RTEMS-5
Annotated Report
Wed Aug 8 20:50:24 2018
400185c0 <_POSIX_Keys_Key_value_allocate>:
uint32_t max = Configuration.maximum_key_value_pairs;
400185c0: 03 10 00 bb sethi %hi(0x4002ec00), %g1
<== NOT EXECUTED
400185c4: c2 00 63 dc ld [ %g1 + 0x3dc ], %g1 ! 4002efdc <Configuration+0x10>
<== NOT EXECUTED
_Objects_Maximum_per_allocation( max ) : 0;
400185c8: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400185cc: 16 80 00 05 bge 400185e0 <_POSIX_Keys_Key_value_allocate+0x20>
<== NOT EXECUTED
400185d0: 94 10 20 00 clr %o2
<== NOT EXECUTED
400185d4: 15 00 00 3f sethi %hi(0xfc00), %o2
<== NOT EXECUTED
400185d8: 94 12 a3 ff or %o2, 0x3ff, %o2 ! ffff <_Configuration_Interrupt_stack_size+0xefff>
<== NOT EXECUTED
400185dc: 94 08 40 0a and %g1, %o2, %o2
<== NOT EXECUTED
return (POSIX_Keys_Key_value_pair *) _Freechain_Get(
400185e0: 13 10 00 79 sethi %hi(0x4001e400), %o1
<== NOT EXECUTED
400185e4: 11 10 00 d2 sethi %hi(0x40034800), %o0
<== NOT EXECUTED
400185e8: 96 10 20 24 mov 0x24, %o3
<== NOT EXECUTED
400185ec: 92 12 62 04 or %o1, 0x204, %o1
<== NOT EXECUTED
400185f0: 90 12 21 fc or %o0, 0x1fc, %o0
<== NOT EXECUTED
400185f4: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400185f8: 40 00 01 c9 call 40018d1c <_Freechain_Get>
<== NOT EXECUTED
400185fc: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4001a1a0 <_POSIX_Threads_Sporadic_timer>:
{
4001a1a0: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
4001a1a4: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
api = RTEMS_CONTAINER_OF( watchdog, POSIX_API_Control, Sporadic.Timer );
4001a1a8: ba 06 3f f8 add %i0, -8, %i5
<== NOT EXECUTED
the_thread = api->Sporadic.thread;
4001a1ac: f8 06 3f f8 ld [ %i0 + -8 ], %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001a1b0: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
4001a1b4: c2 27 bf dc st %g1, [ %fp + -36 ]
<== NOT EXECUTED
if ( _Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
4001a1b8: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
<== NOT EXECUTED
4001a1bc: 80 a0 7f ff cmp %g1, -1
<== NOT EXECUTED
4001a1c0: 02 80 00 0b be 4001a1ec <_POSIX_Threads_Sporadic_timer+0x4c>
<== NOT EXECUTED
4001a1c4: 92 07 20 20 add %i4, 0x20, %o1
<== NOT EXECUTED
_Thread_Priority_add(
4001a1c8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4001a1cc: 7f ff e4 37 call 400132a8 <_Thread_Priority_add>
<== NOT EXECUTED
4001a1d0: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
_Thread_Priority_remove(
4001a1d4: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
4001a1d8: 92 06 20 20 add %i0, 0x20, %o1
<== NOT EXECUTED
4001a1dc: 7f ff e4 38 call 400132bc <_Thread_Priority_remove>
<== NOT EXECUTED
4001a1e0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4001a1e4: 82 10 3f ff mov -1, %g1
<== NOT EXECUTED
4001a1e8: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
<== NOT EXECUTED
_Watchdog_Per_CPU_remove_ticks( &api->Sporadic.Timer );
4001a1ec: b6 07 60 08 add %i5, 8, %i3
<== NOT EXECUTED
4001a1f0: 11 10 00 d5 sethi %hi(0x40035400), %o0
<== NOT EXECUTED
4001a1f4: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4001a1f8: 7f ff ee ff call 40015df4 <_Watchdog_Remove>
<== NOT EXECUTED
4001a1fc: 90 12 20 78 or %o0, 0x78, %o0
<== NOT EXECUTED
Thread_Control *the_thread,
POSIX_API_Control *api
)
{
the_thread->cpu_time_budget =
_Timespec_To_ticks( &api->Sporadic.sched_ss_init_budget );
4001a200: 40 00 02 18 call 4001aa60 <_Timespec_To_ticks>
<== NOT EXECUTED
4001a204: 90 07 60 50 add %i5, 0x50, %o0
<== NOT EXECUTED
the_thread->cpu_time_budget =
4001a208: d0 27 20 8c st %o0, [ %i4 + 0x8c ]
<== NOT EXECUTED
_Watchdog_Per_CPU_insert_ticks(
4001a20c: b8 10 00 06 mov %g6, %i4
<== NOT EXECUTED
4001a210: 40 00 02 14 call 4001aa60 <_Timespec_To_ticks>
<== NOT EXECUTED
4001a214: 90 07 60 40 add %i5, 0x40, %o0
<== NOT EXECUTED
expire = ticks + cpu->Watchdog.ticks;
4001a218: d4 1f 20 30 ldd [ %i4 + 0x30 ], %o2
<== NOT EXECUTED
_Watchdog_Insert(header, the_watchdog, expire);
4001a21c: 86 82 c0 08 addcc %o3, %o0, %g3
<== NOT EXECUTED
4001a220: 84 42 a0 00 addx %o2, 0, %g2
<== NOT EXECUTED
4001a224: 96 10 00 03 mov %g3, %o3
<== NOT EXECUTED
4001a228: 94 10 00 02 mov %g2, %o2
<== NOT EXECUTED
4001a22c: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4001a230: 7f ff ee c9 call 40015d54 <_Watchdog_Insert>
<== NOT EXECUTED
4001a234: 90 07 20 38 add %i4, 0x38, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4001a238: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001a23c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001a240: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( &queue_context );
4001a244: 7f ff e4 2a call 400132ec <_Thread_Priority_update>
<== NOT EXECUTED
4001a248: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
}
4001a24c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001a250: 81 e8 00 00 restore
<== NOT EXECUTED
4002c9ec <_POSIX_signals_Abnormal_termination_handler>:
sigset_t _POSIX_signals_Pending;
void _POSIX_signals_Abnormal_termination_handler(
int signo RTEMS_UNUSED )
{
4002c9ec: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
exit( 1 );
4002c9f0: 40 00 01 c7 call 4002d10c <exit>
<== NOT EXECUTED
4002c9f4: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
4002c9f8: 01 00 00 00 nop
<== NOT EXECUTED
4002d0a4 <_POSIX_signals_Clear_process_signals>:
_Assert( _ISR_Get_level() != 0 );
clear_signal = true;
mask = signo_to_mask( signo );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
4002d0a4: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4002d0a8: 05 10 00 d5 sethi %hi(0x40035400), %g2
<== NOT EXECUTED
4002d0ac: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4002d0b0: 84 10 a3 e8 or %g2, 0x3e8, %g2
<== NOT EXECUTED
4002d0b4: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
4002d0b8: c4 00 80 01 ld [ %g2 + %g1 ], %g2
<== NOT EXECUTED
4002d0bc: 90 02 3f ff add %o0, -1, %o0
<== NOT EXECUTED
4002d0c0: 80 a0 a0 02 cmp %g2, 2
<== NOT EXECUTED
4002d0c4: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
4002d0c8: 02 80 00 07 be 4002d0e4 <_POSIX_signals_Clear_process_signals+0x40>
<== NOT EXECUTED
4002d0cc: 91 28 80 08 sll %g2, %o0, %o0
<== NOT EXECUTED
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
4002d0d0: 03 10 00 d6 sethi %hi(0x40035800), %g1
<== NOT EXECUTED
4002d0d4: c4 00 61 74 ld [ %g1 + 0x174 ], %g2 ! 40035974 <_POSIX_signals_Pending>
<== NOT EXECUTED
4002d0d8: 90 28 80 08 andn %g2, %o0, %o0
<== NOT EXECUTED
}
}
4002d0dc: 81 c3 e0 08 retl
<== NOT EXECUTED
4002d0e0: d0 20 61 74 st %o0, [ %g1 + 0x174 ]
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4002d0e4: 05 10 00 d6 sethi %hi(0x40035800), %g2
<== NOT EXECUTED
4002d0e8: 84 10 a1 78 or %g2, 0x178, %g2 ! 40035978 <_POSIX_signals_Siginfo>
<== NOT EXECUTED
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
4002d0ec: c6 00 80 01 ld [ %g2 + %g1 ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
4002d0f0: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
4002d0f4: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4002d0f8: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
4002d0fc: 02 bf ff f6 be 4002d0d4 <_POSIX_signals_Clear_process_signals+0x30>
<== NOT EXECUTED
4002d100: 03 10 00 d6 sethi %hi(0x40035800), %g1
<== NOT EXECUTED
}
4002d104: 81 c3 e0 08 retl
<== NOT EXECUTED
4002d108: 01 00 00 00 nop
<== NOT EXECUTED
4002cf50 <_POSIX_signals_Clear_signals>:
siginfo_t *info,
bool is_global,
bool check_blocked,
bool do_signals_acquire_release
)
{
4002cf50: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
4002cf54: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
4002cf58: 86 06 7f ff add %i1, -1, %g3
<== NOT EXECUTED
*/
if ( check_blocked )
signals_unblocked = api->signals_unblocked;
else
signals_unblocked = SIGNAL_ALL_MASK;
4002cf5c: 88 10 3f ff mov -1, %g4
<== NOT EXECUTED
if ( check_blocked )
4002cf60: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
4002cf64: 02 80 00 03 be 4002cf70 <_POSIX_signals_Clear_signals+0x20>
<== NOT EXECUTED
4002cf68: 85 28 80 03 sll %g2, %g3, %g2
<== NOT EXECUTED
signals_unblocked = api->signals_unblocked;
4002cf6c: c8 06 20 68 ld [ %i0 + 0x68 ], %g4
<== NOT EXECUTED
/* XXX is this right for siginfo type signals? */
/* XXX are we sure they can be cleared the same way? */
if ( do_signals_acquire_release ) {
4002cf70: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4002cf74: 02 80 00 04 be 4002cf84 <_POSIX_signals_Clear_signals+0x34>
<== NOT EXECUTED
4002cf78: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002cf7c: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Thread_queue_Context_initialize( &queue_context );
_POSIX_signals_Acquire( &queue_context );
}
if ( is_global ) {
4002cf80: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
4002cf84: 22 80 00 10 be,a 4002cfc4 <_POSIX_signals_Clear_signals+0x74>
<== NOT EXECUTED
4002cf88: f8 06 20 6c ld [ %i0 + 0x6c ], %i4
<== NOT EXECUTED
if ( mask & (_POSIX_signals_Pending & signals_unblocked) ) {
4002cf8c: 07 10 00 d6 sethi %hi(0x40035800), %g3
<== NOT EXECUTED
4002cf90: c6 00 e1 74 ld [ %g3 + 0x174 ], %g3 ! 40035974 <_POSIX_signals_Pending>
<== NOT EXECUTED
4002cf94: 84 08 80 03 and %g2, %g3, %g2
<== NOT EXECUTED
4002cf98: 80 88 80 04 btst %g2, %g4
<== NOT EXECUTED
4002cf9c: 12 80 00 12 bne 4002cfe4 <_POSIX_signals_Clear_signals+0x94>
<== NOT EXECUTED
4002cfa0: 86 10 20 00 clr %g3
<== NOT EXECUTED
api->signals_pending &= ~mask;
do_callout = true;
}
}
if ( do_signals_acquire_release ) {
4002cfa4: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4002cfa8: 22 80 00 05 be,a 4002cfbc <_POSIX_signals_Clear_signals+0x6c>
<== NOT EXECUTED
4002cfac: b0 08 e0 01 and %g3, 1, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002cfb0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002cfb4: 01 00 00 00 nop
<== NOT EXECUTED
_POSIX_signals_Release( &queue_context );
}
return do_callout;
}
4002cfb8: b0 08 e0 01 and %g3, 1, %i0
<== NOT EXECUTED
4002cfbc: 81 c7 e0 08 ret
<== NOT EXECUTED
4002cfc0: 81 e8 00 00 restore
<== NOT EXECUTED
if ( mask & (api->signals_pending & signals_unblocked) ) {
4002cfc4: b6 0f 00 02 and %i4, %g2, %i3
<== NOT EXECUTED
4002cfc8: 80 8e c0 04 btst %i3, %g4
<== NOT EXECUTED
4002cfcc: 02 bf ff f6 be 4002cfa4 <_POSIX_signals_Clear_signals+0x54>
<== NOT EXECUTED
4002cfd0: 86 10 20 00 clr %g3
<== NOT EXECUTED
api->signals_pending &= ~mask;
4002cfd4: 84 2f 00 02 andn %i4, %g2, %g2
<== NOT EXECUTED
do_callout = true;
4002cfd8: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
api->signals_pending &= ~mask;
4002cfdc: 10 bf ff f2 b 4002cfa4 <_POSIX_signals_Clear_signals+0x54>
<== NOT EXECUTED
4002cfe0: c4 26 20 6c st %g2, [ %i0 + 0x6c ]
<== NOT EXECUTED
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
4002cfe4: 85 2e 60 01 sll %i1, 1, %g2
<== NOT EXECUTED
4002cfe8: 07 10 00 d5 sethi %hi(0x40035400), %g3
<== NOT EXECUTED
4002cfec: 84 00 80 19 add %g2, %i1, %g2
<== NOT EXECUTED
4002cff0: 86 10 e3 e8 or %g3, 0x3e8, %g3
<== NOT EXECUTED
4002cff4: 85 28 a0 02 sll %g2, 2, %g2
<== NOT EXECUTED
4002cff8: c6 00 c0 02 ld [ %g3 + %g2 ], %g3
<== NOT EXECUTED
4002cffc: 80 a0 e0 02 cmp %g3, 2
<== NOT EXECUTED
4002d000: 22 80 00 08 be,a 4002d020 <_POSIX_signals_Clear_signals+0xd0>
<== NOT EXECUTED
4002d004: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
4002d008: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
_POSIX_signals_Clear_process_signals( signo );
4002d00c: 40 00 00 26 call 4002d0a4 <_POSIX_signals_Clear_process_signals>
<== NOT EXECUTED
4002d010: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
do_callout = true;
4002d014: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
4002d018: 10 bf ff e3 b 4002cfa4 <_POSIX_signals_Clear_signals+0x54>
<== NOT EXECUTED
4002d01c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
_Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] );
4002d020: 07 10 00 d6 sethi %hi(0x40035800), %g3
<== NOT EXECUTED
4002d024: 86 10 e1 78 or %g3, 0x178, %g3 ! 40035978 <_POSIX_signals_Siginfo>
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4002d028: f8 00 80 03 ld [ %g2 + %g3 ], %i4
<== NOT EXECUTED
return &the_chain->Tail.Node;
4002d02c: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
4002d030: 88 01 00 03 add %g4, %g3, %g4
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
4002d034: 80 a7 00 04 cmp %i4, %g4
<== NOT EXECUTED
4002d038: 02 80 00 17 be 4002d094 <_POSIX_signals_Clear_signals+0x144>
<== NOT EXECUTED
4002d03c: b6 00 80 03 add %g2, %g3, %i3
<== NOT EXECUTED
new_first = old_first->next;
4002d040: c8 07 00 00 ld [ %i4 ], %g4
<== NOT EXECUTED
head->next = new_first;
4002d044: c8 20 80 03 st %g4, [ %g2 + %g3 ]
<== NOT EXECUTED
_POSIX_signals_Clear_process_signals( signo );
4002d048: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
4002d04c: 40 00 00 16 call 4002d0a4 <_POSIX_signals_Clear_process_signals>
<== NOT EXECUTED
4002d050: f6 21 20 04 st %i3, [ %g4 + 4 ]
<== NOT EXECUTED
*info = psiginfo->Info;
4002d054: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
4002d058: c4 26 80 00 st %g2, [ %i2 ]
<== NOT EXECUTED
4002d05c: c4 07 20 0c ld [ %i4 + 0xc ], %g2
<== NOT EXECUTED
4002d060: c4 26 a0 04 st %g2, [ %i2 + 4 ]
<== NOT EXECUTED
old_last = tail->previous;
4002d064: 05 10 00 d6 sethi %hi(0x40035800), %g2
<== NOT EXECUTED
4002d068: c6 07 20 10 ld [ %i4 + 0x10 ], %g3
<== NOT EXECUTED
4002d06c: c6 26 a0 08 st %g3, [ %i2 + 8 ]
<== NOT EXECUTED
4002d070: 84 10 a1 68 or %g2, 0x168, %g2
<== NOT EXECUTED
4002d074: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
the_node->next = tail;
4002d078: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
4002d07c: c8 27 00 00 st %g4, [ %i4 ]
<== NOT EXECUTED
tail->previous = the_node;
4002d080: f8 20 a0 08 st %i4, [ %g2 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
4002d084: f8 20 c0 00 st %i4, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
4002d088: c6 27 20 04 st %g3, [ %i4 + 4 ]
<== NOT EXECUTED
4002d08c: 10 bf ff df b 4002d008 <_POSIX_signals_Clear_signals+0xb8>
<== NOT EXECUTED
4002d090: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
_POSIX_signals_Clear_process_signals( signo );
4002d094: 40 00 00 04 call 4002d0a4 <_POSIX_signals_Clear_process_signals>
<== NOT EXECUTED
4002d098: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
4002d09c: 10 bf ff db b 4002d008 <_POSIX_signals_Clear_signals+0xb8>
<== NOT EXECUTED
4002d0a0: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
400317b0 <_POSIX_signals_Default_vectors>:
400317b0: 00 00 00 00 ff ff ff ff 00 00 00 01 00 00 00 00 ................
400317c0: ff ff ff ff 40 02 c9 ec 00 00 00 00 ff ff ff ff ....@...........
400317d0: 40 02 c9 ec 00 00 00 00 ff ff ff ff 40 02 c9 ec @...........@...
400317e0: 00 00 00 00 ff ff ff ff 40 02 c9 ec 00 00 00 00 ........@.......
400317f0: ff ff ff ff 40 02 c9 ec 00 00 00 00 ff ff ff ff ....@...........
40031800: 40 02 c9 ec 00 00 00 00 ff ff ff ff 40 02 c9 ec @...........@...
40031810: 00 00 00 00 ff ff ff ff 40 02 c9 ec 00 00 00 00 ........@.......
40031820: ff ff ff ff 40 02 c9 ec 00 00 00 00 ff ff ff ff ....@...........
40031830: 40 02 c9 ec 00 00 00 00 ff ff ff ff 40 02 c9 ec @...........@...
40031840: 00 00 00 00 ff ff ff ff 40 02 c9 ec 00 00 00 00 ........@.......
40031850: ff ff ff ff 40 02 c9 ec 00 00 00 00 ff ff ff ff ....@...........
40031860: 40 02 c9 ec 00 00 00 00 ff ff ff ff 40 02 c9 ec @...........@...
40031870: 00 00 00 00 ff ff ff ff 40 02 c9 ec 00 00 00 00 ........@.......
40031880: ff ff ff ff 40 02 c9 ec 00 00 00 00 ff ff ff ff ....@...........
40031890: 40 02 c9 ec 00 00 00 00 ff ff ff ff 40 02 c9 ec @...........@...
400318a0: 00 00 00 00 ff ff ff ff 40 02 c9 ec 00 00 00 00 ........@.......
400318b0: ff ff ff ff 40 02 c9 ec 00 00 00 00 ff ff ff ff ....@...........
400318c0: 40 02 c9 ec 00 00 00 00 ff ff ff ff 40 02 c9 ec @...........@...
400318d0: 00 00 00 00 ff ff ff ff 40 02 c9 ec 00 00 00 00 ........@.......
400318e0: ff ff ff ff 40 02 c9 ec 00 00 00 00 ff ff ff ff ....@...........
400318f0: 40 02 c9 ec 00 00 00 00 ff ff ff ff 40 02 c9 ec @...........@...
40031900: 00 00 00 00 ff ff ff ff 40 02 c9 ec 00 00 00 00 ........@.......
40031910: ff ff ff ff 40 02 c9 ec 00 00 00 00 ff ff ff ff ....@...........
40031920: 40 02 c9 ec 00 00 00 00 ff ff ff ff 40 02 c9 ec @...........@...
4002c5bc <_POSIX_signals_Send>:
int _POSIX_signals_Send(
pid_t pid,
int sig,
const union sigval *value
)
{
4002c5bc: 9d e3 bf 88 save %sp, -120, %sp
<== NOT EXECUTED
Per_CPU_Control *cpu_self;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
4002c5c0: 7f ff fe ba call 4002c0a8 <getpid>
<== NOT EXECUTED
4002c5c4: 01 00 00 00 nop
<== NOT EXECUTED
4002c5c8: 80 a2 00 18 cmp %o0, %i0
<== NOT EXECUTED
4002c5cc: 12 80 00 e7 bne 4002c968 <_POSIX_signals_Send+0x3ac>
<== NOT EXECUTED
4002c5d0: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
4002c5d4: 02 80 00 df be 4002c950 <_POSIX_signals_Send+0x394>
<== NOT EXECUTED
4002c5d8: b8 06 7f ff add %i1, -1, %i4
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
4002c5dc: 80 a7 20 1f cmp %i4, 0x1f
<== NOT EXECUTED
4002c5e0: 18 80 00 dc bgu 4002c950 <_POSIX_signals_Send+0x394>
<== NOT EXECUTED
4002c5e4: bb 2e 60 01 sll %i1, 1, %i5
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
4002c5e8: 37 10 00 d5 sethi %hi(0x40035400), %i3
<== NOT EXECUTED
4002c5ec: ba 07 40 19 add %i5, %i1, %i5
<== NOT EXECUTED
4002c5f0: b6 16 e3 e8 or %i3, 0x3e8, %i3
<== NOT EXECUTED
4002c5f4: 83 2f 60 02 sll %i5, 2, %g1
<== NOT EXECUTED
4002c5f8: 82 06 c0 01 add %i3, %g1, %g1
<== NOT EXECUTED
4002c5fc: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
4002c600: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4002c604: 02 80 00 56 be 4002c75c <_POSIX_signals_Send+0x1a0>
<== NOT EXECUTED
4002c608: b0 10 20 00 clr %i0
<== NOT EXECUTED
/*
* P1003.1c/Draft 10, p. 33 says that certain signals should always
* be directed to the executing thread such as those caused by hardware
* faults.
*/
if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
4002c60c: 82 06 7f fc add %i1, -4, %g1
<== NOT EXECUTED
4002c610: 80 88 7f fb btst -5, %g1
<== NOT EXECUTED
4002c614: 02 80 00 46 be 4002c72c <_POSIX_signals_Send+0x170>
<== NOT EXECUTED
4002c618: 80 a6 60 0b cmp %i1, 0xb
<== NOT EXECUTED
4002c61c: 02 80 00 44 be 4002c72c <_POSIX_signals_Send+0x170>
<== NOT EXECUTED
4002c620: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
4002c624: f2 27 bf f4 st %i1, [ %fp + -12 ]
<== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
4002c628: b9 28 40 1c sll %g1, %i4, %i4
<== NOT EXECUTED
siginfo->si_code = SI_USER;
if ( !value ) {
4002c62c: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4002c630: 02 80 00 99 be 4002c894 <_POSIX_signals_Send+0x2d8>
<== NOT EXECUTED
4002c634: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
4002c638: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
4002c63c: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
4002c640: b4 10 00 06 mov %g6, %i2
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4002c644: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
return cpu->executing;
4002c648: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4002c64c: 82 00 60 01 inc %g1
<== NOT EXECUTED
* get it an execute it as soon as the dispatcher executes.
*/
the_thread = _Per_CPU_Get_executing( cpu_self );
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
4002c650: c4 02 21 5c ld [ %o0 + 0x15c ], %g2
<== NOT EXECUTED
4002c654: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
4002c658: c2 00 a0 68 ld [ %g2 + 0x68 ], %g1
<== NOT EXECUTED
4002c65c: 80 8f 00 01 btst %i4, %g1
<== NOT EXECUTED
4002c660: 12 80 00 1a bne 4002c6c8 <_POSIX_signals_Send+0x10c>
<== NOT EXECUTED
4002c664: 03 10 00 cc sethi %hi(0x40033000), %g1
<== NOT EXECUTED
* There is no requirement on the order of threads pending on a sigwait().
*/
/* XXX violation of visibility -- need to define thread queue support */
heads = _POSIX_signals_Wait_queue.Queue.heads;
4002c668: c4 00 62 48 ld [ %g1 + 0x248 ], %g2 ! 40033248 <_POSIX_signals_Wait_queue>
<== NOT EXECUTED
if ( heads != NULL ) {
4002c66c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4002c670: 02 80 00 3d be 4002c764 <_POSIX_signals_Send+0x1a8>
<== NOT EXECUTED
4002c674: 17 10 00 bb sethi %hi(0x4002ec00), %o3
<== NOT EXECUTED
4002c678: c2 00 80 00 ld [ %g2 ], %g1
<== NOT EXECUTED
return &the_chain->Tail.Node;
4002c67c: 84 00 a0 04 add %g2, 4, %g2
<== NOT EXECUTED
Chain_Control *the_chain = &heads->Heads.Fifo;
for ( the_node = _Chain_First( the_chain );
4002c680: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4002c684: 32 80 00 0d bne,a 4002c6b8 <_POSIX_signals_Send+0xfc>
<== NOT EXECUTED
4002c688: d0 00 7f f8 ld [ %g1 + -8 ], %o0
<== NOT EXECUTED
4002c68c: 10 80 00 37 b 4002c768 <_POSIX_signals_Send+0x1ac>
<== NOT EXECUTED
4002c690: 9e 10 3f ff mov -1, %o7
<== NOT EXECUTED
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (api->signals_unblocked & mask)
4002c694: c6 01 20 68 ld [ %g4 + 0x68 ], %g3
<== NOT EXECUTED
4002c698: 80 8f 00 03 btst %i4, %g3
<== NOT EXECUTED
4002c69c: 12 80 00 0c bne 4002c6cc <_POSIX_signals_Send+0x110>
<== NOT EXECUTED
4002c6a0: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
the_node = the_node->next ) {
4002c6a4: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
4002c6a8: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4002c6ac: 02 80 00 2e be 4002c764 <_POSIX_signals_Send+0x1a8>
<== NOT EXECUTED
4002c6b0: 17 10 00 bb sethi %hi(0x4002ec00), %o3
<== NOT EXECUTED
4002c6b4: d0 00 7f f8 ld [ %g1 + -8 ], %o0
<== NOT EXECUTED
if (the_thread->Wait.option & mask)
4002c6b8: c6 02 20 48 ld [ %o0 + 0x48 ], %g3
<== NOT EXECUTED
4002c6bc: 80 8f 00 03 btst %i4, %g3
<== NOT EXECUTED
4002c6c0: 02 bf ff f5 be 4002c694 <_POSIX_signals_Send+0xd8>
<== NOT EXECUTED
4002c6c4: c8 02 21 5c ld [ %o0 + 0x15c ], %g4
<== NOT EXECUTED
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
4002c6c8: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
4002c6cc: 40 00 01 60 call 4002cc4c <_POSIX_signals_Unblock_thread>
<== NOT EXECUTED
4002c6d0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4002c6d4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4002c6d8: 12 80 00 1b bne 4002c744 <_POSIX_signals_Send+0x188>
<== NOT EXECUTED
4002c6dc: 01 00 00 00 nop
<== NOT EXECUTED
/*
* We may have woken up a thread but we definitely need to post the
* signal to the process wide information set.
*/
_POSIX_signals_Set_process_signals( mask );
4002c6e0: 40 00 00 f0 call 4002caa0 <_POSIX_signals_Set_process_signals>
<== NOT EXECUTED
4002c6e4: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002c6e8: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4002c6ec: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
_Thread_queue_Context_initialize( &queue_context );
_POSIX_signals_Acquire( &queue_context );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
4002c6f0: bb 2f 60 02 sll %i5, 2, %i5
<== NOT EXECUTED
4002c6f4: c4 06 c0 1d ld [ %i3 + %i5 ], %g2
<== NOT EXECUTED
4002c6f8: 80 a0 a0 02 cmp %g2, 2
<== NOT EXECUTED
4002c6fc: 02 80 00 6c be 4002c8ac <_POSIX_signals_Send+0x2f0>
<== NOT EXECUTED
4002c700: 09 10 00 d6 sethi %hi(0x40035800), %g4
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4002c704: 82 10 00 03 mov %g3, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002c708: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002c70c: 01 00 00 00 nop
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4002c710: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4002c714: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4002c718: 02 80 00 7f be 4002c914 <_POSIX_signals_Send+0x358>
<== NOT EXECUTED
4002c71c: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4002c720: c2 26 a0 18 st %g1, [ %i2 + 0x18 ]
<== NOT EXECUTED
_POSIX_signals_Release( &queue_context );
DEBUG_STEP("\n");
_Thread_Dispatch_enable( cpu_self );
return 0;
}
4002c724: 81 c7 e0 08 ret
<== NOT EXECUTED
4002c728: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
return pthread_kill( pthread_self(), sig );
4002c72c: 40 00 01 f9 call 4002cf10 <pthread_self>
<== NOT EXECUTED
4002c730: 01 00 00 00 nop
<== NOT EXECUTED
4002c734: 40 00 01 b5 call 4002ce08 <pthread_kill>
<== NOT EXECUTED
4002c738: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4002c73c: 81 c7 e0 08 ret
<== NOT EXECUTED
4002c740: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4002c744: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4002c748: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4002c74c: 02 80 00 72 be 4002c914 <_POSIX_signals_Send+0x358>
<== NOT EXECUTED
4002c750: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
return 0;
4002c754: b0 10 20 00 clr %i0
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4002c758: c2 26 a0 18 st %g1, [ %i2 + 0x18 ]
<== NOT EXECUTED
4002c75c: 81 c7 e0 08 ret
<== NOT EXECUTED
4002c760: 81 e8 00 00 restore
<== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
4002c764: 9e 10 3f ff mov -1, %o7
<== NOT EXECUTED
4002c768: 94 10 3f ff mov -1, %o2
<== NOT EXECUTED
4002c76c: 90 10 20 00 clr %o0
<== NOT EXECUTED
4002c770: 98 10 20 02 mov 2, %o4
<== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
4002c774: 13 04 00 00 sethi %hi(0x10000000), %o1
<== NOT EXECUTED
4002c778: 96 12 e2 f0 or %o3, 0x2f0, %o3
<== NOT EXECUTED
if ( !_Objects_Information_table[ the_api ] )
4002c77c: 83 2b 20 02 sll %o4, 2, %g1
<== NOT EXECUTED
4002c780: c2 02 c0 01 ld [ %o3 + %g1 ], %g1
<== NOT EXECUTED
4002c784: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4002c788: 02 80 00 39 be 4002c86c <_POSIX_signals_Send+0x2b0>
<== NOT EXECUTED
4002c78c: 80 a3 20 03 cmp %o4, 3
<== NOT EXECUTED
the_info = _Objects_Information_table[ the_api ][ 1 ];
4002c790: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
if ( !the_info )
4002c794: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4002c798: 02 80 00 35 be 4002c86c <_POSIX_signals_Send+0x2b0>
<== NOT EXECUTED
4002c79c: 80 a3 20 03 cmp %o4, 3
<== NOT EXECUTED
maximum = the_info->maximum;
4002c7a0: f0 10 60 10 lduh [ %g1 + 0x10 ], %i0
<== NOT EXECUTED
for ( index = 1 ; index <= maximum ; index++ ) {
4002c7a4: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4002c7a8: 02 80 00 30 be 4002c868 <_POSIX_signals_Send+0x2ac>
<== NOT EXECUTED
4002c7ac: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
4002c7b0: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
4002c7b4: b1 2e 20 02 sll %i0, 2, %i0
<== NOT EXECUTED
4002c7b8: b0 06 00 01 add %i0, %g1, %i0
<== NOT EXECUTED
the_thread = (Thread_Control *) object_table[ index ];
4002c7bc: c4 00 40 00 ld [ %g1 ], %g2
<== NOT EXECUTED
if ( !the_thread )
4002c7c0: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4002c7c4: 22 80 00 26 be,a 4002c85c <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
4002c7c8: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
4002c7cc: c6 00 a0 38 ld [ %g2 + 0x38 ], %g3
<== NOT EXECUTED
4002c7d0: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
<== NOT EXECUTED
if ( _Thread_Get_priority( the_thread ) > interested_priority )
4002c7d4: 80 a1 00 0f cmp %g4, %o7
<== NOT EXECUTED
4002c7d8: 18 80 00 20 bgu 4002c858 <_POSIX_signals_Send+0x29c>
<== NOT EXECUTED
4002c7dc: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
<== NOT EXECUTED
4002c7e0: 02 80 00 29 be 4002c884 <_POSIX_signals_Send+0x2c8>
<== NOT EXECUTED
4002c7e4: 80 a0 c0 0a cmp %g3, %o2
<== NOT EXECUTED
if ( !_POSIX_signals_Is_interested( api, mask ) )
4002c7e8: da 00 a1 5c ld [ %g2 + 0x15c ], %o5
<== NOT EXECUTED
4002c7ec: da 03 60 68 ld [ %o5 + 0x68 ], %o5
<== NOT EXECUTED
4002c7f0: 80 8f 00 0d btst %i4, %o5
<== NOT EXECUTED
4002c7f4: 02 80 00 19 be 4002c858 <_POSIX_signals_Send+0x29c>
<== NOT EXECUTED
4002c7f8: 80 a3 c0 04 cmp %o7, %g4
<== NOT EXECUTED
if ( _Thread_Get_priority( the_thread ) < interested_priority ) {
4002c7fc: 38 80 00 15 bgu,a 4002c850 <_POSIX_signals_Send+0x294>
<== NOT EXECUTED
4002c800: 9e 10 00 04 mov %g4, %o7
<== NOT EXECUTED
4002c804: 02 80 00 26 be 4002c89c <_POSIX_signals_Send+0x2e0>
<== NOT EXECUTED
4002c808: 80 a2 80 03 cmp %o2, %g3
<== NOT EXECUTED
if ( interested && !_States_Is_ready( interested->current_state ) ) {
4002c80c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4002c810: 22 80 00 13 be,a 4002c85c <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
4002c814: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
4002c818: da 02 20 1c ld [ %o0 + 0x1c ], %o5
<== NOT EXECUTED
4002c81c: 80 a3 60 00 cmp %o5, 0
<== NOT EXECUTED
4002c820: 22 80 00 0f be,a 4002c85c <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
4002c824: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
if ( _States_Is_ready( the_thread->current_state ) ) {
4002c828: e0 00 a0 1c ld [ %g2 + 0x1c ], %l0
<== NOT EXECUTED
4002c82c: 80 a4 20 00 cmp %l0, 0
<== NOT EXECUTED
4002c830: 02 80 00 07 be 4002c84c <_POSIX_signals_Send+0x290>
<== NOT EXECUTED
4002c834: 80 8b 40 09 btst %o5, %o1
<== NOT EXECUTED
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
4002c838: 32 80 00 09 bne,a 4002c85c <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
4002c83c: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
4002c840: 80 8c 00 09 btst %l0, %o1
<== NOT EXECUTED
4002c844: 22 80 00 06 be,a 4002c85c <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
4002c848: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
4002c84c: 9e 10 00 04 mov %g4, %o7
<== NOT EXECUTED
4002c850: 94 10 00 03 mov %g3, %o2
<== NOT EXECUTED
4002c854: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
4002c858: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
for ( index = 1 ; index <= maximum ; index++ ) {
4002c85c: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
4002c860: 32 bf ff d8 bne,a 4002c7c0 <_POSIX_signals_Send+0x204>
<== NOT EXECUTED
4002c864: c4 00 40 00 ld [ %g1 ], %g2
<== NOT EXECUTED
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
4002c868: 80 a3 20 03 cmp %o4, 3
<== NOT EXECUTED
4002c86c: 12 bf ff c4 bne 4002c77c <_POSIX_signals_Send+0x1c0>
<== NOT EXECUTED
4002c870: 98 10 20 03 mov 3, %o4
<== NOT EXECUTED
if ( interested ) {
4002c874: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4002c878: 12 bf ff 95 bne 4002c6cc <_POSIX_signals_Send+0x110>
<== NOT EXECUTED
4002c87c: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
4002c880: 30 bf ff 98 b,a 4002c6e0 <_POSIX_signals_Send+0x124>
<== NOT EXECUTED
if ( _Thread_Get_priority( the_thread ) > interested_priority )
4002c884: 28 bf ff da bleu,a 4002c7ec <_POSIX_signals_Send+0x230>
<== NOT EXECUTED
4002c888: da 00 a1 5c ld [ %g2 + 0x15c ], %o5
<== NOT EXECUTED
4002c88c: 10 bf ff f4 b 4002c85c <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
4002c890: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
4002c894: 10 bf ff 6b b 4002c640 <_POSIX_signals_Send+0x84>
<== NOT EXECUTED
4002c898: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
if ( _Thread_Get_priority( the_thread ) < interested_priority ) {
4002c89c: 08 bf ff dd bleu 4002c810 <_POSIX_signals_Send+0x254>
<== NOT EXECUTED
4002c8a0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4002c8a4: 10 bf ff eb b 4002c850 <_POSIX_signals_Send+0x294>
<== NOT EXECUTED
4002c8a8: 9e 10 00 04 mov %g4, %o7
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4002c8ac: c4 01 21 68 ld [ %g4 + 0x168 ], %g2
<== NOT EXECUTED
4002c8b0: b8 11 21 68 or %g4, 0x168, %i4
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
4002c8b4: b6 07 20 04 add %i4, 4, %i3
<== NOT EXECUTED
4002c8b8: 80 a0 80 1b cmp %g2, %i3
<== NOT EXECUTED
4002c8bc: 02 80 00 31 be 4002c980 <_POSIX_signals_Send+0x3c4>
<== NOT EXECUTED
4002c8c0: 01 00 00 00 nop
<== NOT EXECUTED
new_first = old_first->next;
4002c8c4: c2 00 80 00 ld [ %g2 ], %g1
<== NOT EXECUTED
new_first->previous = head;
4002c8c8: f8 20 60 04 st %i4, [ %g1 + 4 ]
<== NOT EXECUTED
psiginfo->Info = *siginfo;
4002c8cc: f6 07 bf fc ld [ %fp + -4 ], %i3
<== NOT EXECUTED
4002c8d0: f2 07 bf f8 ld [ %fp + -8 ], %i1
<== NOT EXECUTED
head->next = new_first;
4002c8d4: c2 21 21 68 st %g1, [ %g4 + 0x168 ]
<== NOT EXECUTED
_Chain_Append_unprotected(
4002c8d8: 03 10 00 d6 sethi %hi(0x40035800), %g1
<== NOT EXECUTED
psiginfo->Info = *siginfo;
4002c8dc: c8 07 bf f4 ld [ %fp + -12 ], %g4
<== NOT EXECUTED
4002c8e0: c8 20 a0 08 st %g4, [ %g2 + 8 ]
<== NOT EXECUTED
_Chain_Append_unprotected(
4002c8e4: 82 10 61 78 or %g1, 0x178, %g1
<== NOT EXECUTED
psiginfo->Info = *siginfo;
4002c8e8: f2 20 a0 0c st %i1, [ %g2 + 0xc ]
<== NOT EXECUTED
_Chain_Append_unprotected(
4002c8ec: b8 07 40 01 add %i5, %g1, %i4
<== NOT EXECUTED
return &the_chain->Tail.Node;
4002c8f0: ba 07 60 04 add %i5, 4, %i5
<== NOT EXECUTED
old_last = tail->previous;
4002c8f4: c8 07 20 08 ld [ %i4 + 8 ], %g4
<== NOT EXECUTED
return &the_chain->Tail.Node;
4002c8f8: ba 07 40 01 add %i5, %g1, %i5
<== NOT EXECUTED
psiginfo->Info = *siginfo;
4002c8fc: f6 20 a0 10 st %i3, [ %g2 + 0x10 ]
<== NOT EXECUTED
the_node->next = tail;
4002c900: fa 20 80 00 st %i5, [ %g2 ]
<== NOT EXECUTED
tail->previous = the_node;
4002c904: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
4002c908: c4 21 00 00 st %g2, [ %g4 ]
<== NOT EXECUTED
the_node->previous = old_last;
4002c90c: 10 bf ff 7e b 4002c704 <_POSIX_signals_Send+0x148>
<== NOT EXECUTED
4002c910: c8 20 a0 04 st %g4, [ %g2 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002c914: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4002c918: c4 0e a0 1c ldub [ %i2 + 0x1c ], %g2
<== NOT EXECUTED
4002c91c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4002c920: 12 80 00 07 bne 4002c93c <_POSIX_signals_Send+0x380>
<== NOT EXECUTED
4002c924: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4002c928: c0 26 a0 18 clr [ %i2 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002c92c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002c930: 01 00 00 00 nop
<== NOT EXECUTED
return 0;
4002c934: 81 c7 e0 08 ret
<== NOT EXECUTED
4002c938: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
4002c93c: c2 27 bf ec st %g1, [ %fp + -20 ]
<== NOT EXECUTED
4002c940: 7f ff 9a f2 call 40013508 <_Thread_Do_dispatch>
<== NOT EXECUTED
4002c944: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
4002c948: 10 bf ff f9 b 4002c92c <_POSIX_signals_Send+0x370>
<== NOT EXECUTED
4002c94c: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
4002c950: 7f ff bc ec call 4001bd00 <__errno>
<== NOT EXECUTED
4002c954: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4002c958: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4002c95c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4002c960: 81 c7 e0 08 ret
<== NOT EXECUTED
4002c964: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ESRCH );
4002c968: 7f ff bc e6 call 4001bd00 <__errno>
<== NOT EXECUTED
4002c96c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4002c970: 82 10 20 03 mov 3, %g1
<== NOT EXECUTED
4002c974: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4002c978: 81 c7 e0 08 ret
<== NOT EXECUTED
4002c97c: 81 e8 00 00 restore
<== NOT EXECUTED
4002c980: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002c984: 01 00 00 00 nop
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4002c988: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4002c98c: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4002c990: 02 80 00 09 be 4002c9b4 <_POSIX_signals_Send+0x3f8>
<== NOT EXECUTED
4002c994: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4002c998: c2 26 a0 18 st %g1, [ %i2 + 0x18 ]
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EAGAIN );
4002c99c: 7f ff bc d9 call 4001bd00 <__errno>
<== NOT EXECUTED
4002c9a0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4002c9a4: 82 10 20 0b mov 0xb, %g1
<== NOT EXECUTED
4002c9a8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4002c9ac: 81 c7 e0 08 ret
<== NOT EXECUTED
4002c9b0: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002c9b4: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4002c9b8: c4 0e a0 1c ldub [ %i2 + 0x1c ], %g2
<== NOT EXECUTED
4002c9bc: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4002c9c0: 12 80 00 06 bne 4002c9d8 <_POSIX_signals_Send+0x41c>
<== NOT EXECUTED
4002c9c4: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4002c9c8: c0 26 a0 18 clr [ %i2 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002c9cc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002c9d0: 01 00 00 00 nop
<== NOT EXECUTED
4002c9d4: 30 bf ff f2 b,a 4002c99c <_POSIX_signals_Send+0x3e0>
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
4002c9d8: c2 27 bf ec st %g1, [ %fp + -20 ]
<== NOT EXECUTED
4002c9dc: 7f ff 9a cb call 40013508 <_Thread_Do_dispatch>
<== NOT EXECUTED
4002c9e0: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
4002c9e4: 10 bf ff fa b 4002c9cc <_POSIX_signals_Send+0x410>
<== NOT EXECUTED
4002c9e8: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
4002caa0 <_POSIX_signals_Set_process_signals>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002caa0: 91 d0 20 09 ta 9
<== NOT EXECUTED
{
Thread_queue_Context queue_context;
_Thread_queue_Context_initialize( &queue_context );
_POSIX_signals_Acquire( &queue_context );
_POSIX_signals_Pending |= mask;
4002caa4: 07 10 00 d6 sethi %hi(0x40035800), %g3
<== NOT EXECUTED
4002caa8: c4 00 e1 74 ld [ %g3 + 0x174 ], %g2 ! 40035974 <_POSIX_signals_Pending>
<== NOT EXECUTED
4002caac: 90 10 80 08 or %g2, %o0, %o0
<== NOT EXECUTED
4002cab0: d0 20 e1 74 st %o0, [ %g3 + 0x174 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002cab4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002cab8: 01 00 00 00 nop
<== NOT EXECUTED
_POSIX_signals_Release( &queue_context );
}
4002cabc: 81 c3 e0 08 retl
<== NOT EXECUTED
4002cac0: 01 00 00 00 nop
<== NOT EXECUTED
4002cc4c <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
4002cc4c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4002cc50: fa 06 21 5c ld [ %i0 + 0x15c ], %i5
<== NOT EXECUTED
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
4002cc54: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
<== NOT EXECUTED
4002cc58: 05 04 00 01 sethi %hi(0x10000400), %g2
<== NOT EXECUTED
4002cc5c: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
4002cc60: 82 06 7f ff add %i1, -1, %g1
<== NOT EXECUTED
4002cc64: b8 08 c0 02 and %g3, %g2, %i4
<== NOT EXECUTED
4002cc68: 83 29 00 01 sll %g4, %g1, %g1
<== NOT EXECUTED
4002cc6c: 80 a7 00 02 cmp %i4, %g2
<== NOT EXECUTED
4002cc70: 02 80 00 19 be 4002ccd4 <_POSIX_signals_Unblock_thread+0x88>
<== NOT EXECUTED
4002cc74: b6 07 60 70 add %i5, 0x70, %i3
<== NOT EXECUTED
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( api->signals_unblocked & mask ) {
4002cc78: c4 07 60 68 ld [ %i5 + 0x68 ], %g2
<== NOT EXECUTED
4002cc7c: 80 88 40 02 btst %g1, %g2
<== NOT EXECUTED
4002cc80: 02 80 00 05 be 4002cc94 <_POSIX_signals_Unblock_thread+0x48>
<== NOT EXECUTED
4002cc84: 03 04 00 00 sethi %hi(0x10000000), %g1
<== NOT EXECUTED
* it is not blocked, THEN
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
4002cc88: 80 88 c0 01 btst %g3, %g1
<== NOT EXECUTED
4002cc8c: 12 80 00 4b bne 4002cdb8 <_POSIX_signals_Unblock_thread+0x16c>
<== NOT EXECUTED
4002cc90: 82 10 24 0d mov 0x40d, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002cc94: 91 d0 20 09 ta 9
<== NOT EXECUTED
action->handler = handler;
4002cc98: 05 10 00 b2 sethi %hi(0x4002c800), %g2
<== NOT EXECUTED
4002cc9c: 84 10 a3 60 or %g2, 0x360, %g2 ! 4002cb60 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
4002cca0: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
cpu_self->dispatch_necessary = true;
4002cca4: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
4002cca8: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
<== NOT EXECUTED
if ( _Chain_Is_node_off_chain( the_node ) ) {
4002ccac: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
4002ccb0: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4002ccb4: 22 80 00 1a be,a 4002cd1c <_POSIX_signals_Unblock_thread+0xd0>
<== NOT EXECUTED
4002ccb8: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002ccbc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002ccc0: 01 00 00 00 nop
<== NOT EXECUTED
the_thread->Wait.return_code = STATUS_INTERRUPTED;
_Thread_queue_Extract_with_proxy( the_thread );
}
}
return _POSIX_signals_Unblock_thread_done( the_thread, api, false );
4002ccc4: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
}
4002ccc8: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
4002cccc: 81 c7 e0 08 ret
<== NOT EXECUTED
4002ccd0: 81 e8 00 00 restore
<== NOT EXECUTED
if ( (the_thread->Wait.option & mask) || (api->signals_unblocked & mask) ) {
4002ccd4: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
<== NOT EXECUTED
4002ccd8: 80 88 40 02 btst %g1, %g2
<== NOT EXECUTED
4002ccdc: 32 80 00 16 bne,a 4002cd34 <_POSIX_signals_Unblock_thread+0xe8>
<== NOT EXECUTED
4002cce0: 82 10 24 0d mov 0x40d, %g1
<== NOT EXECUTED
4002cce4: c4 07 60 68 ld [ %i5 + 0x68 ], %g2
<== NOT EXECUTED
4002cce8: 80 88 40 02 btst %g1, %g2
<== NOT EXECUTED
4002ccec: 12 80 00 12 bne 4002cd34 <_POSIX_signals_Unblock_thread+0xe8>
<== NOT EXECUTED
4002ccf0: 82 10 24 0d mov 0x40d, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002ccf4: 91 d0 20 09 ta 9
<== NOT EXECUTED
4002ccf8: 05 10 00 b2 sethi %hi(0x4002c800), %g2
<== NOT EXECUTED
4002ccfc: 84 10 a3 60 or %g2, 0x360, %g2 ! 4002cb60 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
4002cd00: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
4002cd04: c8 29 a0 1c stb %g4, [ %g6 + 0x1c ]
<== NOT EXECUTED
4002cd08: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
4002cd0c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4002cd10: 12 bf ff eb bne 4002ccbc <_POSIX_signals_Unblock_thread+0x70>
<== NOT EXECUTED
4002cd14: 01 00 00 00 nop
<== NOT EXECUTED
old_last = tail->previous;
4002cd18: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
return &the_chain->Tail.Node;
4002cd1c: 86 06 20 e4 add %i0, 0xe4, %g3
<== NOT EXECUTED
the_node->next = tail;
4002cd20: c6 27 60 70 st %g3, [ %i5 + 0x70 ]
<== NOT EXECUTED
tail->previous = the_node;
4002cd24: f6 26 20 e8 st %i3, [ %i0 + 0xe8 ]
<== NOT EXECUTED
old_last->next = the_node;
4002cd28: f6 20 80 00 st %i3, [ %g2 ]
<== NOT EXECUTED
the_node->previous = old_last;
4002cd2c: 10 bf ff e4 b 4002ccbc <_POSIX_signals_Unblock_thread+0x70>
<== NOT EXECUTED
4002cd30: c4 27 60 74 st %g2, [ %i5 + 0x74 ]
<== NOT EXECUTED
the_thread->Wait.return_code = STATUS_INTERRUPTED;
4002cd34: c2 26 20 4c st %g1, [ %i0 + 0x4c ]
<== NOT EXECUTED
if ( !info ) {
4002cd38: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4002cd3c: 02 80 00 2e be 4002cdf4 <_POSIX_signals_Unblock_thread+0x1a8>
<== NOT EXECUTED
4002cd40: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
<== NOT EXECUTED
*the_info = *info;
4002cd44: c4 06 80 00 ld [ %i2 ], %g2
<== NOT EXECUTED
4002cd48: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
4002cd4c: c4 06 a0 04 ld [ %i2 + 4 ], %g2
<== NOT EXECUTED
4002cd50: c4 20 60 04 st %g2, [ %g1 + 4 ]
<== NOT EXECUTED
4002cd54: c4 06 a0 08 ld [ %i2 + 8 ], %g2
<== NOT EXECUTED
4002cd58: c4 20 60 08 st %g2, [ %g1 + 8 ]
<== NOT EXECUTED
_Thread_queue_Extract_with_proxy( the_thread );
4002cd5c: 7f ff b7 3e call 4001aa54 <_Thread_queue_Extract_with_proxy>
<== NOT EXECUTED
4002cd60: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4002cd64: 91 d0 20 09 ta 9
<== NOT EXECUTED
4002cd68: 05 10 00 b2 sethi %hi(0x4002c800), %g2
<== NOT EXECUTED
4002cd6c: 84 10 a3 60 or %g2, 0x360, %g2 ! 4002cb60 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
4002cd70: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
4002cd74: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
4002cd78: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
<== NOT EXECUTED
if ( _Chain_Is_node_off_chain( the_node ) ) {
4002cd7c: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
4002cd80: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4002cd84: 12 80 00 07 bne 4002cda0 <_POSIX_signals_Unblock_thread+0x154>
<== NOT EXECUTED
4002cd88: 86 06 20 e4 add %i0, 0xe4, %g3
<== NOT EXECUTED
old_last = tail->previous;
4002cd8c: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
the_node->next = tail;
4002cd90: c6 27 60 70 st %g3, [ %i5 + 0x70 ]
<== NOT EXECUTED
tail->previous = the_node;
4002cd94: f6 26 20 e8 st %i3, [ %i0 + 0xe8 ]
<== NOT EXECUTED
old_last->next = the_node;
4002cd98: f6 20 80 00 st %i3, [ %g2 ]
<== NOT EXECUTED
the_node->previous = old_last;
4002cd9c: c4 27 60 74 st %g2, [ %i5 + 0x74 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002cda0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002cda4: 01 00 00 00 nop
<== NOT EXECUTED
return _POSIX_signals_Unblock_thread_done( the_thread, api, true );
4002cda8: b0 10 20 01 mov 1, %i0 ! 1 <_TLS_Alignment>
<== NOT EXECUTED
}
4002cdac: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
4002cdb0: 81 c7 e0 08 ret
<== NOT EXECUTED
4002cdb4: 81 e8 00 00 restore
<== NOT EXECUTED
the_thread->Wait.return_code = STATUS_INTERRUPTED;
4002cdb8: c2 26 20 4c st %g1, [ %i0 + 0x4c ]
<== NOT EXECUTED
_Thread_queue_Extract_with_proxy( the_thread );
4002cdbc: 7f ff b7 26 call 4001aa54 <_Thread_queue_Extract_with_proxy>
<== NOT EXECUTED
4002cdc0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002cdc4: 91 d0 20 09 ta 9
<== NOT EXECUTED
4002cdc8: 05 10 00 b2 sethi %hi(0x4002c800), %g2
<== NOT EXECUTED
4002cdcc: 84 10 a3 60 or %g2, 0x360, %g2 ! 4002cb60 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
4002cdd0: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
4002cdd4: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
4002cdd8: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
<== NOT EXECUTED
if ( _Chain_Is_node_off_chain( the_node ) ) {
4002cddc: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
4002cde0: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4002cde4: 12 bf ff b6 bne 4002ccbc <_POSIX_signals_Unblock_thread+0x70>
<== NOT EXECUTED
4002cde8: 01 00 00 00 nop
<== NOT EXECUTED
old_last = tail->previous;
4002cdec: 10 bf ff cc b 4002cd1c <_POSIX_signals_Unblock_thread+0xd0>
<== NOT EXECUTED
4002cdf0: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
the_info->si_code = SI_USER;
4002cdf4: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
the_info->si_signo = signo;
4002cdf8: f2 20 40 00 st %i1, [ %g1 ]
<== NOT EXECUTED
the_info->si_code = SI_USER;
4002cdfc: c4 20 60 04 st %g2, [ %g1 + 4 ]
<== NOT EXECUTED
4002ce00: 10 bf ff d7 b 4002cd5c <_POSIX_signals_Unblock_thread+0x110>
<== NOT EXECUTED
4002ce04: c0 20 60 08 clr [ %g1 + 8 ]
<== NOT EXECUTED
4002c1e8 <_kill_r>:
int _kill_r(
struct _reent *ptr,
pid_t pid,
int sig
)
{
4002c1e8: 82 10 00 0a mov %o2, %g1
<== NOT EXECUTED
return _POSIX_signals_Send( pid, sig, NULL );
4002c1ec: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
4002c1f0: 94 10 20 00 clr %o2
<== NOT EXECUTED
4002c1f4: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
4002c1f8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4002c1fc: 40 00 00 f0 call 4002c5bc <_POSIX_signals_Send>
<== NOT EXECUTED
4002c200: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40006298 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
40006298: 9d e3 bf a0 save %sp, -96, %sp
if ( !tp )
4000629c: 80 a6 60 00 cmp %i1, 0
400062a0: 02 80 00 1f be 4000631c <clock_gettime+0x84>
<== NEVER TAKEN
400062a4: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
400062a8: 02 80 00 18 be 40006308 <clock_gettime+0x70>
<== ALWAYS TAKEN
400062ac: 82 06 3f fe add %i0, -2, %g1
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
400062b0: 80 88 7f fd btst -3, %g1
<== NOT EXECUTED
400062b4: 02 80 00 0a be 400062dc <clock_gettime+0x44>
<== NOT EXECUTED
400062b8: 80 a6 20 03 cmp %i0, 3
<== NOT EXECUTED
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
400062bc: 02 80 00 0d be 400062f0 <clock_gettime+0x58>
<== NOT EXECUTED
400062c0: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
400062c4: 40 00 22 92 call 4000ed0c <__errno>
<== NOT EXECUTED
400062c8: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
400062cc: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400062d0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return 0;
}
400062d4: 81 c7 e0 08 ret
<== NOT EXECUTED
400062d8: 81 e8 00 00 restore
<== NOT EXECUTED
_Timecounter_Nanouptime( tp );
400062dc: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
400062e0: 40 00 08 b7 call 400085bc <_Timecounter_Nanouptime>
<== NOT EXECUTED
400062e4: b0 10 20 00 clr %i0
<== NOT EXECUTED
return 0;
400062e8: 81 c7 e0 08 ret
<== NOT EXECUTED
400062ec: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
400062f0: 40 00 22 87 call 4000ed0c <__errno>
<== NOT EXECUTED
400062f4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400062f8: 82 10 20 58 mov 0x58, %g1
<== NOT EXECUTED
400062fc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006300: 81 c7 e0 08 ret
<== NOT EXECUTED
40006304: 81 e8 00 00 restore
<== NOT EXECUTED
_Timecounter_Nanotime( tod );
40006308: 90 10 00 19 mov %i1, %o0
4000630c: 40 00 08 e7 call 400086a8 <_Timecounter_Nanotime>
40006310: b0 10 20 00 clr %i0
return 0;
40006314: 81 c7 e0 08 ret
40006318: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EINVAL );
4000631c: 40 00 22 7c call 4000ed0c <__errno>
<== NOT EXECUTED
40006320: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006324: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40006328: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000632c: 81 c7 e0 08 ret
<== NOT EXECUTED
40006330: 81 e8 00 00 restore
<== NOT EXECUTED
40043848 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
40043848: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
if ( !tp )
4004384c: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40043850: 02 80 00 2b be 400438fc <clock_settime+0xb4>
<== NOT EXECUTED
40043854: 80 a6 20 01 cmp %i0, 1
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
40043858: 02 80 00 12 be 400438a0 <clock_settime+0x58>
<== NOT EXECUTED
4004385c: 80 a6 20 02 cmp %i0, 2
<== NOT EXECUTED
_TOD_Acquire( &lock_context );
_TOD_Set( tp, &lock_context );
_TOD_Unlock();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
40043860: 02 80 00 0a be 40043888 <clock_settime+0x40>
<== NOT EXECUTED
40043864: 80 a6 20 03 cmp %i0, 3
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
40043868: 02 80 00 08 be 40043888 <clock_settime+0x40>
<== NOT EXECUTED
4004386c: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
40043870: 40 00 64 29 call 4005c914 <__errno>
<== NOT EXECUTED
40043874: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40043878: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4004387c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return 0;
}
40043880: 81 c7 e0 08 ret
<== NOT EXECUTED
40043884: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
40043888: 40 00 64 23 call 4005c914 <__errno>
<== NOT EXECUTED
4004388c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40043890: 82 10 20 58 mov 0x58, %g1
<== NOT EXECUTED
40043894: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40043898: 81 c7 e0 08 ret
<== NOT EXECUTED
4004389c: 81 e8 00 00 restore
<== NOT EXECUTED
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
400438a0: c2 06 40 00 ld [ %i1 ], %g1
<== NOT EXECUTED
400438a4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400438a8: 04 80 00 0e ble 400438e0 <clock_settime+0x98>
<== NOT EXECUTED
400438ac: 01 00 00 00 nop
<== NOT EXECUTED
_TOD_Lock();
400438b0: 40 00 03 d3 call 400447fc <_TOD_Lock>
<== NOT EXECUTED
400438b4: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400438b8: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Timecounter_Acquire( lock_context );
400438bc: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
_TOD_Set( tp, &lock_context );
400438c0: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
400438c4: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
400438c8: 40 00 03 d7 call 40044824 <_TOD_Set>
<== NOT EXECUTED
400438cc: b0 10 20 00 clr %i0
<== NOT EXECUTED
_TOD_Unlock();
400438d0: 40 00 03 d0 call 40044810 <_TOD_Unlock>
<== NOT EXECUTED
400438d4: 01 00 00 00 nop
<== NOT EXECUTED
return 0;
400438d8: 81 c7 e0 08 ret
<== NOT EXECUTED
400438dc: 81 e8 00 00 restore
<== NOT EXECUTED
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
400438e0: 12 80 00 07 bne 400438fc <clock_settime+0xb4>
<== NOT EXECUTED
400438e4: 03 08 76 b9 sethi %hi(0x21dae400), %g1
<== NOT EXECUTED
400438e8: c4 06 60 04 ld [ %i1 + 4 ], %g2
<== NOT EXECUTED
400438ec: 82 10 60 ff or %g1, 0xff, %g1
<== NOT EXECUTED
400438f0: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
400438f4: 18 bf ff ef bgu 400438b0 <clock_settime+0x68>
<== NOT EXECUTED
400438f8: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
400438fc: 40 00 64 06 call 4005c914 <__errno>
<== NOT EXECUTED
40043900: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40043904: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40043908: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4004390c: 81 c7 e0 08 ret
<== NOT EXECUTED
40043910: 81 e8 00 00 restore
<== NOT EXECUTED
4002c3bc <nanosleep>:
{
4002c3bc: 9d e3 bf a0 save %sp, -96, %sp
4002c3c0: 92 10 20 00 clr %o1
4002c3c4: 94 10 00 18 mov %i0, %o2
4002c3c8: 96 10 00 19 mov %i1, %o3
4002c3cc: 7f ff ff 8e call 4002c204 <clock_nanosleep.part.6>
4002c3d0: 90 10 20 01 mov 1, %o0
if ( eno != 0 ) {
4002c3d4: b0 92 20 00 orcc %o0, 0, %i0
4002c3d8: 12 80 00 04 bne 4002c3e8 <nanosleep+0x2c>
<== NEVER TAKEN
4002c3dc: 01 00 00 00 nop
}
4002c3e0: 81 c7 e0 08 ret
4002c3e4: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( eno );
4002c3e8: 7f ff be 46 call 4001bd00 <__errno>
<== NOT EXECUTED
4002c3ec: 01 00 00 00 nop
<== NOT EXECUTED
4002c3f0: f0 22 00 00 st %i0, [ %o0 ]
<== NOT EXECUTED
}
4002c3f4: 81 c7 e0 08 ret
<== NOT EXECUTED
4002c3f8: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
4001bbe4 <pthread_exit>:
#include <pthread.h>
#include <rtems/score/threadimpl.h>
void pthread_exit( void *value_ptr )
{
4001bbe4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4001bbe8: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4001bbec: 82 00 60 01 inc %g1
<== NOT EXECUTED
4001bbf0: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4001bbf4: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
Per_CPU_Control *cpu_self;
cpu_self = _Thread_Dispatch_disable();
executing = _Per_CPU_Get_executing( cpu_self );
_Thread_Exit( executing, THREAD_LIFE_TERMINATING, value_ptr );
4001bbf8: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
<== NOT EXECUTED
4001bbfc: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
4001bc00: 7f ff e6 2a call 400154a8 <_Thread_Exit>
<== NOT EXECUTED
4001bc04: 92 10 20 04 mov 4, %o1
<== NOT EXECUTED
_Thread_Dispatch_direct( cpu_self );
4001bc08: 7f ff de 88 call 40013628 <_Thread_Dispatch_direct>
<== NOT EXECUTED
4001bc0c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001bc10: 01 00 00 00 nop
<== NOT EXECUTED
400062a4 <pthread_getspecific>:
ISR_Level level;
_ISR_Local_disable( level );
#endif
executing = _Thread_Executing;
400062a4: c6 01 a0 20 ld [ %g6 + 0x20 ], %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400062a8: 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 );
400062ac: 86 00 e1 60 add %g3, 0x160, %g3
RBTree_Node *parent;
link = _RBTree_Root_const_reference( the_rbtree );
parent = NULL;
while ( *link != NULL ) {
400062b0: c4 00 c0 00 ld [ %g3 ], %g2
400062b4: 80 a0 a0 00 cmp %g2, 0
400062b8: 02 80 00 0d be 400062ec <pthread_getspecific+0x48>
<== ALWAYS TAKEN
400062bc: 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;
400062c0: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
<== NOT EXECUTED
parent = *link;
if ( ( *equal )( key, parent ) ) {
400062c4: 80 a2 00 04 cmp %o0, %g4
<== NOT EXECUTED
400062c8: 22 80 00 0e be,a 40006300 <pthread_getspecific+0x5c>
<== NOT EXECUTED
400062cc: d0 00 e0 20 ld [ %g3 + 0x20 ], %o0
<== NOT EXECUTED
return ( *map )( parent );
} else if ( ( *less )( key, parent ) ) {
400062d0: 1a bf ff f8 bcc 400062b0 <pthread_getspecific+0xc>
<== NOT EXECUTED
400062d4: 86 00 a0 04 add %g2, 4, %g3
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
400062d8: 86 10 00 02 mov %g2, %g3
<== NOT EXECUTED
while ( *link != NULL ) {
400062dc: c4 00 c0 00 ld [ %g3 ], %g2
<== NOT EXECUTED
400062e0: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
400062e4: 12 bf ff f7 bne 400062c0 <pthread_getspecific+0x1c>
<== NOT EXECUTED
400062e8: 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;
400062ec: 90 10 20 00 clr %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400062f0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400062f4: 01 00 00 00 nop
}
_POSIX_Keys_Key_value_release( executing, &lock_context );
return value;
}
400062f8: 81 c3 e0 08 retl
400062fc: 01 00 00 00 nop
40006300: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006304: 01 00 00 00 nop
<== NOT EXECUTED
40006308: 81 c3 e0 08 retl
<== NOT EXECUTED
4000630c: 01 00 00 00 nop
<== NOT EXECUTED
40018354 <pthread_key_delete>:
* 17.1.3 Thread-Specific Data Key Deletion, P1003.1c/Draft 10, p. 167
*/
int pthread_key_delete(
pthread_key_t key
)
{
40018354: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
_RTEMS_Lock_allocator();
40018358: 40 00 02 2e call 40018c10 <_RTEMS_Lock_allocator>
<== NOT EXECUTED
4001835c: 33 10 00 d2 sethi %hi(0x40034800), %i1
<== NOT EXECUTED
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
}
RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Get( pthread_key_t key )
{
return (POSIX_Keys_Control *)
40018360: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
the_key = _POSIX_Keys_Get( key );
if ( the_key != NULL ) {
_POSIX_Keys_Destroy( the_key );
eno = 0;
} else {
eno = EINVAL;
40018364: b0 10 20 16 mov 0x16, %i0
<== NOT EXECUTED
40018368: 40 00 0b 1c call 4001afd8 <_Objects_Get_no_protection>
<== NOT EXECUTED
4001836c: 92 16 61 c0 or %i1, 0x1c0, %o1
<== NOT EXECUTED
if ( the_key != NULL ) {
40018370: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40018374: 02 80 00 24 be 40018404 <pthread_key_delete+0xb0>
<== NOT EXECUTED
40018378: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
_Objects_Close( &_POSIX_Keys_Information, &the_key->Object );
4001837c: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
40018380: 40 00 0a 1e call 4001abf8 <_Objects_Close>
<== NOT EXECUTED
40018384: 90 16 61 c0 or %i1, 0x1c0, %o0
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40018388: fa 07 20 14 ld [ %i4 + 0x14 ], %i5
<== NOT EXECUTED
return &the_chain->Tail.Node;
4001838c: b4 07 20 18 add %i4, 0x18, %i2
<== NOT EXECUTED
while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) {
40018390: 80 a6 80 1d cmp %i2, %i5
<== NOT EXECUTED
40018394: 02 80 00 19 be 400183f8 <pthread_key_delete+0xa4>
<== NOT EXECUTED
40018398: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4001839c: 37 10 00 d2 sethi %hi(0x40034800), %i3
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Keys_Key_value_free(
POSIX_Keys_Key_value_pair *key_value_pair
)
{
_Chain_Extract_unprotected( &key_value_pair->Key_node );
_Freechain_Put( &_POSIX_Keys_Keypool, key_value_pair );
400183a0: b6 16 e1 fc or %i3, 0x1fc, %i3 ! 400349fc <_POSIX_Keys_Keypool>
<== NOT EXECUTED
the_thread = key_value_pair->thread;
400183a4: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400183a8: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
400183ac: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
_RBTree_Extract(
400183b0: 92 07 60 08 add %i5, 8, %o1
<== NOT EXECUTED
400183b4: 40 00 0b ba call 4001b29c <_RBTree_Extract>
<== NOT EXECUTED
400183b8: 90 02 21 60 add %o0, 0x160, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400183bc: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400183c0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400183c4: 01 00 00 00 nop
<== NOT EXECUTED
next = the_node->next;
400183c8: c4 07 40 00 ld [ %i5 ], %g2
<== NOT EXECUTED
previous = the_node->previous;
400183cc: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
next->previous = previous;
400183d0: c2 20 a0 04 st %g1, [ %g2 + 4 ]
<== NOT EXECUTED
400183d4: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
previous->next = next;
400183d8: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
400183dc: 40 00 02 6e call 40018d94 <_Freechain_Put>
<== NOT EXECUTED
400183e0: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
400183e4: fa 07 20 14 ld [ %i4 + 0x14 ], %i5
<== NOT EXECUTED
while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) {
400183e8: 80 a7 40 1a cmp %i5, %i2
<== NOT EXECUTED
400183ec: 32 bf ff ef bne,a 400183a8 <pthread_key_delete+0x54>
<== NOT EXECUTED
400183f0: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
<== NOT EXECUTED
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
400183f4: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
400183f8: 90 16 61 c0 or %i1, 0x1c0, %o0
<== NOT EXECUTED
400183fc: 40 00 0a cb call 4001af28 <_Objects_Free>
<== NOT EXECUTED
40018400: b0 10 20 00 clr %i0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
40018404: 40 00 02 08 call 40018c24 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40018408: 01 00 00 00 nop
<== NOT EXECUTED
}
_Objects_Allocator_unlock();
return eno;
}
4001840c: 81 c7 e0 08 ret
<== NOT EXECUTED
40018410: 81 e8 00 00 restore
<== NOT EXECUTED
4002ce08 <pthread_kill>:
#include <rtems/posix/threadsup.h>
#include <rtems/posix/psignalimpl.h>
#include <rtems/score/threadimpl.h>
int pthread_kill( pthread_t thread, int sig )
{
4002ce08: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
4002ce0c: ba 06 7f ff add %i1, -1, %i5
<== NOT EXECUTED
Thread_Control *the_thread;
ISR_lock_Context lock_context;
POSIX_API_Control *api;
Per_CPU_Control *cpu_self;
if ( !is_valid_signo( sig ) ) {
4002ce10: 80 a7 60 1f cmp %i5, 0x1f
<== NOT EXECUTED
4002ce14: 18 80 00 28 bgu 4002ceb4 <pthread_kill+0xac>
<== NOT EXECUTED
4002ce18: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
return EINVAL;
}
the_thread = _Thread_Get( thread, &lock_context );
4002ce1c: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
4002ce20: 7f ff 9a 19 call 40013684 <_Thread_Get>
<== NOT EXECUTED
4002ce24: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( the_thread == NULL ) {
4002ce28: 86 92 20 00 orcc %o0, 0, %g3
<== NOT EXECUTED
4002ce2c: 02 80 00 22 be 4002ceb4 <pthread_kill+0xac>
<== NOT EXECUTED
4002ce30: 82 10 20 03 mov 3, %g1
<== NOT EXECUTED
return ESRCH;
}
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
4002ce34: 83 2e 60 01 sll %i1, 1, %g1
<== NOT EXECUTED
4002ce38: 82 00 40 19 add %g1, %i1, %g1
<== NOT EXECUTED
4002ce3c: 85 28 60 02 sll %g1, 2, %g2
<== NOT EXECUTED
4002ce40: 03 10 00 d5 sethi %hi(0x40035400), %g1
<== NOT EXECUTED
4002ce44: 82 10 63 e8 or %g1, 0x3e8, %g1 ! 400357e8 <_POSIX_signals_Vectors>
<== NOT EXECUTED
4002ce48: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4002ce4c: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
4002ce50: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4002ce54: 02 80 00 24 be 4002cee4 <pthread_kill+0xdc>
<== NOT EXECUTED
4002ce58: 01 00 00 00 nop
<== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4002ce5c: c8 00 e1 5c ld [ %g3 + 0x15c ], %g4
<== NOT EXECUTED
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
4002ce60: c4 01 20 6c ld [ %g4 + 0x6c ], %g2
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4002ce64: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
return 1u << (sig - 1);
4002ce68: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
4002ce6c: bb 28 c0 1d sll %g3, %i5, %i5
<== NOT EXECUTED
4002ce70: ba 10 80 1d or %g2, %i5, %i5
<== NOT EXECUTED
4002ce74: fa 21 20 6c st %i5, [ %g4 + 0x6c ]
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4002ce78: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4002ce7c: b8 10 00 06 mov %g6, %i4
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4002ce80: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4002ce84: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002ce88: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002ce8c: 01 00 00 00 nop
<== NOT EXECUTED
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
_ISR_lock_ISR_enable( &lock_context );
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
4002ce90: 94 10 20 00 clr %o2 ! 0 <PROM_START>
<== NOT EXECUTED
4002ce94: 7f ff ff 6e call 4002cc4c <_POSIX_signals_Unblock_thread>
<== NOT EXECUTED
4002ce98: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4002ce9c: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4002cea0: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4002cea4: 02 80 00 06 be 4002cebc <pthread_kill+0xb4>
<== NOT EXECUTED
4002cea8: 84 00 7f ff add %g1, -1, %g2
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4002ceac: c4 27 20 18 st %g2, [ %i4 + 0x18 ]
<== NOT EXECUTED
_Thread_Dispatch_enable( cpu_self );
return 0;
4002ceb0: 82 10 20 00 clr %g1
<== NOT EXECUTED
}
4002ceb4: 81 c7 e0 08 ret
<== NOT EXECUTED
4002ceb8: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002cebc: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4002cec0: c4 0f 20 1c ldub [ %i4 + 0x1c ], %g2
<== NOT EXECUTED
4002cec4: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4002cec8: 12 80 00 0d bne 4002cefc <pthread_kill+0xf4>
<== NOT EXECUTED
4002cecc: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4002ced0: c0 27 20 18 clr [ %i4 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002ced4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002ced8: 01 00 00 00 nop
<== NOT EXECUTED
return 0;
4002cedc: 10 bf ff f6 b 4002ceb4 <pthread_kill+0xac>
<== NOT EXECUTED
4002cee0: 82 10 20 00 clr %g1 ! 0 <PROM_START>
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4002cee4: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002cee8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002ceec: 01 00 00 00 nop
<== NOT EXECUTED
return 0;
4002cef0: 82 10 20 00 clr %g1 ! 0 <PROM_START>
<== NOT EXECUTED
}
4002cef4: 81 c7 e0 08 ret
<== NOT EXECUTED
4002cef8: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
4002cefc: c2 27 bf f4 st %g1, [ %fp + -12 ]
<== NOT EXECUTED
4002cf00: 7f ff 99 82 call 40013508 <_Thread_Do_dispatch>
<== NOT EXECUTED
4002cf04: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4002cf08: 10 bf ff f3 b 4002ced4 <pthread_kill+0xcc>
<== NOT EXECUTED
4002cf0c: c2 07 bf f4 ld [ %fp + -12 ], %g1
<== NOT EXECUTED
4000dab8 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
4000dab8: 80 a2 20 00 cmp %o0, 0
4000dabc: 02 80 00 07 be 4000dad8 <pthread_once+0x20>
<== NEVER TAKEN
4000dac0: 80 a2 60 00 cmp %o1, 0
4000dac4: 02 80 00 05 be 4000dad8 <pthread_once+0x20>
<== NEVER TAKEN
4000dac8: 01 00 00 00 nop
return EINVAL;
return _Once( &once_control->_flags, init_routine );
4000dacc: 82 13 c0 00 mov %o7, %g1
4000dad0: 40 00 10 bc call 40011dc0 <_Once>
4000dad4: 9e 10 40 00 mov %g1, %o7
}
4000dad8: 81 c3 e0 08 retl
<== NOT EXECUTED
4000dadc: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4002cf10 <pthread_self>:
#include <rtems/score/percpu.h>
#include <rtems/score/thread.h>
pthread_t pthread_self( void )
{
return _Thread_Get_executing()->Object.id;
4002cf10: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1
<== NOT EXECUTED
}
4002cf14: 81 c3 e0 08 retl
<== NOT EXECUTED
4002cf18: d0 00 60 08 ld [ %g1 + 8 ], %o0
<== NOT EXECUTED
40018600 <pthread_setspecific>:
int pthread_setspecific(
pthread_key_t key,
const void *value
)
{
40018600: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
40018604: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
Thread_Control *executing;
int eno;
executing = _Thread_Get_executing();
if ( value != NULL ) {
40018608: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4001860c: 02 80 00 52 be 40018754 <pthread_setspecific+0x154>
<== NOT EXECUTED
40018610: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018614: 91 d0 20 09 ta 9
<== NOT EXECUTED
return &RB_ROOT( the_rbtree );
40018618: b6 07 21 60 add %i4, 0x160, %i3
<== NOT EXECUTED
link = _RBTree_Root_const_reference( the_rbtree );
4001861c: 86 10 00 1b mov %i3, %g3
<== NOT EXECUTED
while ( *link != NULL ) {
40018620: c4 00 c0 00 ld [ %g3 ], %g2
<== NOT EXECUTED
40018624: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40018628: 02 80 00 0d be 4001865c <pthread_setspecific+0x5c>
<== NOT EXECUTED
4001862c: 86 00 bf f8 add %g2, -8, %g3
<== NOT EXECUTED
return *the_left == the_right->key;
40018630: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
<== NOT EXECUTED
if ( ( *equal )( key, parent ) ) {
40018634: 80 a7 40 04 cmp %i5, %g4
<== NOT EXECUTED
40018638: 22 80 00 31 be,a 400186fc <pthread_setspecific+0xfc>
<== NOT EXECUTED
4001863c: f2 20 e0 20 st %i1, [ %g3 + 0x20 ]
<== NOT EXECUTED
} else if ( ( *less )( key, parent ) ) {
40018640: 1a bf ff f8 bcc 40018620 <pthread_setspecific+0x20>
<== NOT EXECUTED
40018644: 86 00 a0 04 add %g2, 4, %g3
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
40018648: 86 10 00 02 mov %g2, %g3
<== NOT EXECUTED
while ( *link != NULL ) {
4001864c: c4 00 c0 00 ld [ %g3 ], %g2
<== NOT EXECUTED
40018650: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40018654: 12 bf ff f7 bne 40018630 <pthread_setspecific+0x30>
<== NOT EXECUTED
40018658: 86 00 bf f8 add %g2, -8, %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001865c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018660: 01 00 00 00 nop
<== NOT EXECUTED
_RTEMS_Lock_allocator();
40018664: 40 00 01 6b call 40018c10 <_RTEMS_Lock_allocator>
<== NOT EXECUTED
40018668: b0 10 20 16 mov 0x16, %i0 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
return (POSIX_Keys_Control *)
4001866c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40018670: 13 10 00 d2 sethi %hi(0x40034800), %o1
<== NOT EXECUTED
40018674: 40 00 0a 59 call 4001afd8 <_Objects_Get_no_protection>
<== NOT EXECUTED
40018678: 92 12 61 c0 or %o1, 0x1c0, %o1 ! 400349c0 <_POSIX_Keys_Information>
<== NOT EXECUTED
if ( the_key != NULL ) {
4001867c: b4 92 20 00 orcc %o0, 0, %i2
<== NOT EXECUTED
40018680: 02 80 00 31 be 40018744 <pthread_setspecific+0x144>
<== NOT EXECUTED
40018684: 01 00 00 00 nop
<== NOT EXECUTED
key_value_pair = _POSIX_Keys_Key_value_allocate();
40018688: 7f ff ff ce call 400185c0 <_POSIX_Keys_Key_value_allocate>
<== NOT EXECUTED
4001868c: b0 10 20 0c mov 0xc, %i0 ! c <_TLS_Alignment+0xb>
<== NOT EXECUTED
if ( key_value_pair != NULL ) {
40018690: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40018694: 02 80 00 2c be 40018744 <pthread_setspecific+0x144>
<== NOT EXECUTED
40018698: 88 10 00 08 mov %o0, %g4
<== NOT EXECUTED
old_last = tail->previous;
4001869c: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
<== NOT EXECUTED
return &the_chain->Tail.Node;
400186a0: 84 06 a0 18 add %i2, 0x18, %g2
<== NOT EXECUTED
key_value_pair->key = key;
400186a4: fa 22 20 18 st %i5, [ %o0 + 0x18 ]
<== NOT EXECUTED
_RBTree_Initialize_node( &key_value_pair->Lookup_node );
400186a8: b0 02 20 08 add %o0, 8, %i0
<== NOT EXECUTED
key_value_pair->thread = executing;
400186ac: f8 22 20 1c st %i4, [ %o0 + 0x1c ]
<== NOT EXECUTED
key_value_pair->value = RTEMS_DECONST( void *, value );
400186b0: f2 22 20 20 st %i1, [ %o0 + 0x20 ]
<== NOT EXECUTED
the_node->next = tail;
400186b4: c4 22 00 00 st %g2, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
400186b8: d0 26 a0 1c st %o0, [ %i2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
400186bc: d0 20 40 00 st %o0, [ %g1 ]
<== NOT EXECUTED
the_node->previous = old_last;
400186c0: c2 22 20 04 st %g1, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400186c4: 91 d0 20 09 ta 9
<== NOT EXECUTED
parent = NULL;
400186c8: b8 10 20 00 clr %i4
<== NOT EXECUTED
link = _RBTree_Root_reference( the_rbtree );
400186cc: 86 10 00 1b mov %i3, %g3
<== NOT EXECUTED
while ( *link != NULL ) {
400186d0: c4 00 c0 00 ld [ %g3 ], %g2
<== NOT EXECUTED
400186d4: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
400186d8: 22 80 00 41 be,a 400187dc <pthread_setspecific+0x1dc>
<== NOT EXECUTED
400186dc: f8 21 20 10 st %i4, [ %g4 + 0x10 ]
<== NOT EXECUTED
if ( ( *less )( key, parent ) ) {
400186e0: f8 00 a0 10 ld [ %g2 + 0x10 ], %i4
<== NOT EXECUTED
400186e4: 80 a7 40 1c cmp %i5, %i4
<== NOT EXECUTED
400186e8: 1a 80 00 03 bcc 400186f4 <pthread_setspecific+0xf4>
<== NOT EXECUTED
400186ec: 86 00 a0 04 add %g2, 4, %g3
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
400186f0: 86 10 00 02 mov %g2, %g3
<== NOT EXECUTED
link = _RBTree_Root_const_reference( the_rbtree );
400186f4: 10 bf ff f7 b 400186d0 <pthread_setspecific+0xd0>
<== NOT EXECUTED
400186f8: b8 10 00 02 mov %g2, %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400186fc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018700: 01 00 00 00 nop
<== NOT EXECUTED
} else {
eno = _POSIX_Keys_Delete_value( key, executing );
}
return eno;
}
40018704: 81 c7 e0 08 ret
<== NOT EXECUTED
40018708: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
_RBTree_Extract(
4001870c: 40 00 0a e4 call 4001b29c <_RBTree_Extract>
<== NOT EXECUTED
40018710: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40018714: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018718: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001871c: 01 00 00 00 nop
<== NOT EXECUTED
next = the_node->next;
40018720: c4 07 00 00 ld [ %i4 ], %g2
<== NOT EXECUTED
previous = the_node->previous;
40018724: c2 07 20 04 ld [ %i4 + 4 ], %g1
<== NOT EXECUTED
next->previous = previous;
40018728: c2 20 a0 04 st %g1, [ %g2 + 4 ]
<== NOT EXECUTED
_Freechain_Put( &_POSIX_Keys_Keypool, key_value_pair );
4001872c: 11 10 00 d2 sethi %hi(0x40034800), %o0
<== NOT EXECUTED
previous->next = next;
40018730: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
40018734: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
eno = 0;
40018738: b0 10 20 00 clr %i0
<== NOT EXECUTED
4001873c: 40 00 01 96 call 40018d94 <_Freechain_Put>
<== NOT EXECUTED
40018740: 90 12 21 fc or %o0, 0x1fc, %o0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
40018744: 40 00 01 38 call 40018c24 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40018748: 01 00 00 00 nop
<== NOT EXECUTED
return eno;
4001874c: 81 c7 e0 08 ret
<== NOT EXECUTED
40018750: 81 e8 00 00 restore
<== NOT EXECUTED
_RTEMS_Lock_allocator();
40018754: 40 00 01 2f call 40018c10 <_RTEMS_Lock_allocator>
<== NOT EXECUTED
40018758: 01 00 00 00 nop
<== NOT EXECUTED
return (POSIX_Keys_Control *)
4001875c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40018760: 13 10 00 d2 sethi %hi(0x40034800), %o1
<== NOT EXECUTED
eno = EINVAL;
40018764: b0 10 20 16 mov 0x16, %i0
<== NOT EXECUTED
40018768: 40 00 0a 1c call 4001afd8 <_Objects_Get_no_protection>
<== NOT EXECUTED
4001876c: 92 12 61 c0 or %o1, 0x1c0, %o1
<== NOT EXECUTED
if ( the_key != NULL ) {
40018770: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40018774: 02 bf ff f4 be 40018744 <pthread_setspecific+0x144>
<== NOT EXECUTED
40018778: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001877c: 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(
40018780: 90 07 21 60 add %i4, 0x160, %o0
<== NOT EXECUTED
40018784: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
while ( *link != NULL ) {
40018788: d2 00 80 00 ld [ %g2 ], %o1
<== NOT EXECUTED
4001878c: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
40018790: 02 80 00 0d be 400187c4 <pthread_setspecific+0x1c4>
<== NOT EXECUTED
40018794: b8 02 7f f8 add %o1, -8, %i4
<== NOT EXECUTED
return *the_left == the_right->key;
40018798: c4 07 20 18 ld [ %i4 + 0x18 ], %g2
<== NOT EXECUTED
if ( ( *equal )( key, parent ) ) {
4001879c: 80 a7 40 02 cmp %i5, %g2
<== NOT EXECUTED
400187a0: 02 bf ff db be 4001870c <pthread_setspecific+0x10c>
<== NOT EXECUTED
400187a4: 01 00 00 00 nop
<== NOT EXECUTED
} else if ( ( *less )( key, parent ) ) {
400187a8: 1a bf ff f8 bcc 40018788 <pthread_setspecific+0x188>
<== NOT EXECUTED
400187ac: 84 02 60 04 add %o1, 4, %g2
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
400187b0: 84 10 00 09 mov %o1, %g2
<== NOT EXECUTED
while ( *link != NULL ) {
400187b4: d2 00 80 00 ld [ %g2 ], %o1
<== NOT EXECUTED
400187b8: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
400187bc: 12 bf ff f7 bne 40018798 <pthread_setspecific+0x198>
<== NOT EXECUTED
400187c0: b8 02 7f f8 add %o1, -8, %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400187c4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400187c8: 01 00 00 00 nop
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
400187cc: 40 00 01 16 call 40018c24 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
400187d0: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
return eno;
400187d4: 81 c7 e0 08 ret
<== NOT EXECUTED
400187d8: 81 e8 00 00 restore
<== NOT EXECUTED
RB_SET( child, parent, Node );
400187dc: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
400187e0: c0 21 20 0c clr [ %g4 + 0xc ]
<== NOT EXECUTED
_RBTree_Insert_color( the_rbtree, the_node );
400187e4: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
RB_SET( child, parent, Node );
400187e8: c0 21 20 08 clr [ %g4 + 8 ]
<== NOT EXECUTED
_RBTree_Insert_color( the_rbtree, the_node );
400187ec: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
RB_SET( child, parent, Node );
400187f0: c4 21 20 14 st %g2, [ %g4 + 0x14 ]
<== NOT EXECUTED
*link = child;
400187f4: f0 20 c0 00 st %i0, [ %g3 ]
<== NOT EXECUTED
_RBTree_Insert_color( the_rbtree, the_node );
400187f8: 40 00 0c 0b call 4001b824 <_RBTree_Insert_color>
<== NOT EXECUTED
400187fc: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40018800: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018804: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018808: 01 00 00 00 nop
<== NOT EXECUTED
eno = 0;
4001880c: 10 bf ff ce b 40018744 <pthread_setspecific+0x144>
<== NOT EXECUTED
40018810: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
400589a8 <pthread_sigmask>:
int pthread_sigmask(
int how,
const sigset_t *__restrict set,
sigset_t *__restrict oset
)
{
400589a8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
POSIX_API_Control *api;
if ( !set && !oset )
400589ac: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
400589b0: 12 80 00 04 bne 400589c0 <pthread_sigmask+0x18>
<== NOT EXECUTED
400589b4: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
400589b8: 02 80 00 12 be 40058a00 <pthread_sigmask+0x58>
<== NOT EXECUTED
400589bc: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Get_executing()->API_Extensions[ THREAD_API_POSIX ];
400589c0: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1
<== NOT EXECUTED
if ( oset )
400589c4: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
400589c8: 02 80 00 05 be 400589dc <pthread_sigmask+0x34>
<== NOT EXECUTED
400589cc: c2 00 61 5c ld [ %g1 + 0x15c ], %g1
<== NOT EXECUTED
*oset = ~api->signals_unblocked;
400589d0: c4 00 60 68 ld [ %g1 + 0x68 ], %g2
<== NOT EXECUTED
400589d4: 84 38 00 02 xnor %g0, %g2, %g2
<== NOT EXECUTED
400589d8: c4 26 80 00 st %g2, [ %i2 ]
<== NOT EXECUTED
if ( !set )
400589dc: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
400589e0: 02 80 00 1b be 40058a4c <pthread_sigmask+0xa4>
<== NOT EXECUTED
400589e4: 80 a6 20 01 cmp %i0, 1
<== NOT EXECUTED
return 0;
switch ( how ) {
400589e8: 02 80 00 1e be 40058a60 <pthread_sigmask+0xb8>
<== NOT EXECUTED
400589ec: 80 a6 20 02 cmp %i0, 2
<== NOT EXECUTED
400589f0: 02 80 00 0a be 40058a18 <pthread_sigmask+0x70>
<== NOT EXECUTED
400589f4: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
400589f8: 22 80 00 17 be,a 40058a54 <pthread_sigmask+0xac>
<== NOT EXECUTED
400589fc: c4 06 40 00 ld [ %i1 ], %g2
<== NOT EXECUTED
break;
case SIG_SETMASK:
api->signals_unblocked = ~*set;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
40058a00: 40 00 0f c5 call 4005c914 <__errno>
<== NOT EXECUTED
40058a04: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40058a08: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40058a0c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40058a10: 81 c7 e0 08 ret
<== NOT EXECUTED
40058a14: 81 e8 00 00 restore
<== NOT EXECUTED
api->signals_unblocked |= *set;
40058a18: c4 00 60 68 ld [ %g1 + 0x68 ], %g2
<== NOT EXECUTED
40058a1c: c6 06 40 00 ld [ %i1 ], %g3
<== NOT EXECUTED
40058a20: 84 10 80 03 or %g2, %g3, %g2
<== NOT EXECUTED
40058a24: c4 20 60 68 st %g2, [ %g1 + 0x68 ]
<== NOT EXECUTED
/* XXX are there critical section problems here? */
/* XXX evaluate the new set */
if ( api->signals_unblocked &
(api->signals_pending | _POSIX_signals_Pending) ) {
40058a28: 07 10 02 45 sethi %hi(0x40091400), %g3
<== NOT EXECUTED
40058a2c: c2 00 60 6c ld [ %g1 + 0x6c ], %g1
<== NOT EXECUTED
40058a30: c6 00 e2 b4 ld [ %g3 + 0x2b4 ], %g3
<== NOT EXECUTED
40058a34: 82 10 40 03 or %g1, %g3, %g1
<== NOT EXECUTED
if ( api->signals_unblocked &
40058a38: 80 88 40 02 btst %g1, %g2
<== NOT EXECUTED
40058a3c: 02 80 00 04 be 40058a4c <pthread_sigmask+0xa4>
<== NOT EXECUTED
40058a40: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Dispatch();
40058a44: 7f ff 14 67 call 4001dbe0 <_Thread_Dispatch>
<== NOT EXECUTED
40058a48: 01 00 00 00 nop
<== NOT EXECUTED
}
return 0;
}
40058a4c: 81 c7 e0 08 ret
<== NOT EXECUTED
40058a50: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
api->signals_unblocked = ~*set;
40058a54: 84 38 00 02 xnor %g0, %g2, %g2
<== NOT EXECUTED
break;
40058a58: 10 bf ff f4 b 40058a28 <pthread_sigmask+0x80>
<== NOT EXECUTED
40058a5c: c4 20 60 68 st %g2, [ %g1 + 0x68 ]
<== NOT EXECUTED
api->signals_unblocked &= ~*set;
40058a60: c6 00 60 68 ld [ %g1 + 0x68 ], %g3
<== NOT EXECUTED
40058a64: c4 06 40 00 ld [ %i1 ], %g2
<== NOT EXECUTED
40058a68: 84 28 c0 02 andn %g3, %g2, %g2
<== NOT EXECUTED
break;
40058a6c: 10 bf ff ef b 40058a28 <pthread_sigmask+0x80>
<== NOT EXECUTED
40058a70: c4 20 60 68 st %g2, [ %g1 + 0x68 ]
<== NOT EXECUTED
40043b0c <sigaddset>:
int sigaddset(
sigset_t *set,
int signo
)
{
40043b0c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( !set )
40043b10: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
40043b14: 02 80 00 0d be 40043b48 <sigaddset+0x3c>
<== NOT EXECUTED
40043b18: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
40043b1c: 02 80 00 0b be 40043b48 <sigaddset+0x3c>
<== NOT EXECUTED
40043b20: b2 06 7f ff add %i1, -1, %i1
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(signo) )
40043b24: 80 a6 60 1f cmp %i1, 0x1f
<== NOT EXECUTED
40043b28: 18 80 00 08 bgu 40043b48 <sigaddset+0x3c>
<== NOT EXECUTED
40043b2c: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
*set |= signo_to_mask(signo);
40043b30: c2 06 00 00 ld [ %i0 ], %g1
<== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
40043b34: b3 28 80 19 sll %g2, %i1, %i1
<== NOT EXECUTED
40043b38: b2 10 40 19 or %g1, %i1, %i1
<== NOT EXECUTED
40043b3c: f2 26 00 00 st %i1, [ %i0 ]
<== NOT EXECUTED
return 0;
}
40043b40: 81 c7 e0 08 ret
<== NOT EXECUTED
40043b44: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
40043b48: 40 00 63 73 call 4005c914 <__errno>
<== NOT EXECUTED
40043b4c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40043b50: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40043b54: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40043b58: 81 c7 e0 08 ret
<== NOT EXECUTED
40043b5c: 81 e8 00 00 restore
<== NOT EXECUTED
4002cf1c <sigemptyset>:
#include <rtems/seterr.h>
int sigemptyset(
sigset_t *set
)
{
4002cf1c: 9d e3 bf a0 save %sp, -96, %sp
if ( !set )
4002cf20: 80 a6 20 00 cmp %i0, 0
4002cf24: 02 80 00 05 be 4002cf38 <sigemptyset+0x1c>
<== NEVER TAKEN
4002cf28: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
*set = 0;
4002cf2c: c0 26 00 00 clr [ %i0 ]
return 0;
}
4002cf30: 81 c7 e0 08 ret
4002cf34: 91 e8 20 00 restore %g0, 0, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
4002cf38: 7f ff bb 72 call 4001bd00 <__errno>
<== NOT EXECUTED
4002cf3c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4002cf40: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4002cf44: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4002cf48: 81 c7 e0 08 ret
<== NOT EXECUTED
4002cf4c: 81 e8 00 00 restore
<== NOT EXECUTED
40043b94 <sigprocmask>:
/*
* P1003.1c/Draft 10, p. 38 maps sigprocmask to pthread_sigmask.
*/
#if defined(RTEMS_POSIX_API)
return pthread_sigmask( how, set, oset );
40043b94: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40043b98: 40 00 53 84 call 400589a8 <pthread_sigmask>
<== NOT EXECUTED
40043b9c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED