RTEMS-5
Annotated Report
Fri Aug 10 12:50:01 2018
400072e0 <_POSIX_Mutex_Auto_initialization>:
#include <rtems/posix/posixapi.h>
#include <string.h>
bool _POSIX_Mutex_Auto_initialization( POSIX_Mutex_Control *the_mutex )
{
400072e0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
zero |= (unsigned long) the_mutex->Priority_ceiling.Node.RBTree.Node.rbe_right;
zero |= (unsigned long) the_mutex->Priority_ceiling.Node.RBTree.Node.rbe_parent;
zero |= (unsigned long) the_mutex->Priority_ceiling.Node.RBTree.Node.rbe_color;
zero |= (unsigned long) the_mutex->Priority_ceiling.priority;
zero |= (unsigned long) (the_mutex->Priority_ceiling.priority >> 32);
zero |= (unsigned long) the_mutex->scheduler;
400072e4: f2 06 20 04 ld [ %i0 + 4 ], %i1
<== NOT EXECUTED
zero |= (unsigned long) the_mutex->Priority_ceiling.priority;
400072e8: de 06 20 30 ld [ %i0 + 0x30 ], %o7
<== NOT EXECUTED
400072ec: da 06 20 34 ld [ %i0 + 0x34 ], %o5
<== NOT EXECUTED
zero |= (unsigned long) the_mutex->scheduler;
400072f0: c4 06 00 00 ld [ %i0 ], %g2
<== NOT EXECUTED
400072f4: d4 06 20 08 ld [ %i0 + 8 ], %o2
<== NOT EXECUTED
400072f8: d6 06 20 18 ld [ %i0 + 0x18 ], %o3
<== NOT EXECUTED
400072fc: f4 06 20 0c ld [ %i0 + 0xc ], %i2
<== NOT EXECUTED
40007300: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
<== NOT EXECUTED
40007304: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
<== NOT EXECUTED
40007308: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
<== NOT EXECUTED
4000730c: c8 06 20 24 ld [ %i0 + 0x24 ], %g4
<== NOT EXECUTED
40007310: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
<== NOT EXECUTED
40007314: d8 06 20 2c ld [ %i0 + 0x2c ], %o4
<== NOT EXECUTED
40007318: c6 06 20 38 ld [ %i0 + 0x38 ], %g3
<== NOT EXECUTED
4000731c: 84 10 80 19 or %g2, %i1, %g2
<== NOT EXECUTED
40007320: 84 10 80 0a or %g2, %o2, %g2
<== NOT EXECUTED
40007324: 84 10 80 0b or %g2, %o3, %g2
<== NOT EXECUTED
40007328: 84 16 80 02 or %i2, %g2, %g2
<== NOT EXECUTED
4000732c: 84 16 c0 02 or %i3, %g2, %g2
<== NOT EXECUTED
40007330: 84 17 00 02 or %i4, %g2, %g2
<== NOT EXECUTED
40007334: 84 17 40 02 or %i5, %g2, %g2
<== NOT EXECUTED
40007338: 84 11 00 02 or %g4, %g2, %g2
<== NOT EXECUTED
4000733c: 82 10 40 02 or %g1, %g2, %g1
<== NOT EXECUTED
40007340: 82 10 40 0c or %g1, %o4, %g1
<== NOT EXECUTED
40007344: 82 10 40 0d or %g1, %o5, %g1
<== NOT EXECUTED
40007348: 82 10 c0 01 or %g3, %g1, %g1
<== NOT EXECUTED
if ( zero != 0 ) {
4000734c: 80 90 40 0f orcc %g1, %o7, %g0
<== NOT EXECUTED
40007350: 12 80 00 08 bne 40007370 <_POSIX_Mutex_Auto_initialization+0x90>
<== NOT EXECUTED
40007354: b2 10 20 00 clr %i1
<== NOT EXECUTED
return false;
}
flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
40007358: 03 25 87 04 sethi %hi(0x961c1000), %g1
<== NOT EXECUTED
4000735c: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 <RAM_END+0x55dc13b8>
<== NOT EXECUTED
40007360: 82 1e 00 01 xor %i0, %g1, %g1
<== NOT EXECUTED
flags &= ~POSIX_MUTEX_FLAGS_MASK;
40007364: 82 08 7f f8 and %g1, -8, %g1
<== NOT EXECUTED
the_mutex->flags = flags;
40007368: c2 26 00 00 st %g1, [ %i0 ]
<== NOT EXECUTED
return true;
4000736c: b2 10 20 01 mov 1, %i1
<== NOT EXECUTED
}
40007370: b0 0e 60 01 and %i1, 1, %i0
<== NOT EXECUTED
40007374: 81 c7 e0 08 ret
<== NOT EXECUTED
40007378: 81 e8 00 00 restore
<== NOT EXECUTED
40013470 <_POSIX_Mutex_Default_attributes>:
40013470: 00 00 00 01 00 00 00 00 7f ff ff ff 00 00 00 00 ................
40013480: 00 00 00 03 00 00 00 00 ........
400070a8 <_POSIX_Mutex_Lock_support>:
int _POSIX_Mutex_Lock_support(
pthread_mutex_t *mutex,
const struct timespec *abstime,
Thread_queue_Enqueue_callout enqueue_callout
)
{
400070a8: 9d e3 bf 70 save %sp, -144, %sp
Thread_queue_Context queue_context;
Thread_Control *executing;
Status_Control status;
the_mutex = _POSIX_Mutex_Get( mutex );
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
400070ac: 80 a6 20 00 cmp %i0, 0
400070b0: 02 80 00 3f be 400071ac <_POSIX_Mutex_Lock_support+0x104>
<== NEVER TAKEN
400070b4: 05 25 87 04 sethi %hi(0x961c1000), %g2
400070b8: fa 06 00 00 ld [ %i0 ], %i5
400070bc: 82 1e 00 1d xor %i0, %i5, %g1
400070c0: 84 10 a3 b8 or %g2, 0x3b8, %g2
400070c4: 82 18 40 02 xor %g1, %g2, %g1
400070c8: 80 88 7f f8 btst -8, %g1
400070cc: 12 80 00 33 bne 40007198 <_POSIX_Mutex_Lock_support+0xf0>
<== NEVER TAKEN
400070d0: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400070d4: 91 d0 20 09 ta 9
<== NOT EXECUTED
)
{
#if defined( RTEMS_SMP )
context->Lock_context.isr_level = level;
#else
context->isr_level = level;
400070d8: c2 27 bf dc st %g1, [ %fp + -36 ]
executing = _POSIX_Mutex_Acquire( the_mutex, &queue_context );
_Thread_queue_Context_set_enqueue_callout( &queue_context, enqueue_callout);
_Thread_queue_Context_set_timeout_argument( &queue_context, abstime );
switch ( _POSIX_Mutex_Get_protocol( flags ) ) {
400070dc: 82 8f 60 03 andcc %i5, 3, %g1
queue_context->enqueue_callout = enqueue_callout;
400070e0: f4 27 bf e4 st %i2, [ %fp + -28 ]
queue_context->Timeout.arg = arg;
400070e4: f2 27 bf e8 st %i1, [ %fp + -24 ]
400070e8: 02 80 00 34 be 400071b8 <_POSIX_Mutex_Lock_support+0x110>
<== NEVER TAKEN
400070ec: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
400070f0: 80 a0 60 02 cmp %g1, 2
400070f4: 12 80 00 10 bne 40007134 <_POSIX_Mutex_Lock_support+0x8c>
400070f8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
{
Thread_Control *owner;
owner = _POSIX_Mutex_Get_owner( the_mutex );
if ( owner == NULL ) {
400070fc: 80 a0 60 00 cmp %g1, 0
40007100: 02 80 00 43 be 4000720c <_POSIX_Mutex_Lock_support+0x164>
<== ALWAYS TAKEN
40007104: 80 a2 00 01 cmp %o0, %g1
executing,
queue_context
);
}
if ( owner == executing ) {
40007108: 02 80 00 18 be 40007168 <_POSIX_Mutex_Lock_support+0xc0>
<== NOT EXECUTED
4000710c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
status = _POSIX_Mutex_Lock_nested( the_mutex, flags );
_POSIX_Mutex_Release( the_mutex, queue_context );
return status;
}
return _POSIX_Mutex_Seize_slow(
40007110: 98 07 bf dc add %fp, -36, %o4
<== NOT EXECUTED
40007114: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
40007118: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000711c: 13 10 00 4d sethi %hi(0x40013400), %o1
<== NOT EXECUTED
40007120: 7f ff ff ca call 40007048 <_POSIX_Mutex_Seize_slow>
<== NOT EXECUTED
40007124: 92 12 61 00 or %o1, 0x100, %o1 ! 40013500 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
40007128: 93 3a 60 08 sra %o1, 8, %o1
<== NOT EXECUTED
);
break;
}
return _POSIX_Get_error( status );
}
4000712c: 81 c7 e0 08 ret
<== NOT EXECUTED
40007130: 91 e8 00 09 restore %g0, %o1, %o0
<== NOT EXECUTED
if ( owner == NULL ) {
40007134: 80 a0 60 00 cmp %g1, 0
40007138: 02 80 00 2e be 400071f0 <_POSIX_Mutex_Lock_support+0x148>
<== ALWAYS TAKEN
4000713c: 80 a2 00 01 cmp %o0, %g1
if ( owner == executing ) {
40007140: 02 80 00 0a be 40007168 <_POSIX_Mutex_Lock_support+0xc0>
<== NOT EXECUTED
40007144: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
return _POSIX_Mutex_Seize_slow(
40007148: 98 07 bf dc add %fp, -36, %o4
<== NOT EXECUTED
4000714c: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
40007150: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40007154: 13 10 00 4d sethi %hi(0x40013400), %o1
<== NOT EXECUTED
40007158: 7f ff ff bc call 40007048 <_POSIX_Mutex_Seize_slow>
<== NOT EXECUTED
4000715c: 92 12 60 ec or %o1, 0xec, %o1 ! 400134ec <_Thread_queue_Operations_priority_inherit>
<== NOT EXECUTED
return _POSIX_Get_error( status );
40007160: 10 80 00 0c b 40007190 <_POSIX_Mutex_Lock_support+0xe8>
<== NOT EXECUTED
40007164: 93 3a 60 08 sra %o1, 8, %o1
<== NOT EXECUTED
if ( _POSIX_Mutex_Is_recursive( flags ) ) {
40007168: 80 8f 60 04 btst 4, %i5
<== NOT EXECUTED
4000716c: 02 80 00 06 be 40007184 <_POSIX_Mutex_Lock_support+0xdc>
<== NOT EXECUTED
40007170: 92 10 20 2d mov 0x2d, %o1
<== NOT EXECUTED
++the_mutex->Recursive.nest_level;
40007174: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
40007178: 82 00 60 01 inc %g1
<== NOT EXECUTED
4000717c: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
<== NOT EXECUTED
40007180: 92 10 20 00 clr %o1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40007184: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007188: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000718c: 01 00 00 00 nop
<== NOT EXECUTED
}
40007190: 81 c7 e0 08 ret
40007194: 91 e8 00 09 restore %g0, %o1, %o0
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40007198: 40 00 00 52 call 400072e0 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
4000719c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400071a0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400071a4: 12 bf ff cc bne 400070d4 <_POSIX_Mutex_Lock_support+0x2c>
<== NOT EXECUTED
400071a8: 01 00 00 00 nop
<== NOT EXECUTED
400071ac: 92 10 20 16 mov 0x16, %o1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
}
400071b0: 81 c7 e0 08 ret
<== NOT EXECUTED
400071b4: 91 e8 00 09 restore %g0, %o1, %o0
<== NOT EXECUTED
400071b8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
<== NOT EXECUTED
if ( owner == NULL ) {
400071bc: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400071c0: 02 80 00 0c be 400071f0 <_POSIX_Mutex_Lock_support+0x148>
<== NOT EXECUTED
400071c4: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
if ( owner == executing ) {
400071c8: 02 bf ff e8 be 40007168 <_POSIX_Mutex_Lock_support+0xc0>
<== NOT EXECUTED
400071cc: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
return _POSIX_Mutex_Seize_slow(
400071d0: 98 07 bf dc add %fp, -36, %o4
<== NOT EXECUTED
400071d4: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
400071d8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400071dc: 13 10 00 4d sethi %hi(0x40013400), %o1
<== NOT EXECUTED
400071e0: 7f ff ff 9a call 40007048 <_POSIX_Mutex_Seize_slow>
<== NOT EXECUTED
400071e4: 92 12 61 14 or %o1, 0x114, %o1 ! 40013514 <_Thread_queue_Operations_FIFO>
<== NOT EXECUTED
400071e8: 10 bf ff ea b 40007190 <_POSIX_Mutex_Lock_support+0xe8>
<== NOT EXECUTED
400071ec: 93 3a 60 08 sra %o1, 8, %o1
<== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
400071f0: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400071f4: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400071f8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400071fc: 01 00 00 00 nop
40007200: 92 10 20 00 clr %o1 ! 0 <PROM_START>
40007204: 81 c7 e0 08 ret
40007208: 91 e8 00 09 restore %g0, %o1, %o0
if (
4000720c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
queue_context->Priority.update_count = 0;
40007210: c0 27 bf f0 clr [ %fp + -16 ]
40007214: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
40007218: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4000721c: 80 a0 c0 02 cmp %g3, %g2
40007220: 18 80 00 09 bgu 40007244 <_POSIX_Mutex_Lock_support+0x19c>
<== NEVER TAKEN
40007224: 01 00 00 00 nop
40007228: 32 80 00 0c bne,a 40007258 <_POSIX_Mutex_Lock_support+0x1b0>
<== NEVER TAKEN
4000722c: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
<== NOT EXECUTED
40007230: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
40007234: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
40007238: 80 a0 80 01 cmp %g2, %g1
4000723c: 28 80 00 07 bleu,a 40007258 <_POSIX_Mutex_Lock_support+0x1b0>
<== ALWAYS TAKEN
40007240: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40007244: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007248: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000724c: 01 00 00 00 nop
<== NOT EXECUTED
40007250: 10 bf ff d8 b 400071b0 <_POSIX_Mutex_Lock_support+0x108>
<== NOT EXECUTED
40007254: 92 10 20 16 mov 0x16, %o1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
_Thread_Priority_add(
40007258: 92 06 20 20 add %i0, 0x20, %o1
4000725c: 40 00 14 e1 call 4000c5e0 <_Thread_Priority_add>
40007260: 94 07 bf dc add %fp, -36, %o2
const ISR_lock_Context *lock_context
)
{
uint32_t disable_level;
disable_level = cpu_self->thread_dispatch_disable_level;
40007264: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
_Profiling_Thread_dispatch_disable_critical(
cpu_self,
disable_level,
lock_context
);
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40007268: 82 00 60 01 inc %g1
<== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Per_CPU_Control *_Thread_Dispatch_disable_critical(
const ISR_lock_Context *lock_context
)
{
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000726c: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40007270: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40007274: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007278: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000727c: 01 00 00 00 nop
_Thread_Priority_update( queue_context );
40007280: 40 00 14 e9 call 4000c624 <_Thread_Priority_update>
40007284: 90 07 bf dc add %fp, -36, %o0
*
* @param[in] cpu_self The current processor.
*/
RTEMS_INLINE_ROUTINE void _Thread_Dispatch_enable( Per_CPU_Control *cpu_self )
{
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
40007288: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
if ( disable_level == 1 ) {
4000728c: 80 a0 60 01 cmp %g1, 1
40007290: 02 80 00 05 be 400072a4 <_POSIX_Mutex_Lock_support+0x1fc>
<== ALWAYS TAKEN
40007294: 82 00 7f ff add %g1, -1, %g1
}
_ISR_Local_enable( level );
} else {
_Assert( disable_level > 0 );
cpu_self->thread_dispatch_disable_level = disable_level - 1;
40007298: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000729c: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
400072a0: 30 bf ff bc b,a 40007190 <_POSIX_Mutex_Lock_support+0xe8>
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400072a4: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
400072a8: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
400072ac: 80 a0 a0 00 cmp %g2, 0
400072b0: 32 80 00 07 bne,a 400072cc <_POSIX_Mutex_Lock_support+0x224>
<== NEVER TAKEN
400072b4: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
400072b8: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400072bc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400072c0: 01 00 00 00 nop
400072c4: 10 bf ff b3 b 40007190 <_POSIX_Mutex_Lock_support+0xe8>
400072c8: 92 10 20 00 clr %o1 ! 0 <PROM_START>
_Thread_Do_dispatch( cpu_self, level );
400072cc: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
400072d0: 40 00 15 5c call 4000c840 <_Thread_Do_dispatch>
<== NOT EXECUTED
400072d4: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
400072d8: 10 bf ff f9 b 400072bc <_POSIX_Mutex_Lock_support+0x214>
<== NOT EXECUTED
400072dc: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
40007048 <_POSIX_Mutex_Seize_slow>:
const Thread_queue_Operations *operations,
Thread_Control *executing,
const struct timespec *abstime,
Thread_queue_Context *queue_context
)
{
40007048: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( (uintptr_t) abstime != POSIX_MUTEX_ABSTIME_TRY_LOCK ) {
4000704c: 80 a6 e0 01 cmp %i3, 1
<== NOT EXECUTED
40007050: 02 80 00 0f be 4000708c <_POSIX_Mutex_Seize_slow+0x44>
<== NOT EXECUTED
40007054: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
queue_context->thread_state = thread_state;
40007058: c2 27 20 04 st %g1, [ %i4 + 4 ]
<== NOT EXECUTED
queue_context->deadlock_callout = deadlock_callout;
4000705c: 03 10 00 33 sethi %hi(0x4000cc00), %g1
<== NOT EXECUTED
40007060: 82 10 63 70 or %g1, 0x370, %g1 ! 4000cf70 <_Thread_queue_Deadlock_status>
<== NOT EXECUTED
40007064: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
<== NOT EXECUTED
);
_Thread_queue_Context_set_deadlock_callout(
queue_context,
_Thread_queue_Deadlock_status
);
_Thread_queue_Enqueue(
40007068: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000706c: 90 06 20 0c add %i0, 0xc, %o0
<== NOT EXECUTED
40007070: 96 10 00 1c mov %i4, %o3
<== NOT EXECUTED
40007074: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
40007078: 40 00 17 c6 call 4000cf90 <_Thread_queue_Enqueue>
<== NOT EXECUTED
4000707c: b0 10 20 00 clr %i0
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Status_Control _Thread_Wait_get_status(
const Thread_Control *the_thread
)
{
return (Status_Control) the_thread->Wait.return_code;
40007080: f2 06 a0 4c ld [ %i2 + 0x4c ], %i1
<== NOT EXECUTED
return _Thread_Wait_get_status( executing );
} else {
_POSIX_Mutex_Release( the_mutex, queue_context );
return STATUS_UNAVAILABLE;
}
}
40007084: 81 c7 e0 08 ret
<== NOT EXECUTED
40007088: 81 e8 00 00 restore
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000708c: c2 07 00 00 ld [ %i4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007090: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007094: 01 00 00 00 nop
<== NOT EXECUTED
40007098: 33 00 00 04 sethi %hi(0x1000), %i1
<== NOT EXECUTED
4000709c: b2 16 60 0d or %i1, 0xd, %i1 ! 100d <_Configuration_Interrupt_stack_size+0xd>
<== NOT EXECUTED
400070a0: 81 c7 e0 08 ret
<== NOT EXECUTED
400070a4: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
400075fc <_POSIX_Priority_To_core>:
Priority_Control _POSIX_Priority_To_core(
const Scheduler_Control *scheduler,
int posix_priority,
bool *valid
)
{
400075fc: 9d e3 bf a0 save %sp, -96, %sp
Priority_Control core_posix_priority;
Priority_Control core_priority;
core_posix_priority = (Priority_Control) posix_priority;
core_priority = scheduler->maximum_priority - core_posix_priority;
40007600: f8 1e 20 40 ldd [ %i0 + 0x40 ], %i4
core_posix_priority = (Priority_Control) posix_priority;
40007604: 83 3e 60 1f sra %i1, 0x1f, %g1
40007608: 86 10 00 19 mov %i1, %g3
4000760c: 84 10 00 01 mov %g1, %g2
*valid = ( posix_priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY
&& core_posix_priority < scheduler->maximum_priority );
40007610: 80 a7 00 01 cmp %i4, %g1
40007614: 18 80 00 05 bgu 40007628 <_POSIX_Priority_To_core+0x2c>
<== NEVER TAKEN
40007618: 88 10 20 01 mov 1, %g4
4000761c: 02 80 00 11 be 40007660 <_POSIX_Priority_To_core+0x64>
<== ALWAYS TAKEN
40007620: 80 a7 40 19 cmp %i5, %i1
40007624: 88 10 20 00 clr %g4
<== NOT EXECUTED
40007628: 82 20 40 19 sub %g1, %i1, %g1
<== NOT EXECUTED
4000762c: 83 30 60 1f srl %g1, 0x1f, %g1
40007630: 82 08 40 04 and %g1, %g4, %g1
*valid = ( posix_priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY
40007634: c2 2e 80 00 stb %g1, [ %i2 ]
core_priority = scheduler->maximum_priority - core_posix_priority;
40007638: b6 a7 40 03 subcc %i5, %g3, %i3
RTEMS_INLINE_ROUTINE Priority_Control _Scheduler_Map_priority(
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
return ( *scheduler->Operations.map_priority )( scheduler, priority );
4000763c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
40007640: b4 67 00 02 subx %i4, %g2, %i2
40007644: 94 10 00 1b mov %i3, %o2
40007648: 92 10 00 1a mov %i2, %o1
4000764c: 9f c0 40 00 call %g1
40007650: 90 10 00 18 mov %i0, %o0
return _Scheduler_Map_priority( scheduler, core_priority );
}
40007654: b0 10 00 08 mov %o0, %i0
40007658: 81 c7 e0 08 ret
4000765c: 93 e8 00 09 restore %g0, %o1, %o1
&& core_posix_priority < scheduler->maximum_priority );
40007660: 38 bf ff f3 bgu,a 4000762c <_POSIX_Priority_To_core+0x30>
<== ALWAYS TAKEN
40007664: 82 20 40 19 sub %g1, %i1, %g1
40007668: 10 bf ff f0 b 40007628 <_POSIX_Priority_To_core+0x2c>
<== NOT EXECUTED
4000766c: 88 10 20 00 clr %g4
<== NOT EXECUTED
40005fac <pthread_getspecific>:
ISR_Level level;
_ISR_Local_disable( level );
#endif
executing = _Thread_Executing;
40005fac: c6 01 a0 20 ld [ %g6 + 0x20 ], %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005fb0: 91 d0 20 09 ta 9
<== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE RBTree_Node * const *_RBTree_Root_const_reference(
const RBTree_Control *the_rbtree
)
{
return &RB_ROOT( the_rbtree );
40005fb4: 86 00 e1 60 add %g3, 0x160, %g3
RBTree_Node *parent;
link = _RBTree_Root_const_reference( the_rbtree );
parent = NULL;
while ( *link != NULL ) {
40005fb8: c4 00 c0 00 ld [ %g3 ], %g2
40005fbc: 80 a0 a0 00 cmp %g2, 0
40005fc0: 02 80 00 0d be 40005ff4 <pthread_getspecific+0x48>
<== ALWAYS TAKEN
40005fc4: 86 00 bf f8 add %g2, -8, %g3
const POSIX_Keys_Key_value_pair *the_right;
the_left = left;
the_right = POSIX_KEYS_RBTREE_NODE_TO_KEY_VALUE_PAIR( right );
return *the_left == the_right->key;
40005fc8: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
<== NOT EXECUTED
parent = *link;
if ( ( *equal )( key, parent ) ) {
40005fcc: 80 a2 00 04 cmp %o0, %g4
<== NOT EXECUTED
40005fd0: 22 80 00 0e be,a 40006008 <pthread_getspecific+0x5c>
<== NOT EXECUTED
40005fd4: d0 00 e0 20 ld [ %g3 + 0x20 ], %o0
<== NOT EXECUTED
return ( *map )( parent );
} else if ( ( *less )( key, parent ) ) {
40005fd8: 1a bf ff f8 bcc 40005fb8 <pthread_getspecific+0xc>
<== NOT EXECUTED
40005fdc: 86 00 a0 04 add %g2, 4, %g3
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
40005fe0: 86 10 00 02 mov %g2, %g3
<== NOT EXECUTED
while ( *link != NULL ) {
40005fe4: c4 00 c0 00 ld [ %g3 ], %g2
<== NOT EXECUTED
40005fe8: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40005fec: 12 bf ff f7 bne 40005fc8 <pthread_getspecific+0x1c>
<== NOT EXECUTED
40005ff0: 86 00 bf f8 add %g2, -8, %g3
<== NOT EXECUTED
key_value_pair = _POSIX_Keys_Key_value_find( key, executing );
if ( key_value_pair != NULL ) {
value = key_value_pair->value;
} else {
value = NULL;
40005ff4: 90 10 20 00 clr %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005ff8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005ffc: 01 00 00 00 nop
}
_POSIX_Keys_Key_value_release( executing, &lock_context );
return value;
}
40006000: 81 c3 e0 08 retl
40006004: 01 00 00 00 nop
40006008: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000600c: 01 00 00 00 nop
<== NOT EXECUTED
40006010: 81 c3 e0 08 retl
<== NOT EXECUTED
40006014: 01 00 00 00 nop
<== NOT EXECUTED
40005f3c <pthread_key_create>:
*/
int pthread_key_create(
pthread_key_t *key,
void (*destructor)( void * )
)
{
40005f3c: 9d e3 bf a0 save %sp, -96, %sp
* the inactive chain of free keys control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void )
{
return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information );
40005f40: 3b 10 00 4e sethi %hi(0x40013800), %i5
40005f44: 40 00 0a da call 40008aac <_Objects_Allocate>
40005f48: 90 17 60 d8 or %i5, 0xd8, %o0 ! 400138d8 <_POSIX_Keys_Information>
POSIX_Keys_Control *the_key;
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
40005f4c: 80 a2 20 00 cmp %o0, 0
40005f50: 02 80 00 13 be 40005f9c <pthread_key_create+0x60>
<== NEVER TAKEN
40005f54: 86 02 20 14 add %o0, 0x14, %g3
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40005f58: c2 12 20 0a lduh [ %o0 + 0xa ], %g1
tail->previous = head;
40005f5c: c6 22 20 1c st %g3, [ %o0 + 0x1c ]
return &the_chain->Tail.Node;
40005f60: 84 02 20 18 add %o0, 0x18, %g2
_Objects_Allocator_unlock();
return EAGAIN;
}
the_key->destructor = destructor;
40005f64: f2 22 20 10 st %i1, [ %o0 + 0x10 ]
40005f68: ba 17 60 d8 or %i5, 0xd8, %i5
head->next = tail;
40005f6c: c4 22 20 14 st %g2, [ %o0 + 0x14 ]
40005f70: 83 28 60 02 sll %g1, 2, %g1
head->previous = NULL;
40005f74: c0 22 20 18 clr [ %o0 + 0x18 ]
Objects_Control *the_object,
uint32_t name
)
{
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
40005f78: c0 22 20 0c clr [ %o0 + 0xc ]
information->local_table[ index ] = the_object;
40005f7c: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
40005f80: c4 02 20 08 ld [ %o0 + 8 ], %g2
40005f84: d0 20 c0 01 st %o0, [ %g3 + %g1 ]
_Chain_Initialize_empty( &the_key->Key_value_pairs );
_Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 );
*key = the_key->Object.id;
40005f88: c4 26 00 00 st %g2, [ %i0 ]
* previous thread life protection state and thus may not return if the
* executing thread was restarted or deleted in the mean-time.
*/
RTEMS_INLINE_ROUTINE void _Objects_Allocator_unlock( void )
{
_RTEMS_Unlock_allocator();
40005f8c: 40 00 04 68 call 4000712c <_RTEMS_Unlock_allocator>
40005f90: b0 10 20 00 clr %i0
_Objects_Allocator_unlock();
return 0;
}
40005f94: 81 c7 e0 08 ret
40005f98: 81 e8 00 00 restore
40005f9c: 40 00 04 64 call 4000712c <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40005fa0: b0 10 20 0b mov 0xb, %i0
<== NOT EXECUTED
return EAGAIN;
40005fa4: 81 c7 e0 08 ret
<== NOT EXECUTED
40005fa8: 81 e8 00 00 restore
<== NOT EXECUTED
40006e58 <pthread_mutex_destroy>:
*/
int pthread_mutex_destroy(
pthread_mutex_t *mutex
)
{
40006e58: 9d e3 bf a0 save %sp, -96, %sp
unsigned long flags;
Thread_queue_Context queue_context;
int eno;
the_mutex = _POSIX_Mutex_Get( mutex );
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40006e5c: 80 a6 20 00 cmp %i0, 0
40006e60: 02 80 00 18 be 40006ec0 <pthread_mutex_destroy+0x68>
<== NEVER TAKEN
40006e64: 05 25 87 04 sethi %hi(0x961c1000), %g2
40006e68: c2 06 00 00 ld [ %i0 ], %g1
40006e6c: 82 1e 00 01 xor %i0, %g1, %g1
40006e70: 84 10 a3 b8 or %g2, 0x3b8, %g2
40006e74: 82 18 40 02 xor %g1, %g2, %g1
40006e78: 80 88 7f f8 btst -8, %g1
40006e7c: 12 80 00 0c bne 40006eac <pthread_mutex_destroy+0x54>
<== NEVER TAKEN
40006e80: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006e84: 91 d0 20 09 ta 9
<== NOT EXECUTED
_POSIX_Mutex_Acquire( the_mutex, &queue_context );
if ( _POSIX_Mutex_Get_owner( the_mutex ) == NULL ) {
40006e88: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
40006e8c: 80 a0 a0 00 cmp %g2, 0
40006e90: 22 80 00 0e be,a 40006ec8 <pthread_mutex_destroy+0x70>
<== ALWAYS TAKEN
40006e94: c4 06 00 00 ld [ %i0 ], %g2
the_mutex->flags = ~the_mutex->flags;
eno = 0;
} else {
eno = EBUSY;
40006e98: b0 10 20 10 mov 0x10, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006e9c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006ea0: 01 00 00 00 nop
<== NOT EXECUTED
}
_POSIX_Mutex_Release( the_mutex, &queue_context );
return eno;
}
40006ea4: 81 c7 e0 08 ret
<== NOT EXECUTED
40006ea8: 81 e8 00 00 restore
<== NOT EXECUTED
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40006eac: 40 00 01 0d call 400072e0 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
40006eb0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40006eb4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40006eb8: 12 bf ff f3 bne 40006e84 <pthread_mutex_destroy+0x2c>
<== NOT EXECUTED
40006ebc: 01 00 00 00 nop
<== NOT EXECUTED
40006ec0: 81 c7 e0 08 ret
<== NOT EXECUTED
40006ec4: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
the_mutex->flags = ~the_mutex->flags;
40006ec8: 84 38 00 02 xnor %g0, %g2, %g2
<== NOT EXECUTED
40006ecc: c4 26 00 00 st %g2, [ %i0 ]
<== NOT EXECUTED
eno = 0;
40006ed0: b0 10 20 00 clr %i0
<== NOT EXECUTED
40006ed4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006ed8: 01 00 00 00 nop
}
40006edc: 81 c7 e0 08 ret
40006ee0: 81 e8 00 00 restore
40006ee4 <pthread_mutex_init>:
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr
)
{
40006ee4: 9d e3 bf 98 save %sp, -104, %sp
POSIX_Mutex_Protocol protocol;
unsigned long flags;
Priority_Control priority;
const Scheduler_Control *scheduler;
if ( attr ) the_attr = attr;
40006ee8: 80 a6 60 00 cmp %i1, 0
40006eec: 02 80 00 0f be 40006f28 <pthread_mutex_init+0x44>
<== NEVER TAKEN
40006ef0: ba 10 00 18 mov %i0, %i5
else the_attr = &_POSIX_Mutex_Default_attributes;
/* Check for NULL mutex */
if ( !mutex )
40006ef4: 80 a6 20 00 cmp %i0, 0
40006ef8: 02 80 00 44 be 40007008 <pthread_mutex_init+0x124>
<== NEVER TAKEN
40006efc: 01 00 00 00 nop
* value in an uninitialized variable to make this fail.
*
* Thus, we do not look at *mutex.
*/
if ( !the_attr->is_initialized )
40006f00: c2 06 40 00 ld [ %i1 ], %g1
40006f04: 80 a0 60 00 cmp %g1, 0
40006f08: 02 80 00 06 be 40006f20 <pthread_mutex_init+0x3c>
<== NEVER TAKEN
40006f0c: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( !_POSIX_Is_valid_pshared( the_attr->process_shared ) ) {
40006f10: c2 06 60 04 ld [ %i1 + 4 ], %g1
40006f14: 80 a0 60 01 cmp %g1, 1
40006f18: 28 80 00 16 bleu,a 40006f70 <pthread_mutex_init+0x8c>
<== ALWAYS TAKEN
40006f1c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
);
the_mutex->Recursive.nest_level = 0;
_Priority_Node_initialize( &the_mutex->Priority_ceiling, priority );
the_mutex->scheduler = scheduler;
return 0;
}
40006f20: 81 c7 e0 08 ret
<== NOT EXECUTED
40006f24: 81 e8 00 00 restore
<== NOT EXECUTED
if ( !mutex )
40006f28: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
40006f2c: 02 80 00 37 be 40007008 <pthread_mutex_init+0x124>
<== NOT EXECUTED
40006f30: 03 25 87 04 sethi %hi(0x961c1000), %g1
<== NOT EXECUTED
flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
40006f34: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 <RAM_END+0x55dc13b8>
<== NOT EXECUTED
40006f38: 82 1e 00 01 xor %i0, %g1, %g1
<== NOT EXECUTED
flags &= ~POSIX_MUTEX_FLAGS_MASK;
40006f3c: 82 08 7f f8 and %g1, -8, %g1
<== NOT EXECUTED
the_mutex->flags = flags;
40006f40: c2 26 00 00 st %g1, [ %i0 ]
<== NOT EXECUTED
scheduler = NULL;
40006f44: 84 10 20 00 clr %g2
<== NOT EXECUTED
priority = 0;
40006f48: 90 10 20 00 clr %o0
<== NOT EXECUTED
40006f4c: 92 10 20 00 clr %o1
<== NOT EXECUTED
)
{
#if defined(RTEMS_SMP)
_SMP_ticket_lock_Initialize( &queue->Lock );
#endif
queue->heads = NULL;
40006f50: c0 27 60 0c clr [ %i5 + 0xc ]
queue->owner = NULL;
40006f54: c0 27 60 10 clr [ %i5 + 0x10 ]
queue->name = name;
40006f58: c0 27 60 14 clr [ %i5 + 0x14 ]
the_mutex->Recursive.nest_level = 0;
40006f5c: c0 27 60 18 clr [ %i5 + 0x18 ]
RTEMS_INLINE_ROUTINE void _Priority_Node_initialize(
Priority_Node *node,
Priority_Control priority
)
{
node->priority = priority;
40006f60: d0 3f 60 30 std %o0, [ %i5 + 0x30 ]
the_mutex->scheduler = scheduler;
40006f64: c4 27 60 38 st %g2, [ %i5 + 0x38 ]
return 0;
40006f68: 81 c7 e0 08 ret
40006f6c: 91 e8 20 00 restore %g0, 0, %o0
switch ( the_attr->protocol ) {
40006f70: 80 a0 60 01 cmp %g1, 1
40006f74: 02 80 00 27 be 40007010 <pthread_mutex_init+0x12c>
40006f78: 80 a0 60 02 cmp %g1, 2
40006f7c: 02 80 00 27 be 40007018 <pthread_mutex_init+0x134>
<== ALWAYS TAKEN
40006f80: 80 a0 60 00 cmp %g1, 0
40006f84: 12 bf ff e7 bne 40006f20 <pthread_mutex_init+0x3c>
<== NOT EXECUTED
40006f88: 84 10 20 00 clr %g2
<== NOT EXECUTED
switch ( the_attr->type ) {
40006f8c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
40006f90: 80 a0 60 03 cmp %g1, 3
40006f94: 18 bf ff e3 bgu 40006f20 <pthread_mutex_init+0x3c>
<== NEVER TAKEN
40006f98: b0 10 20 16 mov 0x16, %i0
if ( the_attr->type == PTHREAD_MUTEX_RECURSIVE ) {
40006f9c: 80 a0 60 01 cmp %g1, 1
flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
40006fa0: 03 25 87 04 sethi %hi(0x961c1000), %g1
40006fa4: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 <RAM_END+0x55dc13b8>
40006fa8: 82 1f 40 01 xor %i5, %g1, %g1
flags &= ~POSIX_MUTEX_FLAGS_MASK;
40006fac: 82 08 7f f8 and %g1, -8, %g1
if ( the_attr->type == PTHREAD_MUTEX_RECURSIVE ) {
40006fb0: 12 80 00 03 bne 40006fbc <pthread_mutex_init+0xd8>
<== ALWAYS TAKEN
40006fb4: 82 10 80 01 or %g2, %g1, %g1
flags |= POSIX_MUTEX_RECURSIVE;
40006fb8: 82 10 60 04 or %g1, 4, %g1
<== NOT EXECUTED
if ( protocol == POSIX_MUTEX_PRIORITY_CEILING ) {
40006fbc: 80 a0 a0 02 cmp %g2, 2
40006fc0: 12 80 00 18 bne 40007020 <pthread_mutex_init+0x13c>
40006fc4: c2 27 40 00 st %g1, [ %i5 ]
prio_ceiling = the_attr->prio_ceiling;
40006fc8: d2 06 60 08 ld [ %i1 + 8 ], %o1
if ( prio_ceiling == INT_MAX ) {
40006fcc: 03 1f ff ff sethi %hi(0x7ffffc00), %g1
40006fd0: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff <RAM_END+0x3fbfffff>
40006fd4: 80 a2 40 01 cmp %o1, %g1
40006fd8: 12 80 00 05 bne 40006fec <pthread_mutex_init+0x108>
<== ALWAYS TAKEN
40006fdc: 39 10 00 4b sethi %hi(0x40012c00), %i4
RTEMS_INLINE_ROUTINE int _POSIX_Priority_Get_maximum(
const Scheduler_Control *scheduler
)
{
_Assert( (int) scheduler->maximum_priority > 1 );
return (int) scheduler->maximum_priority - 1;
40006fe0: 82 17 22 98 or %i4, 0x298, %g1 ! 40012e98 <_Scheduler_Table>
<== NOT EXECUTED
40006fe4: d2 00 60 44 ld [ %g1 + 0x44 ], %o1
<== NOT EXECUTED
40006fe8: 92 02 7f ff add %o1, -1, %o1
<== NOT EXECUTED
priority = _POSIX_Priority_To_core( scheduler, prio_ceiling, &valid );
40006fec: 94 07 bf ff add %fp, -1, %o2
40006ff0: 40 00 01 83 call 400075fc <_POSIX_Priority_To_core>
40006ff4: 90 17 22 98 or %i4, 0x298, %o0
if ( !valid ) {
40006ff8: c2 0f bf ff ldub [ %fp + -1 ], %g1
40006ffc: 80 a0 60 00 cmp %g1, 0
40007000: 12 bf ff d4 bne 40006f50 <pthread_mutex_init+0x6c>
<== ALWAYS TAKEN
40007004: 84 17 22 98 or %i4, 0x298, %g2
return EINVAL;
40007008: 81 c7 e0 08 ret
<== NOT EXECUTED
4000700c: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
protocol = POSIX_MUTEX_PRIORITY_INHERIT;
40007010: 10 bf ff df b 40006f8c <pthread_mutex_init+0xa8>
40007014: 84 10 20 01 mov 1, %g2
break;
40007018: 10 bf ff dd b 40006f8c <pthread_mutex_init+0xa8>
4000701c: 84 10 20 02 mov 2, %g2
scheduler = NULL;
40007020: 84 10 20 00 clr %g2
priority = 0;
40007024: 90 10 20 00 clr %o0
40007028: 10 bf ff ca b 40006f50 <pthread_mutex_init+0x6c>
4000702c: 92 10 20 00 clr %o1
4000737c <pthread_mutex_unlock>:
*/
int pthread_mutex_unlock(
pthread_mutex_t *mutex
)
{
4000737c: 9d e3 bf 70 save %sp, -144, %sp
Thread_queue_Context queue_context;
Thread_Control *executing;
Status_Control status;
the_mutex = _POSIX_Mutex_Get( mutex );
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40007380: 80 a6 20 00 cmp %i0, 0
40007384: 02 80 00 32 be 4000744c <pthread_mutex_unlock+0xd0>
<== NEVER TAKEN
40007388: 05 25 87 04 sethi %hi(0x961c1000), %g2
4000738c: fa 06 00 00 ld [ %i0 ], %i5
40007390: 82 1e 00 1d xor %i0, %i5, %g1
40007394: 84 10 a3 b8 or %g2, 0x3b8, %g2
40007398: 82 18 40 02 xor %g1, %g2, %g1
4000739c: 80 88 7f f8 btst -8, %g1
400073a0: 12 80 00 26 bne 40007438 <pthread_mutex_unlock+0xbc>
<== NEVER TAKEN
400073a4: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400073a8: 91 d0 20 09 ta 9
<== NOT EXECUTED
400073ac: c2 27 bf dc st %g1, [ %fp + -36 ]
executing = _POSIX_Mutex_Acquire( the_mutex, &queue_context );
switch ( _POSIX_Mutex_Get_protocol( flags ) ) {
400073b0: ba 8f 60 03 andcc %i5, 3, %i5
400073b4: 02 80 00 28 be 40007454 <pthread_mutex_unlock+0xd8>
<== NEVER TAKEN
400073b8: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
400073bc: 80 a7 60 02 cmp %i5, 2
400073c0: 12 80 00 0a bne 400073e8 <pthread_mutex_unlock+0x6c>
400073c4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
unsigned int nest_level;
ISR_lock_Context lock_context;
Per_CPU_Control *cpu_self;
Thread_queue_Heads *heads;
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
400073c8: 80 a2 00 01 cmp %o0, %g1
400073cc: 22 80 00 37 be,a 400074a8 <pthread_mutex_unlock+0x12c>
<== ALWAYS TAKEN
400073d0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400073d4: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400073d8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400073dc: 01 00 00 00 nop
<== NOT EXECUTED
400073e0: 81 c7 e0 08 ret
<== NOT EXECUTED
400073e4: 91 e8 20 01 restore %g0, 1, %o0
<== NOT EXECUTED
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
400073e8: 80 a2 00 01 cmp %o0, %g1
400073ec: 12 bf ff fa bne 400073d4 <pthread_mutex_unlock+0x58>
<== NEVER TAKEN
400073f0: 01 00 00 00 nop
nest_level = the_mutex->Recursive.nest_level;
400073f4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
if ( nest_level > 0 ) {
400073f8: 80 a0 60 00 cmp %g1, 0
400073fc: 12 80 00 2e bne 400074b4 <pthread_mutex_unlock+0x138>
<== NEVER TAKEN
40007400: 82 00 7f ff add %g1, -1, %g1
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40007404: c0 26 20 10 clr [ %i0 + 0x10 ]
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
40007408: d2 06 20 0c ld [ %i0 + 0xc ], %o1
if ( heads == NULL ) {
4000740c: 80 a2 60 00 cmp %o1, 0
40007410: 02 80 00 2f be 400074cc <pthread_mutex_unlock+0x150>
<== ALWAYS TAKEN
40007414: 94 10 00 08 mov %o0, %o2
_Thread_queue_Surrender(
40007418: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
4000741c: 90 06 20 0c add %i0, 0xc, %o0
<== NOT EXECUTED
40007420: 19 10 00 4d sethi %hi(0x40013400), %o4
<== NOT EXECUTED
40007424: b0 10 20 00 clr %i0
<== NOT EXECUTED
40007428: 40 00 17 91 call 4000d26c <_Thread_queue_Surrender>
<== NOT EXECUTED
4000742c: 98 13 20 ec or %o4, 0xec, %o4
<== NOT EXECUTED
);
break;
}
return _POSIX_Get_error( status );
}
40007430: 81 c7 e0 08 ret
<== NOT EXECUTED
40007434: 81 e8 00 00 restore
<== NOT EXECUTED
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40007438: 7f ff ff aa call 400072e0 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
4000743c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40007440: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40007444: 12 bf ff d9 bne 400073a8 <pthread_mutex_unlock+0x2c>
<== NOT EXECUTED
40007448: 01 00 00 00 nop
<== NOT EXECUTED
4000744c: 81 c7 e0 08 ret
<== NOT EXECUTED
40007450: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
40007454: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
<== NOT EXECUTED
40007458: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
4000745c: 12 bf ff de bne 400073d4 <pthread_mutex_unlock+0x58>
<== NOT EXECUTED
40007460: 01 00 00 00 nop
<== NOT EXECUTED
nest_level = the_mutex->Recursive.nest_level;
40007464: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
if ( nest_level > 0 ) {
40007468: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000746c: 12 80 00 12 bne 400074b4 <pthread_mutex_unlock+0x138>
<== NOT EXECUTED
40007470: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40007474: c0 26 20 10 clr [ %i0 + 0x10 ]
<== NOT EXECUTED
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
40007478: d2 06 20 0c ld [ %i0 + 0xc ], %o1
<== NOT EXECUTED
if ( heads == NULL ) {
4000747c: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
40007480: 02 80 00 13 be 400074cc <pthread_mutex_unlock+0x150>
<== NOT EXECUTED
40007484: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
_Thread_queue_Surrender(
40007488: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
4000748c: 90 06 20 0c add %i0, 0xc, %o0
<== NOT EXECUTED
40007490: 19 10 00 4d sethi %hi(0x40013400), %o4
<== NOT EXECUTED
40007494: b0 10 20 00 clr %i0
<== NOT EXECUTED
40007498: 40 00 17 75 call 4000d26c <_Thread_queue_Surrender>
<== NOT EXECUTED
4000749c: 98 13 21 14 or %o4, 0x114, %o4
<== NOT EXECUTED
400074a0: 81 c7 e0 08 ret
<== NOT EXECUTED
400074a4: 81 e8 00 00 restore
<== NOT EXECUTED
return STATUS_NOT_OWNER;
}
nest_level = the_mutex->Recursive.nest_level;
if ( nest_level > 0 ) {
400074a8: 80 a0 60 00 cmp %g1, 0
400074ac: 02 80 00 0d be 400074e0 <pthread_mutex_unlock+0x164>
<== ALWAYS TAKEN
400074b0: 82 00 7f ff add %g1, -1, %g1
the_mutex->Recursive.nest_level = nest_level - 1;
400074b4: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400074b8: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400074bc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400074c0: 01 00 00 00 nop
<== NOT EXECUTED
400074c4: 81 c7 e0 08 ret
<== NOT EXECUTED
400074c8: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400074cc: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400074d0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400074d4: 01 00 00 00 nop
400074d8: 81 c7 e0 08 ret
400074dc: 91 e8 20 00 restore %g0, 0, %o0
400074e0: c0 27 bf f0 clr [ %fp + -16 ]
_Thread_Resource_count_decrement( executing );
_Thread_queue_Context_clear_priority_updates( queue_context );
_Thread_Wait_acquire_default_critical( executing, &lock_context );
_Thread_Priority_remove(
400074e4: b6 06 20 20 add %i0, 0x20, %i3
400074e8: 94 07 bf dc add %fp, -36, %o2
400074ec: 40 00 14 42 call 4000c5f4 <_Thread_Priority_remove>
400074f0: 92 10 00 1b mov %i3, %o1
disable_level = cpu_self->thread_dispatch_disable_level;
400074f4: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
400074f8: 82 00 60 01 inc %g1
400074fc: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
);
_Thread_Wait_release_default_critical( executing, &lock_context );
cpu_self = _Thread_queue_Dispatch_disable( queue_context );
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
40007500: d0 06 20 0c ld [ %i0 + 0xc ], %o0
if ( heads != NULL ) {
40007504: 80 a2 20 00 cmp %o0, 0
40007508: 02 80 00 2a be 400075b0 <pthread_mutex_unlock+0x234>
<== ALWAYS TAKEN
4000750c: ba 10 00 06 mov %g6, %i5
const Thread_queue_Operations *operations;
Thread_Control *new_owner;
operations = POSIX_MUTEX_PRIORITY_CEILING_TQ_OPERATIONS;
new_owner = ( *operations->first )( heads );
40007510: 39 10 00 4d sethi %hi(0x40013400), %i4
<== NOT EXECUTED
40007514: b8 17 21 00 or %i4, 0x100, %i4 ! 40013500 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
40007518: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
<== NOT EXECUTED
4000751c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007520: 01 00 00 00 nop
<== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40007524: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
<== NOT EXECUTED
new_owner = ( *operations->first )( heads );
40007528: b4 10 00 08 mov %o0, %i2
<== NOT EXECUTED
_POSIX_Mutex_Set_owner( the_mutex, new_owner );
_Thread_Resource_count_increment( new_owner );
_Thread_Priority_add(
4000752c: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
40007530: 40 00 14 2c call 4000c5e0 <_Thread_Priority_add>
<== NOT EXECUTED
40007534: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
new_owner,
&the_mutex->Priority_ceiling,
queue_context
);
_Thread_queue_Extract_critical(
40007538: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
4000753c: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
40007540: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
40007544: 40 00 17 09 call 4000d168 <_Thread_queue_Extract_critical>
<== NOT EXECUTED
40007548: 90 06 20 0c add %i0, 0xc, %o0
<== NOT EXECUTED
} else {
_POSIX_Mutex_Set_owner( the_mutex, NULL );
_POSIX_Mutex_Release( the_mutex, queue_context );
}
_Thread_Priority_update( queue_context );
4000754c: 40 00 14 36 call 4000c624 <_Thread_Priority_update>
40007550: 90 07 bf dc add %fp, -36, %o0
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
40007554: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
if ( disable_level == 1 ) {
40007558: 80 a0 60 01 cmp %g1, 1
4000755c: 02 80 00 06 be 40007574 <pthread_mutex_unlock+0x1f8>
<== ALWAYS TAKEN
40007560: 82 00 7f ff add %g1, -1, %g1
cpu_self->thread_dispatch_disable_level = disable_level - 1;
40007564: b0 10 20 00 clr %i0
<== NOT EXECUTED
40007568: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
4000756c: 81 c7 e0 08 ret
<== NOT EXECUTED
40007570: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007574: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
40007578: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
4000757c: 80 a0 a0 00 cmp %g2, 0
40007580: 12 80 00 07 bne 4000759c <pthread_mutex_unlock+0x220>
<== NEVER TAKEN
40007584: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
40007588: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000758c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007590: 01 00 00 00 nop
40007594: 81 c7 e0 08 ret
40007598: 91 e8 20 00 restore %g0, 0, %o0
_Thread_Do_dispatch( cpu_self, level );
4000759c: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
400075a0: 40 00 14 a8 call 4000c840 <_Thread_Do_dispatch>
<== NOT EXECUTED
400075a4: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
400075a8: 10 bf ff f9 b 4000758c <pthread_mutex_unlock+0x210>
<== NOT EXECUTED
400075ac: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
400075b0: c0 26 20 10 clr [ %i0 + 0x10 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400075b4: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400075b8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400075bc: 01 00 00 00 nop
400075c0: 30 bf ff e3 b,a 4000754c <pthread_mutex_unlock+0x1d0>
40006d70 <pthread_mutexattr_destroy>:
*/
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( attr == NULL || !attr->is_initialized )
40006d70: 82 92 20 00 orcc %o0, 0, %g1
40006d74: 02 80 00 09 be 40006d98 <pthread_mutexattr_destroy+0x28>
<== NEVER TAKEN
40006d78: 90 10 20 16 mov 0x16, %o0
40006d7c: c4 00 40 00 ld [ %g1 ], %g2
40006d80: 80 a0 a0 00 cmp %g2, 0
40006d84: 02 80 00 05 be 40006d98 <pthread_mutexattr_destroy+0x28>
<== NEVER TAKEN
40006d88: 01 00 00 00 nop
return EINVAL;
attr->is_initialized = false;
40006d8c: c0 20 40 00 clr [ %g1 ]
return 0;
40006d90: 81 c3 e0 08 retl
40006d94: 90 10 20 00 clr %o0
}
40006d98: 81 c3 e0 08 retl
<== NOT EXECUTED
40006d9c: 01 00 00 00 nop
<== NOT EXECUTED
40006da0 <pthread_mutexattr_init>:
*/
int pthread_mutexattr_init(
pthread_mutexattr_t *attr
)
{
if ( attr == NULL )
40006da0: 82 92 20 00 orcc %o0, 0, %g1
40006da4: 02 80 00 11 be 40006de8 <pthread_mutexattr_init+0x48>
<== NEVER TAKEN
40006da8: 07 10 00 4d sethi %hi(0x40013400), %g3
return EINVAL;
*attr = _POSIX_Mutex_Default_attributes;
40006dac: 84 10 e0 70 or %g3, 0x70, %g2 ! 40013470 <_POSIX_Mutex_Default_attributes>
40006db0: d6 00 e0 70 ld [ %g3 + 0x70 ], %o3
40006db4: d8 00 a0 04 ld [ %g2 + 4 ], %o4
40006db8: da 00 a0 08 ld [ %g2 + 8 ], %o5
40006dbc: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
40006dc0: c6 00 a0 10 ld [ %g2 + 0x10 ], %g3
40006dc4: c4 00 a0 14 ld [ %g2 + 0x14 ], %g2
40006dc8: d6 20 40 00 st %o3, [ %g1 ]
return 0;
40006dcc: 90 10 20 00 clr %o0
*attr = _POSIX_Mutex_Default_attributes;
40006dd0: d8 20 60 04 st %o4, [ %g1 + 4 ]
40006dd4: da 20 60 08 st %o5, [ %g1 + 8 ]
40006dd8: c8 20 60 0c st %g4, [ %g1 + 0xc ]
40006ddc: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
return 0;
40006de0: 81 c3 e0 08 retl
40006de4: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
}
40006de8: 81 c3 e0 08 retl
<== NOT EXECUTED
40006dec: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
40006df0 <pthread_mutexattr_setprioceiling>:
int pthread_mutexattr_setprioceiling(
pthread_mutexattr_t *attr,
int prioceiling
)
{
if ( !attr || !attr->is_initialized )
40006df0: 82 92 20 00 orcc %o0, 0, %g1
40006df4: 02 80 00 09 be 40006e18 <pthread_mutexattr_setprioceiling+0x28>
<== NEVER TAKEN
40006df8: 90 10 20 16 mov 0x16, %o0
40006dfc: c4 00 40 00 ld [ %g1 ], %g2
40006e00: 80 a0 a0 00 cmp %g2, 0
40006e04: 02 80 00 05 be 40006e18 <pthread_mutexattr_setprioceiling+0x28>
<== NEVER TAKEN
40006e08: 01 00 00 00 nop
return EINVAL;
attr->prio_ceiling = prioceiling;
40006e0c: d2 20 60 08 st %o1, [ %g1 + 8 ]
return 0;
40006e10: 81 c3 e0 08 retl
40006e14: 90 10 20 00 clr %o0
}
40006e18: 81 c3 e0 08 retl
<== NOT EXECUTED
40006e1c: 01 00 00 00 nop
<== NOT EXECUTED
40006e20 <pthread_mutexattr_setprotocol>:
int pthread_mutexattr_setprotocol(
pthread_mutexattr_t *attr,
int protocol
)
{
if ( !attr || !attr->is_initialized )
40006e20: 82 92 20 00 orcc %o0, 0, %g1
40006e24: 02 80 00 0b be 40006e50 <pthread_mutexattr_setprotocol+0x30>
<== NEVER TAKEN
40006e28: 90 10 20 16 mov 0x16, %o0
40006e2c: c4 00 40 00 ld [ %g1 ], %g2
40006e30: 80 a0 a0 00 cmp %g2, 0
40006e34: 02 80 00 07 be 40006e50 <pthread_mutexattr_setprotocol+0x30>
<== NEVER TAKEN
40006e38: 80 a2 60 02 cmp %o1, 2
return EINVAL;
switch ( protocol ) {
40006e3c: 18 80 00 05 bgu 40006e50 <pthread_mutexattr_setprotocol+0x30>
<== NEVER TAKEN
40006e40: 01 00 00 00 nop
case PTHREAD_PRIO_NONE:
case PTHREAD_PRIO_INHERIT:
case PTHREAD_PRIO_PROTECT:
attr->protocol = protocol;
40006e44: d2 20 60 0c st %o1, [ %g1 + 0xc ]
return 0;
40006e48: 81 c3 e0 08 retl
40006e4c: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
40006e50: 81 c3 e0 08 retl
<== NOT EXECUTED
40006e54: 01 00 00 00 nop
<== NOT EXECUTED
40006ff0 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
40006ff0: 80 a2 20 00 cmp %o0, 0
40006ff4: 02 80 00 07 be 40007010 <pthread_once+0x20>
<== NEVER TAKEN
40006ff8: 80 a2 60 00 cmp %o1, 0
40006ffc: 02 80 00 05 be 40007010 <pthread_once+0x20>
<== NEVER TAKEN
40007000: 01 00 00 00 nop
return EINVAL;
return _Once( &once_control->_flags, init_routine );
40007004: 82 13 c0 00 mov %o7, %g1
40007008: 40 00 0a 03 call 40009814 <_Once>
4000700c: 9e 10 40 00 mov %g1, %o7
}
40007010: 81 c3 e0 08 retl
<== NOT EXECUTED
40007014: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
400075d4 <pthread_spin_lock>:
sizeof( POSIX_Spinlock_Control ) == sizeof( pthread_spinlock_t ),
POSIX_SPINLOCK_T_SIZE
);
int pthread_spin_lock( pthread_spinlock_t *spinlock )
{
400075d4: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400075d8: 91 d0 20 09 ta 9
<== NOT EXECUTED
&cpu_self->Lock_stats_context
);
#endif
the_spinlock->interrupt_state = level;
return 0;
}
400075dc: 90 10 20 00 clr %o0
400075e0: 81 c3 e0 08 retl
400075e4: c2 20 a0 08 st %g1, [ %g2 + 8 ]
400075e8 <pthread_spin_unlock>:
{
POSIX_Spinlock_Control *the_spinlock;
ISR_Level level;
the_spinlock = _POSIX_Spinlock_Get( lock );
level = the_spinlock->interrupt_state;
400075e8: c2 02 20 08 ld [ %o0 + 8 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400075ec: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400075f0: 01 00 00 00 nop
&_Per_CPU_Get()->Lock_stats_context
);
#endif
_ISR_Local_enable( level );
return 0;
}
400075f4: 81 c3 e0 08 retl
400075f8: 90 10 20 00 clr %o0 ! 0 <PROM_START>
40007670 <sched_get_priority_max>:
#include <rtems/score/schedulerimpl.h>
int sched_get_priority_max(
int policy
)
{
40007670: 9d e3 bf a0 save %sp, -96, %sp
40007674: 80 a6 20 04 cmp %i0, 4
40007678: 18 80 00 09 bgu 4000769c <sched_get_priority_max+0x2c>
<== NEVER TAKEN
4000767c: 82 10 20 01 mov 1, %g1
40007680: b1 28 40 18 sll %g1, %i0, %i0
40007684: 80 8e 20 17 btst 0x17, %i0
40007688: 02 80 00 05 be 4000769c <sched_get_priority_max+0x2c>
<== NEVER TAKEN
4000768c: 03 10 00 4b sethi %hi(0x40012c00), %g1
40007690: f0 00 62 dc ld [ %g1 + 0x2dc ], %i0 ! 40012edc <_Scheduler_Table+0x44>
rtems_set_errno_and_return_minus_one( EINVAL );
}
scheduler = _Thread_Scheduler_get_home( _Thread_Get_executing() );
return _POSIX_Priority_Get_maximum( scheduler );
}
40007694: 81 c7 e0 08 ret
40007698: 91 ee 3f ff restore %i0, -1, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
4000769c: 40 00 28 5d call 40011810 <__errno>
<== NOT EXECUTED
400076a0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400076a4: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400076a8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400076ac: 81 c7 e0 08 ret
<== NOT EXECUTED
400076b0: 81 e8 00 00 restore
<== NOT EXECUTED