RTEMS-5
Annotated Report
Fri Aug 10 13:41:31 2018
40014580 <_POSIX_Keys_Key_value_allocate>:
uint32_t max = Configuration.maximum_key_value_pairs;
40014580: 03 10 00 78 sethi %hi(0x4001e000), %g1
40014584: c2 00 62 98 ld [ %g1 + 0x298 ], %g1 ! 4001e298 <Configuration+0x10>
_Objects_Maximum_per_allocation( max ) : 0;
40014588: 80 a0 60 00 cmp %g1, 0
4001458c: 16 80 00 05 bge 400145a0 <_POSIX_Keys_Key_value_allocate+0x20>
<== ALWAYS TAKEN
40014590: 94 10 20 00 clr %o2
40014594: 15 00 00 3f sethi %hi(0xfc00), %o2
<== NOT EXECUTED
40014598: 94 12 a3 ff or %o2, 0x3ff, %o2 ! ffff <_Configuration_Interrupt_stack_size+0xefff>
<== NOT EXECUTED
4001459c: 94 08 40 0a and %g1, %o2, %o2
<== NOT EXECUTED
return (POSIX_Keys_Key_value_pair *) _Freechain_Get(
400145a0: 13 10 00 69 sethi %hi(0x4001a400), %o1
400145a4: 11 10 01 19 sethi %hi(0x40046400), %o0
400145a8: 96 10 20 24 mov 0x24, %o3
400145ac: 92 12 60 c8 or %o1, 0xc8, %o1
400145b0: 90 12 22 d4 or %o0, 0x2d4, %o0
400145b4: 82 13 c0 00 mov %o7, %g1
400145b8: 40 00 01 c4 call 40014cc8 <_Freechain_Get>
400145bc: 9e 10 40 00 mov %g1, %o7
40010b80 <nanosleep>:
{
40010b80: 9d e3 bf a0 save %sp, -96, %sp
40010b84: 92 10 20 00 clr %o1
40010b88: 94 10 00 18 mov %i0, %o2
40010b8c: 96 10 00 19 mov %i1, %o3
40010b90: 7f ff ff 8e call 400109c8 <clock_nanosleep.part.6>
40010b94: 90 10 20 01 mov 1, %o0
if ( eno != 0 ) {
40010b98: b0 92 20 00 orcc %o0, 0, %i0
40010b9c: 12 80 00 04 bne 40010bac <nanosleep+0x2c>
<== NEVER TAKEN
40010ba0: 01 00 00 00 nop
}
40010ba4: 81 c7 e0 08 ret
40010ba8: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( eno );
40010bac: 7f ff fa dc call 4000f71c <__errno>
<== NOT EXECUTED
40010bb0: 01 00 00 00 nop
<== NOT EXECUTED
40010bb4: f0 22 00 00 st %i0, [ %o0 ]
<== NOT EXECUTED
}
40010bb8: 81 c7 e0 08 ret
<== NOT EXECUTED
40010bbc: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
40009650 <pthread_getspecific>:
ISR_Level level;
_ISR_Local_disable( level );
#endif
executing = _Thread_Executing;
40009650: c6 01 a0 20 ld [ %g6 + 0x20 ], %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40009654: 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 );
40009658: 86 00 e1 60 add %g3, 0x160, %g3
RBTree_Node *parent;
link = _RBTree_Root_const_reference( the_rbtree );
parent = NULL;
while ( *link != NULL ) {
4000965c: c4 00 c0 00 ld [ %g3 ], %g2
40009660: 80 a0 a0 00 cmp %g2, 0
40009664: 02 80 00 0d be 40009698 <pthread_getspecific+0x48>
40009668: 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;
4000966c: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
parent = *link;
if ( ( *equal )( key, parent ) ) {
40009670: 80 a2 00 04 cmp %o0, %g4
40009674: 22 80 00 0e be,a 400096ac <pthread_getspecific+0x5c>
<== ALWAYS TAKEN
40009678: d0 00 e0 20 ld [ %g3 + 0x20 ], %o0
return ( *map )( parent );
} else if ( ( *less )( key, parent ) ) {
4000967c: 1a bf ff f8 bcc 4000965c <pthread_getspecific+0xc>
<== NOT EXECUTED
40009680: 86 00 a0 04 add %g2, 4, %g3
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
40009684: 86 10 00 02 mov %g2, %g3
<== NOT EXECUTED
while ( *link != NULL ) {
40009688: c4 00 c0 00 ld [ %g3 ], %g2
<== NOT EXECUTED
4000968c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40009690: 12 bf ff f7 bne 4000966c <pthread_getspecific+0x1c>
<== NOT EXECUTED
40009694: 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;
40009698: 90 10 20 00 clr %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000969c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400096a0: 01 00 00 00 nop
}
_POSIX_Keys_Key_value_release( executing, &lock_context );
return value;
}
400096a4: 81 c3 e0 08 retl
400096a8: 01 00 00 00 nop
400096ac: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400096b0: 01 00 00 00 nop
400096b4: 81 c3 e0 08 retl
400096b8: 01 00 00 00 nop
400095e0 <pthread_key_create>:
*/
int pthread_key_create(
pthread_key_t *key,
void (*destructor)( void * )
)
{
400095e0: 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 );
400095e4: 3b 10 00 9b sethi %hi(0x40026c00), %i5
400095e8: 40 00 09 90 call 4000bc28 <_Objects_Allocate>
400095ec: 90 17 60 28 or %i5, 0x28, %o0 ! 40026c28 <_POSIX_Keys_Information>
POSIX_Keys_Control *the_key;
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
400095f0: 80 a2 20 00 cmp %o0, 0
400095f4: 02 80 00 13 be 40009640 <pthread_key_create+0x60>
<== NEVER TAKEN
400095f8: 86 02 20 14 add %o0, 0x14, %g3
information->local_table[ index ] = the_object;
400095fc: c2 12 20 0a lduh [ %o0 + 0xa ], %g1
tail->previous = head;
40009600: c6 22 20 1c st %g3, [ %o0 + 0x1c ]
return &the_chain->Tail.Node;
40009604: 84 02 20 18 add %o0, 0x18, %g2
_Objects_Allocator_unlock();
return EAGAIN;
}
the_key->destructor = destructor;
40009608: f2 22 20 10 st %i1, [ %o0 + 0x10 ]
4000960c: ba 17 60 28 or %i5, 0x28, %i5
head->next = tail;
40009610: c4 22 20 14 st %g2, [ %o0 + 0x14 ]
40009614: 83 28 60 02 sll %g1, 2, %g1
head->previous = NULL;
40009618: c0 22 20 18 clr [ %o0 + 0x18 ]
the_object->name.name_u32 = name;
4000961c: c0 22 20 0c clr [ %o0 + 0xc ]
information->local_table[ index ] = the_object;
40009620: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
40009624: c4 02 20 08 ld [ %o0 + 8 ], %g2
40009628: 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;
4000962c: c4 26 00 00 st %g2, [ %i0 ]
_RTEMS_Unlock_allocator();
40009630: 40 00 01 43 call 40009b3c <_RTEMS_Unlock_allocator>
40009634: b0 10 20 00 clr %i0
_Objects_Allocator_unlock();
return 0;
}
40009638: 81 c7 e0 08 ret
4000963c: 81 e8 00 00 restore
40009640: 40 00 01 3f call 40009b3c <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40009644: b0 10 20 0b mov 0xb, %i0
<== NOT EXECUTED
return EAGAIN;
40009648: 81 c7 e0 08 ret
<== NOT EXECUTED
4000964c: 81 e8 00 00 restore
<== NOT EXECUTED
4001375c <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
4001375c: 80 a2 20 00 cmp %o0, 0
40013760: 02 80 00 07 be 4001377c <pthread_once+0x20>
<== NEVER TAKEN
40013764: 80 a2 60 00 cmp %o1, 0
40013768: 02 80 00 05 be 4001377c <pthread_once+0x20>
<== NEVER TAKEN
4001376c: 01 00 00 00 nop
return EINVAL;
return _Once( &once_control->_flags, init_routine );
40013770: 82 13 c0 00 mov %o7, %g1
40013774: 40 00 03 a1 call 400145f8 <_Once>
40013778: 9e 10 40 00 mov %g1, %o7
}
4001377c: 81 c3 e0 08 retl
<== NOT EXECUTED
40013780: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
400145c0 <pthread_setspecific>:
int pthread_setspecific(
pthread_key_t key,
const void *value
)
{
400145c0: 9d e3 bf 98 save %sp, -104, %sp
400145c4: ba 10 00 18 mov %i0, %i5
Thread_Control *executing;
int eno;
executing = _Thread_Get_executing();
if ( value != NULL ) {
400145c8: 80 a6 60 00 cmp %i1, 0
400145cc: 02 80 00 52 be 40014714 <pthread_setspecific+0x154>
400145d0: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400145d4: 91 d0 20 09 ta 9
<== NOT EXECUTED
return &RB_ROOT( the_rbtree );
400145d8: b6 07 21 60 add %i4, 0x160, %i3
link = _RBTree_Root_const_reference( the_rbtree );
400145dc: 86 10 00 1b mov %i3, %g3
while ( *link != NULL ) {
400145e0: c4 00 c0 00 ld [ %g3 ], %g2
400145e4: 80 a0 a0 00 cmp %g2, 0
400145e8: 02 80 00 0d be 4001461c <pthread_setspecific+0x5c>
<== ALWAYS TAKEN
400145ec: 86 00 bf f8 add %g2, -8, %g3
return *the_left == the_right->key;
400145f0: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
<== NOT EXECUTED
if ( ( *equal )( key, parent ) ) {
400145f4: 80 a7 40 04 cmp %i5, %g4
<== NOT EXECUTED
400145f8: 22 80 00 31 be,a 400146bc <pthread_setspecific+0xfc>
<== NOT EXECUTED
400145fc: f2 20 e0 20 st %i1, [ %g3 + 0x20 ]
<== NOT EXECUTED
} else if ( ( *less )( key, parent ) ) {
40014600: 1a bf ff f8 bcc 400145e0 <pthread_setspecific+0x20>
<== NOT EXECUTED
40014604: 86 00 a0 04 add %g2, 4, %g3
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
40014608: 86 10 00 02 mov %g2, %g3
<== NOT EXECUTED
while ( *link != NULL ) {
4001460c: c4 00 c0 00 ld [ %g3 ], %g2
<== NOT EXECUTED
40014610: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40014614: 12 bf ff f7 bne 400145f0 <pthread_setspecific+0x30>
<== NOT EXECUTED
40014618: 86 00 bf f8 add %g2, -8, %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001461c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40014620: 01 00 00 00 nop
_RTEMS_Lock_allocator();
40014624: 40 00 01 5b call 40014b90 <_RTEMS_Lock_allocator>
40014628: b0 10 20 16 mov 0x16, %i0 ! 16 <_TLS_Alignment+0x15>
return (POSIX_Keys_Control *)
4001462c: 90 10 00 1d mov %i5, %o0
40014630: 13 10 01 19 sethi %hi(0x40046400), %o1
40014634: 40 00 0a 29 call 40016ed8 <_Objects_Get_no_protection>
40014638: 92 12 62 98 or %o1, 0x298, %o1 ! 40046698 <_POSIX_Keys_Information>
if ( the_key != NULL ) {
4001463c: b4 92 20 00 orcc %o0, 0, %i2
40014640: 02 80 00 31 be 40014704 <pthread_setspecific+0x144>
<== NEVER TAKEN
40014644: 01 00 00 00 nop
key_value_pair = _POSIX_Keys_Key_value_allocate();
40014648: 7f ff ff ce call 40014580 <_POSIX_Keys_Key_value_allocate>
4001464c: b0 10 20 0c mov 0xc, %i0 ! c <_TLS_Alignment+0xb>
if ( key_value_pair != NULL ) {
40014650: 80 a2 20 00 cmp %o0, 0
40014654: 02 80 00 2c be 40014704 <pthread_setspecific+0x144>
<== NEVER TAKEN
40014658: 88 10 00 08 mov %o0, %g4
<== NOT EXECUTED
old_last = tail->previous;
4001465c: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
<== NOT EXECUTED
return &the_chain->Tail.Node;
40014660: 84 06 a0 18 add %i2, 0x18, %g2
<== NOT EXECUTED
key_value_pair->key = key;
40014664: fa 22 20 18 st %i5, [ %o0 + 0x18 ]
<== NOT EXECUTED
_RBTree_Initialize_node( &key_value_pair->Lookup_node );
40014668: b0 02 20 08 add %o0, 8, %i0
<== NOT EXECUTED
key_value_pair->thread = executing;
4001466c: f8 22 20 1c st %i4, [ %o0 + 0x1c ]
<== NOT EXECUTED
key_value_pair->value = RTEMS_DECONST( void *, value );
40014670: f2 22 20 20 st %i1, [ %o0 + 0x20 ]
<== NOT EXECUTED
the_node->next = tail;
40014674: c4 22 00 00 st %g2, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
40014678: d0 26 a0 1c st %o0, [ %i2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
4001467c: d0 20 40 00 st %o0, [ %g1 ]
<== NOT EXECUTED
the_node->previous = old_last;
40014680: c2 22 20 04 st %g1, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40014684: 91 d0 20 09 ta 9
<== NOT EXECUTED
parent = NULL;
40014688: b8 10 20 00 clr %i4
link = _RBTree_Root_reference( the_rbtree );
4001468c: 86 10 00 1b mov %i3, %g3
while ( *link != NULL ) {
40014690: c4 00 c0 00 ld [ %g3 ], %g2
40014694: 80 a0 a0 00 cmp %g2, 0
40014698: 22 80 00 41 be,a 4001479c <pthread_setspecific+0x1dc>
<== ALWAYS TAKEN
4001469c: f8 21 20 10 st %i4, [ %g4 + 0x10 ]
if ( ( *less )( key, parent ) ) {
400146a0: f8 00 a0 10 ld [ %g2 + 0x10 ], %i4
<== NOT EXECUTED
400146a4: 80 a7 40 1c cmp %i5, %i4
<== NOT EXECUTED
400146a8: 1a 80 00 03 bcc 400146b4 <pthread_setspecific+0xf4>
<== NOT EXECUTED
400146ac: 86 00 a0 04 add %g2, 4, %g3
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
400146b0: 86 10 00 02 mov %g2, %g3
<== NOT EXECUTED
link = _RBTree_Root_const_reference( the_rbtree );
400146b4: 10 bf ff f7 b 40014690 <pthread_setspecific+0xd0>
<== NOT EXECUTED
400146b8: b8 10 00 02 mov %g2, %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400146bc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400146c0: 01 00 00 00 nop
<== NOT EXECUTED
} else {
eno = _POSIX_Keys_Delete_value( key, executing );
}
return eno;
}
400146c4: 81 c7 e0 08 ret
<== NOT EXECUTED
400146c8: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
_RBTree_Extract(
400146cc: 40 00 0a 50 call 4001700c <_RBTree_Extract>
400146d0: c2 27 bf fc st %g1, [ %fp + -4 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400146d4: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400146d8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400146dc: 01 00 00 00 nop
next = the_node->next;
400146e0: c4 07 00 00 ld [ %i4 ], %g2
previous = the_node->previous;
400146e4: c2 07 20 04 ld [ %i4 + 4 ], %g1
next->previous = previous;
400146e8: c2 20 a0 04 st %g1, [ %g2 + 4 ]
_Freechain_Put( &_POSIX_Keys_Keypool, key_value_pair );
400146ec: 11 10 01 19 sethi %hi(0x40046400), %o0
previous->next = next;
400146f0: c4 20 40 00 st %g2, [ %g1 ]
400146f4: 92 10 00 1c mov %i4, %o1
eno = 0;
400146f8: b0 10 20 00 clr %i0
400146fc: 40 00 01 91 call 40014d40 <_Freechain_Put>
40014700: 90 12 22 d4 or %o0, 0x2d4, %o0
_RTEMS_Unlock_allocator();
40014704: 40 00 01 28 call 40014ba4 <_RTEMS_Unlock_allocator>
40014708: 01 00 00 00 nop
return eno;
4001470c: 81 c7 e0 08 ret
40014710: 81 e8 00 00 restore
_RTEMS_Lock_allocator();
40014714: 40 00 01 1f call 40014b90 <_RTEMS_Lock_allocator>
40014718: 01 00 00 00 nop
return (POSIX_Keys_Control *)
4001471c: 90 10 00 18 mov %i0, %o0
40014720: 13 10 01 19 sethi %hi(0x40046400), %o1
eno = EINVAL;
40014724: b0 10 20 16 mov 0x16, %i0
40014728: 40 00 09 ec call 40016ed8 <_Objects_Get_no_protection>
4001472c: 92 12 62 98 or %o1, 0x298, %o1
if ( the_key != NULL ) {
40014730: 80 a2 20 00 cmp %o0, 0
40014734: 02 bf ff f4 be 40014704 <pthread_setspecific+0x144>
<== NEVER TAKEN
40014738: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001473c: 91 d0 20 09 ta 9
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Keys_Key_value_pair *_POSIX_Keys_Key_value_find(
pthread_key_t key,
const Thread_Control *the_thread
)
{
return _RBTree_Find_inline(
40014740: 90 07 21 60 add %i4, 0x160, %o0
40014744: 84 10 00 08 mov %o0, %g2
while ( *link != NULL ) {
40014748: d2 00 80 00 ld [ %g2 ], %o1
4001474c: 80 a2 60 00 cmp %o1, 0
40014750: 02 80 00 0d be 40014784 <pthread_setspecific+0x1c4>
<== NEVER TAKEN
40014754: b8 02 7f f8 add %o1, -8, %i4
return *the_left == the_right->key;
40014758: c4 07 20 18 ld [ %i4 + 0x18 ], %g2
if ( ( *equal )( key, parent ) ) {
4001475c: 80 a7 40 02 cmp %i5, %g2
40014760: 02 bf ff db be 400146cc <pthread_setspecific+0x10c>
<== ALWAYS TAKEN
40014764: 01 00 00 00 nop
} else if ( ( *less )( key, parent ) ) {
40014768: 1a bf ff f8 bcc 40014748 <pthread_setspecific+0x188>
<== NOT EXECUTED
4001476c: 84 02 60 04 add %o1, 4, %g2
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
40014770: 84 10 00 09 mov %o1, %g2
<== NOT EXECUTED
while ( *link != NULL ) {
40014774: d2 00 80 00 ld [ %g2 ], %o1
<== NOT EXECUTED
40014778: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
4001477c: 12 bf ff f7 bne 40014758 <pthread_setspecific+0x198>
<== NOT EXECUTED
40014780: b8 02 7f f8 add %o1, -8, %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40014784: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40014788: 01 00 00 00 nop
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
4001478c: 40 00 01 06 call 40014ba4 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40014790: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
return eno;
40014794: 81 c7 e0 08 ret
<== NOT EXECUTED
40014798: 81 e8 00 00 restore
<== NOT EXECUTED
RB_SET( child, parent, Node );
4001479c: 84 10 20 01 mov 1, %g2
400147a0: c0 21 20 0c clr [ %g4 + 0xc ]
_RBTree_Insert_color( the_rbtree, the_node );
400147a4: 92 10 00 18 mov %i0, %o1
RB_SET( child, parent, Node );
400147a8: c0 21 20 08 clr [ %g4 + 8 ]
_RBTree_Insert_color( the_rbtree, the_node );
400147ac: 90 10 00 1b mov %i3, %o0
RB_SET( child, parent, Node );
400147b0: c4 21 20 14 st %g2, [ %g4 + 0x14 ]
*link = child;
400147b4: f0 20 c0 00 st %i0, [ %g3 ]
_RBTree_Insert_color( the_rbtree, the_node );
400147b8: 40 00 0b 77 call 40017594 <_RBTree_Insert_color>
400147bc: c2 27 bf fc st %g1, [ %fp + -4 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400147c0: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400147c4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400147c8: 01 00 00 00 nop
eno = 0;
400147cc: 10 bf ff ce b 40014704 <pthread_setspecific+0x144>
400147d0: b0 10 20 00 clr %i0 ! 0 <PROM_START>
40001274 <wait>:
{
40001274: 9d e3 bf 98 save %sp, -104, %sp
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
40001278: 94 10 20 00 clr %o2
4000127c: 96 07 bf fc add %fp, -4, %o3
40001280: 92 10 20 00 clr %o1
40001284: 40 00 1d 2a call 4000872c <rtems_event_system_receive>
40001288: 11 20 00 00 sethi %hi(0x80000000), %o0
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
4000128c: 80 a2 20 00 cmp %o0, 0
40001290: 12 80 00 04 bne 400012a0 <wait+0x2c>
<== NEVER TAKEN
40001294: 94 10 20 51 mov 0x51, %o2
}
40001298: 81 c7 e0 08 ret
4000129c: 81 e8 00 00 restore
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
400012a0: 17 10 00 66 sethi %hi(0x40019800), %o3
<== NOT EXECUTED
400012a4: 13 10 00 66 sethi %hi(0x40019800), %o1
<== NOT EXECUTED
400012a8: 96 12 e3 10 or %o3, 0x310, %o3
<== NOT EXECUTED
400012ac: 92 12 63 28 or %o1, 0x328, %o1
<== NOT EXECUTED
400012b0: 11 10 00 66 sethi %hi(0x40019800), %o0
<== NOT EXECUTED
400012b4: 40 00 36 66 call 4000ec4c <__wrap_printf>
<== NOT EXECUTED
400012b8: 90 12 23 88 or %o0, 0x388, %o0 ! 40019b88 <_rodata_start+0x78>
<== NOT EXECUTED
400012bc: 40 00 36 5e call 4000ec34 <rtems_test_exit>
<== NOT EXECUTED
400012c0: 90 10 20 00 clr %o0
<== NOT EXECUTED
400012c4: 01 00 00 00 nop
<== NOT EXECUTED