RTEMS-5
Annotated Report
Fri Aug 10 14:04:53 2018
4001f8c8 <_POSIX_Condition_variables_Auto_initialization>:
#include <string.h>
bool _POSIX_Condition_variables_Auto_initialization(
POSIX_Condition_variables_Control *the_cond
)
{
4001f8c8: 9d e3 bf 80 save %sp, -128, %sp
<== NOT EXECUTED
POSIX_Condition_variables_Control zero;
unsigned long flags;
memset( &zero, 0, sizeof( zero ) );
if ( memcmp( the_cond, &zero, sizeof( *the_cond ) ) != 0 ) {
4001f8cc: 94 10 20 1c mov 0x1c, %o2
<== NOT EXECUTED
memset( &zero, 0, sizeof( zero ) );
4001f8d0: c0 27 bf e4 clr [ %fp + -28 ]
<== NOT EXECUTED
if ( memcmp( the_cond, &zero, sizeof( *the_cond ) ) != 0 ) {
4001f8d4: 92 07 bf e4 add %fp, -28, %o1
<== NOT EXECUTED
memset( &zero, 0, sizeof( zero ) );
4001f8d8: c0 27 bf e8 clr [ %fp + -24 ]
<== NOT EXECUTED
if ( memcmp( the_cond, &zero, sizeof( *the_cond ) ) != 0 ) {
4001f8dc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
memset( &zero, 0, sizeof( zero ) );
4001f8e0: c0 27 bf ec clr [ %fp + -20 ]
<== NOT EXECUTED
4001f8e4: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
4001f8e8: c0 27 bf f4 clr [ %fp + -12 ]
<== NOT EXECUTED
4001f8ec: c0 27 bf f8 clr [ %fp + -8 ]
<== NOT EXECUTED
if ( memcmp( the_cond, &zero, sizeof( *the_cond ) ) != 0 ) {
4001f8f0: 40 00 97 14 call 40045540 <memcmp>
<== NOT EXECUTED
4001f8f4: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
4001f8f8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f8fc: 12 80 00 08 bne 4001f91c <_POSIX_Condition_variables_Auto_initialization+0x54>
<== NOT EXECUTED
4001f900: 82 10 20 00 clr %g1
<== NOT EXECUTED
return false;
}
flags = (uintptr_t) the_cond ^ POSIX_CONDITION_VARIABLES_MAGIC;
4001f904: 03 06 37 ec sethi %hi(0x18dfb000), %g1
<== NOT EXECUTED
4001f908: 82 10 61 fe or %g1, 0x1fe, %g1 ! 18dfb1fe <RAM_SIZE+0x189fb1fe>
<== NOT EXECUTED
4001f90c: 82 1e 00 01 xor %i0, %g1, %g1
<== NOT EXECUTED
flags &= ~POSIX_CONDITION_VARIABLES_FLAGS_MASK;
4001f910: 82 08 7f fe and %g1, -2, %g1
<== NOT EXECUTED
the_cond->flags = flags;
4001f914: c2 26 00 00 st %g1, [ %i0 ]
<== NOT EXECUTED
return true;
4001f918: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
}
4001f91c: b0 08 60 01 and %g1, 1, %i0
<== NOT EXECUTED
4001f920: 81 c7 e0 08 ret
<== NOT EXECUTED
4001f924: 81 e8 00 00 restore
<== NOT EXECUTED
40066040 <_POSIX_Condition_variables_Default_attributes>:
40066040: 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 01 ................
...
4001f818 <_POSIX_Condition_variables_Signal_support>:
int _POSIX_Condition_variables_Signal_support(
pthread_cond_t *cond,
bool is_broadcast
)
{
4001f818: 9d e3 bf 78 save %sp, -136, %sp
unsigned long flags;
const Thread_queue_Operations *operations;
Thread_queue_Heads *heads;
the_cond = _POSIX_Condition_variables_Get( cond );
POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
4001f81c: 80 a6 20 00 cmp %i0, 0
4001f820: 02 80 00 28 be 4001f8c0 <_POSIX_Condition_variables_Signal_support+0xa8>
<== NEVER TAKEN
4001f824: 05 06 37 ec sethi %hi(0x18dfb000), %g2
4001f828: c2 06 00 00 ld [ %i0 ], %g1
4001f82c: 82 1e 00 01 xor %i0, %g1, %g1
4001f830: 84 10 a1 fe or %g2, 0x1fe, %g2
4001f834: 82 18 40 02 xor %g1, %g2, %g1
4001f838: 80 88 7f fe btst -2, %g1
4001f83c: 12 80 00 1c bne 4001f8ac <_POSIX_Condition_variables_Signal_support+0x94>
<== NEVER TAKEN
4001f840: 3b 10 01 91 sethi %hi(0x40064400), %i5
<== NOT EXECUTED
if ( heads != NULL ) {
Thread_Control *the_thread;
the_thread = ( *operations->first )( heads );
_Thread_queue_Extract_critical(
4001f844: b8 06 20 0c add %i0, 0xc, %i4
<== NOT EXECUTED
the_thread = ( *operations->first )( heads );
4001f848: ba 17 63 2c or %i5, 0x32c, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001f84c: 91 d0 20 09 ta 9
<== NOT EXECUTED
)
{
#if defined( RTEMS_SMP )
context->Lock_context.isr_level = level;
#else
context->isr_level = level;
4001f850: c2 27 bf dc st %g1, [ %fp + -36 ]
heads = the_cond->Queue.Queue.heads;
4001f854: c2 06 20 0c ld [ %i0 + 0xc ], %g1
if ( heads != NULL ) {
4001f858: 90 90 60 00 orcc %g1, 0, %o0
4001f85c: 22 80 00 0f be,a 4001f898 <_POSIX_Condition_variables_Signal_support+0x80>
4001f860: c0 26 20 18 clr [ %i0 + 0x18 ]
the_thread = ( *operations->first )( heads );
4001f864: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4001f868: 9f c0 40 00 call %g1
4001f86c: 01 00 00 00 nop
_Thread_queue_Extract_critical(
4001f870: 96 07 bf dc add %fp, -36, %o3
4001f874: 94 10 00 08 mov %o0, %o2
4001f878: 92 10 00 1d mov %i5, %o1
4001f87c: 40 00 18 bf call 40025b78 <_Thread_queue_Extract_critical>
4001f880: 90 10 00 1c mov %i4, %o0
);
} else {
the_cond->mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_POSIX_Condition_variables_Release( the_cond, &queue_context );
}
} while ( is_broadcast && heads != NULL );
4001f884: 80 a6 60 00 cmp %i1, 0
4001f888: 12 bf ff f1 bne 4001f84c <_POSIX_Condition_variables_Signal_support+0x34>
4001f88c: 01 00 00 00 nop
return 0;
}
4001f890: 81 c7 e0 08 ret
4001f894: 91 e8 20 00 restore %g0, 0, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4001f898: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001f89c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001f8a0: 01 00 00 00 nop
4001f8a4: 81 c7 e0 08 ret
4001f8a8: 91 e8 20 00 restore %g0, 0, %o0
POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
4001f8ac: 40 00 00 07 call 4001f8c8 <_POSIX_Condition_variables_Auto_initialization>
<== NOT EXECUTED
4001f8b0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001f8b4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f8b8: 12 bf ff e3 bne 4001f844 <_POSIX_Condition_variables_Signal_support+0x2c>
<== NOT EXECUTED
4001f8bc: 3b 10 01 91 sethi %hi(0x40064400), %i5
<== NOT EXECUTED
4001f8c0: 81 c7 e0 08 ret
<== NOT EXECUTED
4001f8c4: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
4001f9b0 <_POSIX_Condition_variables_Wait_support>:
int _POSIX_Condition_variables_Wait_support(
pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
4001f9b0: 9d e3 bf 78 save %sp, -136, %sp
Thread_queue_Context queue_context;
int error;
Thread_Control *executing;
the_cond = _POSIX_Condition_variables_Get( cond );
POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
4001f9b4: 80 a6 20 00 cmp %i0, 0
4001f9b8: 02 80 00 44 be 4001fac8 <_POSIX_Condition_variables_Wait_support+0x118>
<== NEVER TAKEN
4001f9bc: 05 06 37 ec sethi %hi(0x18dfb000), %g2
4001f9c0: fa 06 00 00 ld [ %i0 ], %i5
4001f9c4: 82 1e 00 1d xor %i0, %i5, %g1
4001f9c8: 84 10 a1 fe or %g2, 0x1fe, %g2
4001f9cc: 82 18 40 02 xor %g1, %g2, %g1
4001f9d0: 80 88 7f fe btst -2, %g1
4001f9d4: 12 80 00 38 bne 4001fab4 <_POSIX_Condition_variables_Wait_support+0x104>
<== NEVER TAKEN
4001f9d8: 80 a6 a0 00 cmp %i2, 0
_Thread_queue_Context_initialize( &queue_context );
if ( abstime != NULL ) {
4001f9dc: 02 80 00 3d be 4001fad0 <_POSIX_Condition_variables_Wait_support+0x120>
<== ALWAYS TAKEN
4001f9e0: 80 8f 60 01 btst 1, %i5
RTEMS_INLINE_ROUTINE clockid_t _POSIX_Condition_variables_Get_clock(
unsigned long flags
)
{
if ( ( flags & POSIX_CONDITION_VARIABLES_CLOCK_MONOTONIC ) != 0 ) {
4001f9e4: 12 80 00 13 bne 4001fa30 <_POSIX_Condition_variables_Wait_support+0x80>
<== NOT EXECUTED
4001f9e8: f4 27 bf e8 st %i2, [ %fp + -24 ]
<== NOT EXECUTED
queue_context->enqueue_callout = enqueue_callout;
4001f9ec: 03 10 00 7e sethi %hi(0x4001f800), %g1
<== NOT EXECUTED
4001f9f0: 82 10 61 70 or %g1, 0x170, %g1 ! 4001f970 <_POSIX_Condition_variables_Enqueue_with_timeout_realtime>
<== NOT EXECUTED
4001f9f4: c2 27 bf e4 st %g1, [ %fp + -28 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001f9f8: 91 d0 20 09 ta 9
<== NOT EXECUTED
4001f9fc: c2 27 bf dc st %g1, [ %fp + -36 ]
}
executing = _POSIX_Condition_variables_Acquire( the_cond, &queue_context );
if (
the_cond->mutex != POSIX_CONDITION_VARIABLES_NO_MUTEX
4001fa00: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
&& the_cond->mutex != mutex
4001fa04: 80 a0 40 19 cmp %g1, %i1
4001fa08: 02 80 00 13 be 4001fa54 <_POSIX_Condition_variables_Wait_support+0xa4>
4001fa0c: 84 10 00 06 mov %g6, %g2
4001fa10: 80 a0 60 00 cmp %g1, 0
4001fa14: 22 80 00 11 be,a 4001fa58 <_POSIX_Condition_variables_Wait_support+0xa8>
<== ALWAYS TAKEN
4001fa18: fa 00 a0 20 ld [ %g2 + 0x20 ], %i5
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4001fa1c: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001fa20: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001fa24: 01 00 00 00 nop
<== NOT EXECUTED
) {
_POSIX_Condition_variables_Release( the_cond, &queue_context );
return EINVAL;
4001fa28: 81 c7 e0 08 ret
<== NOT EXECUTED
4001fa2c: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
4001fa30: 03 10 00 7e sethi %hi(0x4001f800), %g1
<== NOT EXECUTED
4001fa34: 82 10 61 90 or %g1, 0x190, %g1 ! 4001f990 <_POSIX_Condition_variables_Enqueue_with_timeout_monotonic>
<== NOT EXECUTED
4001fa38: c2 27 bf e4 st %g1, [ %fp + -28 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001fa3c: 91 d0 20 09 ta 9
<== NOT EXECUTED
4001fa40: c2 27 bf dc st %g1, [ %fp + -36 ]
<== NOT EXECUTED
the_cond->mutex != POSIX_CONDITION_VARIABLES_NO_MUTEX
4001fa44: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
&& the_cond->mutex != mutex
4001fa48: 80 a0 40 19 cmp %g1, %i1
<== NOT EXECUTED
4001fa4c: 12 bf ff f1 bne 4001fa10 <_POSIX_Condition_variables_Wait_support+0x60>
<== NOT EXECUTED
4001fa50: 84 10 00 06 mov %g6, %g2
<== NOT EXECUTED
ISR_Level level;
Thread_Control *executing;
_Thread_queue_Context_ISR_disable( queue_context, level );
_Thread_queue_Context_set_ISR_level( queue_context, level );
executing = _Thread_Executing;
4001fa54: fa 00 a0 20 ld [ %g2 + 0x20 ], %i5
}
the_cond->mutex = mutex;
4001fa58: f2 26 20 18 st %i1, [ %i0 + 0x18 ]
queue_context->thread_state = thread_state;
4001fa5c: 82 10 20 20 mov 0x20, %g1
_Thread_queue_Context_set_thread_state(
&queue_context,
STATES_WAITING_FOR_CONDITION_VARIABLE
);
_Thread_queue_Enqueue(
4001fa60: 90 06 20 0c add %i0, 0xc, %o0
4001fa64: 96 07 bf dc add %fp, -36, %o3
4001fa68: c2 27 bf e0 st %g1, [ %fp + -32 ]
4001fa6c: 94 10 00 1d mov %i5, %o2
4001fa70: 13 10 01 91 sethi %hi(0x40064400), %o1
4001fa74: 40 00 17 cb call 400259a0 <_Thread_queue_Enqueue>
4001fa78: 92 12 63 2c or %o1, 0x32c, %o1 ! 4006472c <_Thread_queue_Operations_FIFO>
return _POSIX_Get_by_name_error_table[ error ];
}
RTEMS_INLINE_ROUTINE int _POSIX_Get_error( Status_Control status )
{
return STATUS_GET_POSIX( status );
4001fa7c: f0 07 60 4c ld [ %i5 + 0x4c ], %i0
4001fa80: b1 3e 20 08 sra %i0, 8, %i0
* according to the POSIX standard. It means that pthread_cond_wait
* returns a success status, except for the fact that it was not
* woken up a pthread_cond_signal() or a pthread_cond_broadcast().
*/
if ( error == EINTR ) {
4001fa84: 80 a6 20 04 cmp %i0, 4
4001fa88: 02 80 00 18 be 4001fae8 <_POSIX_Condition_variables_Wait_support+0x138>
<== NEVER TAKEN
4001fa8c: 80 a6 20 01 cmp %i0, 1
/*
* When we get here the dispatch disable level is 0.
*/
if ( error != EPERM ) {
4001fa90: 02 80 00 14 be 4001fae0 <_POSIX_Condition_variables_Wait_support+0x130>
<== NEVER TAKEN
4001fa94: 01 00 00 00 nop
int mutex_error;
mutex_error = pthread_mutex_lock( mutex );
4001fa98: 40 00 01 13 call 4001fee4 <pthread_mutex_lock>
4001fa9c: 90 10 00 19 mov %i1, %o0
if ( mutex_error != 0 ) {
4001faa0: 80 a2 20 00 cmp %o0, 0
4001faa4: 12 80 00 09 bne 4001fac8 <_POSIX_Condition_variables_Wait_support+0x118>
<== NEVER TAKEN
4001faa8: 01 00 00 00 nop
error = EINVAL;
}
}
return error;
}
4001faac: 81 c7 e0 08 ret
4001fab0: 81 e8 00 00 restore
POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
4001fab4: 7f ff ff 85 call 4001f8c8 <_POSIX_Condition_variables_Auto_initialization>
<== NOT EXECUTED
4001fab8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001fabc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001fac0: 12 bf ff c7 bne 4001f9dc <_POSIX_Condition_variables_Wait_support+0x2c>
<== NOT EXECUTED
4001fac4: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
}
4001fac8: 81 c7 e0 08 ret
<== NOT EXECUTED
4001facc: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
queue_context->enqueue_callout = enqueue_callout;
4001fad0: 03 10 00 7e sethi %hi(0x4001f800), %g1
4001fad4: 82 10 61 64 or %g1, 0x164, %g1 ! 4001f964 <_POSIX_Condition_variables_Enqueue_no_timeout>
4001fad8: 10 bf ff c8 b 4001f9f8 <_POSIX_Condition_variables_Wait_support+0x48>
4001fadc: c2 27 bf e4 st %g1, [ %fp + -28 ]
4001fae0: 81 c7 e0 08 ret
<== NOT EXECUTED
4001fae4: 81 e8 00 00 restore
<== NOT EXECUTED
error = 0;
4001fae8: 10 bf ff ec b 4001fa98 <_POSIX_Condition_variables_Wait_support+0xe8>
<== NOT EXECUTED
4001faec: b0 10 20 00 clr %i0
<== NOT EXECUTED
40020e68 <_POSIX_Keys_Key_value_allocate>:
uint32_t max = Configuration.maximum_key_value_pairs;
40020e68: 03 10 00 da sethi %hi(0x40036800), %g1
40020e6c: c2 00 60 ac ld [ %g1 + 0xac ], %g1 ! 400368ac <Configuration+0x10>
_Objects_Maximum_per_allocation( max ) : 0;
40020e70: 80 a0 60 00 cmp %g1, 0
40020e74: 16 80 00 05 bge 40020e88 <_POSIX_Keys_Key_value_allocate+0x20>
<== ALWAYS TAKEN
40020e78: 94 10 20 00 clr %o2
40020e7c: 15 00 00 3f sethi %hi(0xfc00), %o2
<== NOT EXECUTED
40020e80: 94 12 a3 ff or %o2, 0x3ff, %o2 ! ffff <_Configuration_Interrupt_stack_size+0x7fff>
<== NOT EXECUTED
40020e84: 94 08 40 0a and %g1, %o2, %o2
<== NOT EXECUTED
return (POSIX_Keys_Key_value_pair *) _Freechain_Get(
40020e88: 13 10 00 a1 sethi %hi(0x40028400), %o1
40020e8c: 11 10 01 66 sethi %hi(0x40059800), %o0
40020e90: 96 10 20 24 mov 0x24, %o3
40020e94: 92 12 62 ac or %o1, 0x2ac, %o1
40020e98: 90 12 21 30 or %o0, 0x130, %o0
40020e9c: 82 13 c0 00 mov %o7, %g1
40020ea0: 40 00 05 e9 call 40022644 <_Freechain_Get>
40020ea4: 9e 10 40 00 mov %g1, %o7
40020194 <_POSIX_Mutex_Auto_initialization>:
#include <rtems/posix/posixapi.h>
#include <string.h>
bool _POSIX_Mutex_Auto_initialization( POSIX_Mutex_Control *the_mutex )
{
40020194: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
zero |= (unsigned long) the_mutex->Priority_ceiling.Node.RBTree.Node.rbe_right;
zero |= (unsigned long) the_mutex->Priority_ceiling.Node.RBTree.Node.rbe_parent;
zero |= (unsigned long) the_mutex->Priority_ceiling.Node.RBTree.Node.rbe_color;
zero |= (unsigned long) the_mutex->Priority_ceiling.priority;
zero |= (unsigned long) (the_mutex->Priority_ceiling.priority >> 32);
zero |= (unsigned long) the_mutex->scheduler;
40020198: f2 06 20 04 ld [ %i0 + 4 ], %i1
<== NOT EXECUTED
zero |= (unsigned long) the_mutex->Priority_ceiling.priority;
4002019c: de 06 20 30 ld [ %i0 + 0x30 ], %o7
<== NOT EXECUTED
400201a0: da 06 20 34 ld [ %i0 + 0x34 ], %o5
<== NOT EXECUTED
zero |= (unsigned long) the_mutex->scheduler;
400201a4: c4 06 00 00 ld [ %i0 ], %g2
<== NOT EXECUTED
400201a8: d4 06 20 08 ld [ %i0 + 8 ], %o2
<== NOT EXECUTED
400201ac: d6 06 20 18 ld [ %i0 + 0x18 ], %o3
<== NOT EXECUTED
400201b0: f4 06 20 0c ld [ %i0 + 0xc ], %i2
<== NOT EXECUTED
400201b4: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
<== NOT EXECUTED
400201b8: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
<== NOT EXECUTED
400201bc: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
<== NOT EXECUTED
400201c0: c8 06 20 24 ld [ %i0 + 0x24 ], %g4
<== NOT EXECUTED
400201c4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
<== NOT EXECUTED
400201c8: d8 06 20 2c ld [ %i0 + 0x2c ], %o4
<== NOT EXECUTED
400201cc: c6 06 20 38 ld [ %i0 + 0x38 ], %g3
<== NOT EXECUTED
400201d0: 84 10 80 19 or %g2, %i1, %g2
<== NOT EXECUTED
400201d4: 84 10 80 0a or %g2, %o2, %g2
<== NOT EXECUTED
400201d8: 84 10 80 0b or %g2, %o3, %g2
<== NOT EXECUTED
400201dc: 84 16 80 02 or %i2, %g2, %g2
<== NOT EXECUTED
400201e0: 84 16 c0 02 or %i3, %g2, %g2
<== NOT EXECUTED
400201e4: 84 17 00 02 or %i4, %g2, %g2
<== NOT EXECUTED
400201e8: 84 17 40 02 or %i5, %g2, %g2
<== NOT EXECUTED
400201ec: 84 11 00 02 or %g4, %g2, %g2
<== NOT EXECUTED
400201f0: 82 10 40 02 or %g1, %g2, %g1
<== NOT EXECUTED
400201f4: 82 10 40 0c or %g1, %o4, %g1
<== NOT EXECUTED
400201f8: 82 10 40 0d or %g1, %o5, %g1
<== NOT EXECUTED
400201fc: 82 10 c0 01 or %g3, %g1, %g1
<== NOT EXECUTED
if ( zero != 0 ) {
40020200: 80 90 40 0f orcc %g1, %o7, %g0
<== NOT EXECUTED
40020204: 12 80 00 08 bne 40020224 <_POSIX_Mutex_Auto_initialization+0x90>
<== NOT EXECUTED
40020208: b2 10 20 00 clr %i1
<== NOT EXECUTED
return false;
}
flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
4002020c: 03 25 87 04 sethi %hi(0x961c1000), %g1
<== NOT EXECUTED
40020210: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 <RAM_END+0x55dc13b8>
<== NOT EXECUTED
40020214: 82 1e 00 01 xor %i0, %g1, %g1
<== NOT EXECUTED
flags &= ~POSIX_MUTEX_FLAGS_MASK;
40020218: 82 08 7f f8 and %g1, -8, %g1
<== NOT EXECUTED
the_mutex->flags = flags;
4002021c: c2 26 00 00 st %g1, [ %i0 ]
<== NOT EXECUTED
return true;
40020220: b2 10 20 01 mov 1, %i1
<== NOT EXECUTED
}
40020224: b0 0e 60 01 and %i1, 1, %i0
<== NOT EXECUTED
40020228: 81 c7 e0 08 ret
<== NOT EXECUTED
4002022c: 81 e8 00 00 restore
<== NOT EXECUTED
4001ff5c <_POSIX_Mutex_Lock_support>:
int _POSIX_Mutex_Lock_support(
pthread_mutex_t *mutex,
const struct timespec *abstime,
Thread_queue_Enqueue_callout enqueue_callout
)
{
4001ff5c: 9d e3 bf 70 save %sp, -144, %sp
Thread_queue_Context queue_context;
Thread_Control *executing;
Status_Control status;
the_mutex = _POSIX_Mutex_Get( mutex );
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
4001ff60: 80 a6 20 00 cmp %i0, 0
4001ff64: 02 80 00 3f be 40020060 <_POSIX_Mutex_Lock_support+0x104>
<== NEVER TAKEN
4001ff68: 05 25 87 04 sethi %hi(0x961c1000), %g2
4001ff6c: fa 06 00 00 ld [ %i0 ], %i5
4001ff70: 82 1e 00 1d xor %i0, %i5, %g1
4001ff74: 84 10 a3 b8 or %g2, 0x3b8, %g2
4001ff78: 82 18 40 02 xor %g1, %g2, %g1
4001ff7c: 80 88 7f f8 btst -8, %g1
4001ff80: 12 80 00 33 bne 4002004c <_POSIX_Mutex_Lock_support+0xf0>
<== NEVER TAKEN
4001ff84: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001ff88: 91 d0 20 09 ta 9
<== NOT EXECUTED
4001ff8c: c2 27 bf dc st %g1, [ %fp + -36 ]
executing = _POSIX_Mutex_Acquire( the_mutex, &queue_context );
_Thread_queue_Context_set_enqueue_callout( &queue_context, enqueue_callout);
_Thread_queue_Context_set_timeout_argument( &queue_context, abstime );
switch ( _POSIX_Mutex_Get_protocol( flags ) ) {
4001ff90: 82 8f 60 03 andcc %i5, 3, %g1
queue_context->enqueue_callout = enqueue_callout;
4001ff94: f4 27 bf e4 st %i2, [ %fp + -28 ]
queue_context->Timeout.arg = arg;
4001ff98: f2 27 bf e8 st %i1, [ %fp + -24 ]
4001ff9c: 02 80 00 34 be 4002006c <_POSIX_Mutex_Lock_support+0x110>
<== ALWAYS TAKEN
4001ffa0: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
4001ffa4: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
4001ffa8: 12 80 00 10 bne 4001ffe8 <_POSIX_Mutex_Lock_support+0x8c>
<== NOT EXECUTED
4001ffac: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
<== NOT EXECUTED
{
Thread_Control *owner;
owner = _POSIX_Mutex_Get_owner( the_mutex );
if ( owner == NULL ) {
4001ffb0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001ffb4: 02 80 00 43 be 400200c0 <_POSIX_Mutex_Lock_support+0x164>
<== NOT EXECUTED
4001ffb8: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
executing,
queue_context
);
}
if ( owner == executing ) {
4001ffbc: 02 80 00 18 be 4002001c <_POSIX_Mutex_Lock_support+0xc0>
<== NOT EXECUTED
4001ffc0: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
status = _POSIX_Mutex_Lock_nested( the_mutex, flags );
_POSIX_Mutex_Release( the_mutex, queue_context );
return status;
}
return _POSIX_Mutex_Seize_slow(
4001ffc4: 98 07 bf dc add %fp, -36, %o4
<== NOT EXECUTED
4001ffc8: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
4001ffcc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001ffd0: 13 10 01 91 sethi %hi(0x40064400), %o1
<== NOT EXECUTED
4001ffd4: 7f ff ff ca call 4001fefc <_POSIX_Mutex_Seize_slow>
<== NOT EXECUTED
4001ffd8: 92 12 63 18 or %o1, 0x318, %o1 ! 40064718 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
4001ffdc: 93 3a 60 08 sra %o1, 8, %o1
<== NOT EXECUTED
);
break;
}
return _POSIX_Get_error( status );
}
4001ffe0: 81 c7 e0 08 ret
<== NOT EXECUTED
4001ffe4: 91 e8 00 09 restore %g0, %o1, %o0
<== NOT EXECUTED
if ( owner == NULL ) {
4001ffe8: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001ffec: 02 80 00 2e be 400200a4 <_POSIX_Mutex_Lock_support+0x148>
<== NOT EXECUTED
4001fff0: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
if ( owner == executing ) {
4001fff4: 02 80 00 0a be 4002001c <_POSIX_Mutex_Lock_support+0xc0>
<== NOT EXECUTED
4001fff8: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
return _POSIX_Mutex_Seize_slow(
4001fffc: 98 07 bf dc add %fp, -36, %o4
<== NOT EXECUTED
40020000: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
40020004: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40020008: 13 10 01 91 sethi %hi(0x40064400), %o1
<== NOT EXECUTED
4002000c: 7f ff ff bc call 4001fefc <_POSIX_Mutex_Seize_slow>
<== NOT EXECUTED
40020010: 92 12 63 04 or %o1, 0x304, %o1 ! 40064704 <_Thread_queue_Operations_priority_inherit>
<== NOT EXECUTED
return _POSIX_Get_error( status );
40020014: 10 80 00 0c b 40020044 <_POSIX_Mutex_Lock_support+0xe8>
<== NOT EXECUTED
40020018: 93 3a 60 08 sra %o1, 8, %o1
<== NOT EXECUTED
if ( _POSIX_Mutex_Is_recursive( flags ) ) {
4002001c: 80 8f 60 04 btst 4, %i5
<== NOT EXECUTED
40020020: 02 80 00 06 be 40020038 <_POSIX_Mutex_Lock_support+0xdc>
<== NOT EXECUTED
40020024: 92 10 20 2d mov 0x2d, %o1
<== NOT EXECUTED
++the_mutex->Recursive.nest_level;
40020028: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
4002002c: 82 00 60 01 inc %g1
<== NOT EXECUTED
40020030: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
<== NOT EXECUTED
40020034: 92 10 20 00 clr %o1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40020038: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002003c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020040: 01 00 00 00 nop
<== NOT EXECUTED
}
40020044: 81 c7 e0 08 ret
<== NOT EXECUTED
40020048: 91 e8 00 09 restore %g0, %o1, %o0
<== NOT EXECUTED
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
4002004c: 40 00 00 52 call 40020194 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
40020050: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40020054: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40020058: 12 bf ff cc bne 4001ff88 <_POSIX_Mutex_Lock_support+0x2c>
<== NOT EXECUTED
4002005c: 01 00 00 00 nop
<== NOT EXECUTED
40020060: 92 10 20 16 mov 0x16, %o1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
}
40020064: 81 c7 e0 08 ret
<== NOT EXECUTED
40020068: 91 e8 00 09 restore %g0, %o1, %o0
<== NOT EXECUTED
4002006c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
if ( owner == NULL ) {
40020070: 80 a0 60 00 cmp %g1, 0
40020074: 02 80 00 0c be 400200a4 <_POSIX_Mutex_Lock_support+0x148>
<== ALWAYS TAKEN
40020078: 80 a2 00 01 cmp %o0, %g1
if ( owner == executing ) {
4002007c: 02 bf ff e8 be 4002001c <_POSIX_Mutex_Lock_support+0xc0>
<== NOT EXECUTED
40020080: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
return _POSIX_Mutex_Seize_slow(
40020084: 98 07 bf dc add %fp, -36, %o4
<== NOT EXECUTED
40020088: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
4002008c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40020090: 13 10 01 91 sethi %hi(0x40064400), %o1
<== NOT EXECUTED
40020094: 7f ff ff 9a call 4001fefc <_POSIX_Mutex_Seize_slow>
<== NOT EXECUTED
40020098: 92 12 63 2c or %o1, 0x32c, %o1 ! 4006472c <_Thread_queue_Operations_FIFO>
<== NOT EXECUTED
4002009c: 10 bf ff ea b 40020044 <_POSIX_Mutex_Lock_support+0xe8>
<== NOT EXECUTED
400200a0: 93 3a 60 08 sra %o1, 8, %o1
<== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
400200a4: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400200a8: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400200ac: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400200b0: 01 00 00 00 nop
400200b4: 92 10 20 00 clr %o1 ! 0 <PROM_START>
400200b8: 81 c7 e0 08 ret
400200bc: 91 e8 00 09 restore %g0, %o1, %o0
if (
400200c0: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
<== NOT EXECUTED
queue_context->Priority.update_count = 0;
400200c4: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
400200c8: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
<== NOT EXECUTED
400200cc: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
<== NOT EXECUTED
400200d0: 80 a0 c0 02 cmp %g3, %g2
<== NOT EXECUTED
400200d4: 18 80 00 09 bgu 400200f8 <_POSIX_Mutex_Lock_support+0x19c>
<== NOT EXECUTED
400200d8: 01 00 00 00 nop
<== NOT EXECUTED
400200dc: 32 80 00 0c bne,a 4002010c <_POSIX_Mutex_Lock_support+0x1b0>
<== NOT EXECUTED
400200e0: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
<== NOT EXECUTED
400200e4: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
<== NOT EXECUTED
400200e8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
400200ec: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
400200f0: 28 80 00 07 bleu,a 4002010c <_POSIX_Mutex_Lock_support+0x1b0>
<== NOT EXECUTED
400200f4: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400200f8: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400200fc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020100: 01 00 00 00 nop
<== NOT EXECUTED
40020104: 10 bf ff d8 b 40020064 <_POSIX_Mutex_Lock_support+0x108>
<== NOT EXECUTED
40020108: 92 10 20 16 mov 0x16, %o1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
_Thread_Priority_add(
4002010c: 92 06 20 20 add %i0, 0x20, %o1
<== NOT EXECUTED
40020110: 40 00 13 e3 call 4002509c <_Thread_Priority_add>
<== NOT EXECUTED
40020114: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
const ISR_lock_Context *lock_context
)
{
uint32_t disable_level;
disable_level = cpu_self->thread_dispatch_disable_level;
40020118: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
_Profiling_Thread_dispatch_disable_critical(
cpu_self,
disable_level,
lock_context
);
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4002011c: 82 00 60 01 inc %g1
<== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Per_CPU_Control *_Thread_Dispatch_disable_critical(
const ISR_lock_Context *lock_context
)
{
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40020120: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40020124: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40020128: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002012c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020130: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( queue_context );
40020134: 40 00 13 e4 call 400250c4 <_Thread_Priority_update>
<== NOT EXECUTED
40020138: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
*
* @param[in] cpu_self The current processor.
*/
RTEMS_INLINE_ROUTINE void _Thread_Dispatch_enable( Per_CPU_Control *cpu_self )
{
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4002013c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
40020140: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
40020144: 02 80 00 05 be 40020158 <_POSIX_Mutex_Lock_support+0x1fc>
<== NOT EXECUTED
40020148: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
}
_ISR_Local_enable( level );
} else {
_Assert( disable_level > 0 );
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4002014c: 92 10 20 00 clr %o1
<== NOT EXECUTED
40020150: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
40020154: 30 bf ff bc b,a 40020044 <_POSIX_Mutex_Lock_support+0xe8>
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40020158: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4002015c: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
<== NOT EXECUTED
40020160: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40020164: 32 80 00 07 bne,a 40020180 <_POSIX_Mutex_Lock_support+0x224>
<== NOT EXECUTED
40020168: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4002016c: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40020170: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020174: 01 00 00 00 nop
<== NOT EXECUTED
40020178: 10 bf ff b3 b 40020044 <_POSIX_Mutex_Lock_support+0xe8>
<== NOT EXECUTED
4002017c: 92 10 20 00 clr %o1 ! 0 <PROM_START>
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
40020180: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
40020184: 40 00 14 2c call 40025234 <_Thread_Do_dispatch>
<== NOT EXECUTED
40020188: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4002018c: 10 bf ff f9 b 40020170 <_POSIX_Mutex_Lock_support+0x214>
<== NOT EXECUTED
40020190: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
4001fefc <_POSIX_Mutex_Seize_slow>:
const Thread_queue_Operations *operations,
Thread_Control *executing,
const struct timespec *abstime,
Thread_queue_Context *queue_context
)
{
4001fefc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( (uintptr_t) abstime != POSIX_MUTEX_ABSTIME_TRY_LOCK ) {
4001ff00: 80 a6 e0 01 cmp %i3, 1
<== NOT EXECUTED
4001ff04: 02 80 00 0f be 4001ff40 <_POSIX_Mutex_Seize_slow+0x44>
<== NOT EXECUTED
4001ff08: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
queue_context->thread_state = thread_state;
4001ff0c: c2 27 20 04 st %g1, [ %i4 + 4 ]
<== NOT EXECUTED
queue_context->deadlock_callout = deadlock_callout;
4001ff10: 03 10 00 96 sethi %hi(0x40025800), %g1
<== NOT EXECUTED
4001ff14: 82 10 61 80 or %g1, 0x180, %g1 ! 40025980 <_Thread_queue_Deadlock_status>
<== NOT EXECUTED
4001ff18: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
<== NOT EXECUTED
);
_Thread_queue_Context_set_deadlock_callout(
queue_context,
_Thread_queue_Deadlock_status
);
_Thread_queue_Enqueue(
4001ff1c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001ff20: 90 06 20 0c add %i0, 0xc, %o0
<== NOT EXECUTED
4001ff24: 96 10 00 1c mov %i4, %o3
<== NOT EXECUTED
4001ff28: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4001ff2c: 40 00 16 9d call 400259a0 <_Thread_queue_Enqueue>
<== NOT EXECUTED
4001ff30: b0 10 20 00 clr %i0
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Status_Control _Thread_Wait_get_status(
const Thread_Control *the_thread
)
{
return (Status_Control) the_thread->Wait.return_code;
4001ff34: f2 06 a0 4c ld [ %i2 + 0x4c ], %i1
<== NOT EXECUTED
return _Thread_Wait_get_status( executing );
} else {
_POSIX_Mutex_Release( the_mutex, queue_context );
return STATUS_UNAVAILABLE;
}
}
4001ff38: 81 c7 e0 08 ret
<== NOT EXECUTED
4001ff3c: 81 e8 00 00 restore
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4001ff40: c2 07 00 00 ld [ %i4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001ff44: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001ff48: 01 00 00 00 nop
<== NOT EXECUTED
4001ff4c: 33 00 00 04 sethi %hi(0x1000), %i1
<== NOT EXECUTED
4001ff50: b2 16 60 0d or %i1, 0xd, %i1 ! 100d <_Configuration_Interrupt_stack_size+0xd>
<== NOT EXECUTED
4001ff54: 81 c7 e0 08 ret
<== NOT EXECUTED
4001ff58: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
40020478 <_POSIX_Priority_To_core>:
Priority_Control _POSIX_Priority_To_core(
const Scheduler_Control *scheduler,
int posix_priority,
bool *valid
)
{
40020478: 9d e3 bf a0 save %sp, -96, %sp
Priority_Control core_posix_priority;
Priority_Control core_priority;
core_posix_priority = (Priority_Control) posix_priority;
core_priority = scheduler->maximum_priority - core_posix_priority;
4002047c: f8 1e 20 40 ldd [ %i0 + 0x40 ], %i4
core_posix_priority = (Priority_Control) posix_priority;
40020480: 83 3e 60 1f sra %i1, 0x1f, %g1
40020484: 86 10 00 19 mov %i1, %g3
40020488: 84 10 00 01 mov %g1, %g2
*valid = ( posix_priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY
&& core_posix_priority < scheduler->maximum_priority );
4002048c: 80 a7 00 01 cmp %i4, %g1
40020490: 18 80 00 05 bgu 400204a4 <_POSIX_Priority_To_core+0x2c>
<== NEVER TAKEN
40020494: 88 10 20 01 mov 1, %g4
40020498: 02 80 00 11 be 400204dc <_POSIX_Priority_To_core+0x64>
<== ALWAYS TAKEN
4002049c: 80 a7 40 19 cmp %i5, %i1
400204a0: 88 10 20 00 clr %g4
<== NOT EXECUTED
400204a4: 82 20 40 19 sub %g1, %i1, %g1
<== NOT EXECUTED
400204a8: 83 30 60 1f srl %g1, 0x1f, %g1
400204ac: 82 08 40 04 and %g1, %g4, %g1
*valid = ( posix_priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY
400204b0: c2 2e 80 00 stb %g1, [ %i2 ]
core_priority = scheduler->maximum_priority - core_posix_priority;
400204b4: b6 a7 40 03 subcc %i5, %g3, %i3
RTEMS_INLINE_ROUTINE Priority_Control _Scheduler_Map_priority(
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
return ( *scheduler->Operations.map_priority )( scheduler, priority );
400204b8: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
400204bc: b4 67 00 02 subx %i4, %g2, %i2
400204c0: 94 10 00 1b mov %i3, %o2
400204c4: 92 10 00 1a mov %i2, %o1
400204c8: 9f c0 40 00 call %g1
400204cc: 90 10 00 18 mov %i0, %o0
return _Scheduler_Map_priority( scheduler, core_priority );
}
400204d0: b0 10 00 08 mov %o0, %i0
400204d4: 81 c7 e0 08 ret
400204d8: 93 e8 00 09 restore %g0, %o1, %o1
&& core_posix_priority < scheduler->maximum_priority );
400204dc: 38 bf ff f3 bgu,a 400204a8 <_POSIX_Priority_To_core+0x30>
<== ALWAYS TAKEN
400204e0: 82 20 40 19 sub %g1, %i1, %g1
400204e4: 10 bf ff f0 b 400204a4 <_POSIX_Priority_To_core+0x2c>
<== NOT EXECUTED
400204e8: 88 10 20 00 clr %g4
<== NOT EXECUTED
4003d898 <_POSIX_Thread_Translate_sched_param>:
int policy,
const struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
4003d898: 9d e3 bf a0 save %sp, -96, %sp
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
4003d89c: c0 26 80 00 clr [ %i2 ]
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
4003d8a0: 80 a6 20 00 cmp %i0, 0
4003d8a4: 02 80 00 29 be 4003d948 <_POSIX_Thread_Translate_sched_param+0xb0>
4003d8a8: c0 26 c0 00 clr [ %i3 ]
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
4003d8ac: 80 a6 20 01 cmp %i0, 1
4003d8b0: 02 80 00 2a be 4003d958 <_POSIX_Thread_Translate_sched_param+0xc0>
<== ALWAYS TAKEN
4003d8b4: 80 a6 20 02 cmp %i0, 2
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
4003d8b8: 02 80 00 2d be 4003d96c <_POSIX_Thread_Translate_sched_param+0xd4>
<== NOT EXECUTED
4003d8bc: 80 a6 20 04 cmp %i0, 4
<== NOT EXECUTED
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
4003d8c0: 12 80 00 29 bne 4003d964 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
4003d8c4: 01 00 00 00 nop
<== NOT EXECUTED
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
4003d8c8: c4 06 60 08 ld [ %i1 + 8 ], %g2
<== NOT EXECUTED
4003d8cc: c2 06 60 0c ld [ %i1 + 0xc ], %g1
<== NOT EXECUTED
4003d8d0: 80 90 80 01 orcc %g2, %g1, %g0
<== NOT EXECUTED
4003d8d4: 32 80 00 07 bne,a 4003d8f0 <_POSIX_Thread_Translate_sched_param+0x58>
<== NOT EXECUTED
4003d8d8: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
<== NOT EXECUTED
4003d8dc: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
<== NOT EXECUTED
4003d8e0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4003d8e4: 02 80 00 20 be 4003d964 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
4003d8e8: 01 00 00 00 nop
<== NOT EXECUTED
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
4003d8ec: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
<== NOT EXECUTED
4003d8f0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
<== NOT EXECUTED
4003d8f4: 80 90 80 01 orcc %g2, %g1, %g0
<== NOT EXECUTED
4003d8f8: 12 80 00 06 bne 4003d910 <_POSIX_Thread_Translate_sched_param+0x78>
<== NOT EXECUTED
4003d8fc: 01 00 00 00 nop
<== NOT EXECUTED
4003d900: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
<== NOT EXECUTED
4003d904: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4003d908: 02 80 00 17 be 4003d964 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
4003d90c: 01 00 00 00 nop
<== NOT EXECUTED
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
4003d910: 7f ff a5 ae call 40026fc8 <_Timespec_To_ticks>
<== NOT EXECUTED
4003d914: 90 06 60 08 add %i1, 8, %o0
<== NOT EXECUTED
4003d918: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
4003d91c: 7f ff a5 ab call 40026fc8 <_Timespec_To_ticks>
<== NOT EXECUTED
4003d920: 90 06 60 18 add %i1, 0x18, %o0
<== NOT EXECUTED
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
4003d924: 80 a7 40 08 cmp %i5, %o0
<== NOT EXECUTED
4003d928: 0a 80 00 0f bcs 4003d964 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
4003d92c: 82 10 20 03 mov 3, %g1
<== NOT EXECUTED
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
4003d930: c2 26 80 00 st %g1, [ %i2 ]
<== NOT EXECUTED
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
4003d934: 03 10 00 83 sethi %hi(0x40020c00), %g1
<== NOT EXECUTED
4003d938: 82 10 60 a0 or %g1, 0xa0, %g1 ! 40020ca0 <_POSIX_Threads_Sporadic_budget_callout>
<== NOT EXECUTED
4003d93c: c2 26 c0 00 st %g1, [ %i3 ]
<== NOT EXECUTED
return 0;
}
return EINVAL;
}
4003d940: 81 c7 e0 08 ret
<== NOT EXECUTED
4003d944: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
4003d948: 82 10 20 01 mov 1, %g1
4003d94c: c2 26 80 00 st %g1, [ %i2 ]
return 0;
4003d950: 81 c7 e0 08 ret
4003d954: 81 e8 00 00 restore
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
4003d958: c0 26 80 00 clr [ %i2 ]
return 0;
4003d95c: 81 c7 e0 08 ret
4003d960: 91 e8 20 00 restore %g0, 0, %o0
return EINVAL;
4003d964: 81 c7 e0 08 ret
<== NOT EXECUTED
4003d968: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
4003d96c: f0 26 80 00 st %i0, [ %i2 ]
<== NOT EXECUTED
return 0;
4003d970: 81 c7 e0 08 ret
<== NOT EXECUTED
4003d974: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
4003d870 <_POSIX_Thread_Translate_to_sched_policy>:
#include <rtems/posix/pthreadimpl.h>
int _POSIX_Thread_Translate_to_sched_policy(
Thread_CPU_budget_algorithms budget_algorithm
)
{
4003d870: 82 02 3f ff add %o0, -1, %g1
4003d874: 80 a0 60 02 cmp %g1, 2
4003d878: 18 80 00 06 bgu 4003d890 <_POSIX_Thread_Translate_to_sched_policy+0x20>
<== ALWAYS TAKEN
4003d87c: 90 10 20 01 mov 1, %o0
4003d880: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
4003d884: 05 10 01 98 sethi %hi(0x40066000), %g2
<== NOT EXECUTED
4003d888: 84 10 a0 58 or %g2, 0x58, %g2 ! 40066058 <CSWTCH.1>
<== NOT EXECUTED
4003d88c: d0 00 80 01 ld [ %g2 + %g1 ], %o0
<== NOT EXECUTED
return SCHED_SPORADIC;
default:
_Assert( budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE );
return SCHED_FIFO;
}
}
4003d890: 81 c3 e0 08 retl
4003d894: 01 00 00 00 nop
40066068 <_POSIX_Threads_Default_attributes>:
40066068: 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 ................
40066078: 00 00 00 01 00 00 00 01 00 00 00 02 00 00 00 00 ................
...
400660b4: 00 00 00 01 00 00 00 01 00 00 00 04 40 06 60 c4 ............@.`.
400660c4: ff ff ff ff ....
40020ca0 <_POSIX_Threads_Sporadic_budget_callout>:
{
40020ca0: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
40020ca4: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
40020ca8: d2 06 21 5c ld [ %i0 + 0x15c ], %o1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40020cac: 91 d0 20 09 ta 9
<== NOT EXECUTED
40020cb0: c2 27 bf dc st %g1, [ %fp + -36 ]
<== NOT EXECUTED
the_thread->cpu_time_budget = UINT32_MAX;
40020cb4: 82 10 3f ff mov -1, %g1
<== NOT EXECUTED
40020cb8: c2 26 20 8c st %g1, [ %i0 + 0x8c ]
<== NOT EXECUTED
if ( !_Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
40020cbc: c2 02 60 34 ld [ %o1 + 0x34 ], %g1
<== NOT EXECUTED
40020cc0: 80 a0 7f ff cmp %g1, -1
<== NOT EXECUTED
40020cc4: 02 80 00 09 be 40020ce8 <_POSIX_Threads_Sporadic_budget_callout+0x48>
<== NOT EXECUTED
40020cc8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40020ccc: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40020cd0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020cd4: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( &queue_context );
40020cd8: 40 00 10 fb call 400250c4 <_Thread_Priority_update>
<== NOT EXECUTED
40020cdc: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
}
40020ce0: 81 c7 e0 08 ret
<== NOT EXECUTED
40020ce4: 81 e8 00 00 restore
<== NOT EXECUTED
_Thread_Priority_add(
40020ce8: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
40020cec: 40 00 10 ec call 4002509c <_Thread_Priority_add>
<== NOT EXECUTED
40020cf0: 92 02 60 28 add %o1, 0x28, %o1
<== NOT EXECUTED
_Thread_Priority_remove(
40020cf4: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
40020cf8: 92 06 20 20 add %i0, 0x20, %o1
<== NOT EXECUTED
40020cfc: 40 00 10 ed call 400250b0 <_Thread_Priority_remove>
<== NOT EXECUTED
40020d00: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40020d04: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40020d08: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020d0c: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( &queue_context );
40020d10: 40 00 10 ed call 400250c4 <_Thread_Priority_update>
<== NOT EXECUTED
40020d14: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
}
40020d18: 81 c7 e0 08 ret
<== NOT EXECUTED
40020d1c: 81 e8 00 00 restore
<== NOT EXECUTED
40020bec <_POSIX_Threads_Sporadic_timer>:
{
40020bec: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
40020bf0: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
api = RTEMS_CONTAINER_OF( watchdog, POSIX_API_Control, Sporadic.Timer );
40020bf4: ba 06 3f f8 add %i0, -8, %i5
<== NOT EXECUTED
the_thread = api->Sporadic.thread;
40020bf8: f8 06 3f f8 ld [ %i0 + -8 ], %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40020bfc: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
40020c00: c2 27 bf dc st %g1, [ %fp + -36 ]
<== NOT EXECUTED
if ( _Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
40020c04: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
<== NOT EXECUTED
40020c08: 80 a0 7f ff cmp %g1, -1
<== NOT EXECUTED
40020c0c: 02 80 00 0b be 40020c38 <_POSIX_Threads_Sporadic_timer+0x4c>
<== NOT EXECUTED
40020c10: 92 07 20 20 add %i4, 0x20, %o1
<== NOT EXECUTED
_Thread_Priority_add(
40020c14: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40020c18: 40 00 11 21 call 4002509c <_Thread_Priority_add>
<== NOT EXECUTED
40020c1c: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
_Thread_Priority_remove(
40020c20: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
40020c24: 92 06 20 20 add %i0, 0x20, %o1
<== NOT EXECUTED
40020c28: 40 00 11 22 call 400250b0 <_Thread_Priority_remove>
<== NOT EXECUTED
40020c2c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40020c30: 82 10 3f ff mov -1, %g1
<== NOT EXECUTED
40020c34: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
<== NOT EXECUTED
_Watchdog_Per_CPU_remove_ticks( &api->Sporadic.Timer );
40020c38: b6 07 60 08 add %i5, 8, %i3
<== NOT EXECUTED
40020c3c: 11 10 01 bf sethi %hi(0x4006fc00), %o0
<== NOT EXECUTED
40020c40: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
40020c44: 40 00 1a 11 call 40027488 <_Watchdog_Remove>
<== NOT EXECUTED
40020c48: 90 12 23 b8 or %o0, 0x3b8, %o0
<== NOT EXECUTED
_Timespec_To_ticks( &api->Sporadic.sched_ss_init_budget );
40020c4c: 40 00 18 df call 40026fc8 <_Timespec_To_ticks>
<== NOT EXECUTED
40020c50: 90 07 60 50 add %i5, 0x50, %o0
<== NOT EXECUTED
the_thread->cpu_time_budget =
40020c54: d0 27 20 8c st %o0, [ %i4 + 0x8c ]
<== NOT EXECUTED
_Watchdog_Per_CPU_insert_ticks(
40020c58: b8 10 00 06 mov %g6, %i4
<== NOT EXECUTED
40020c5c: 40 00 18 db call 40026fc8 <_Timespec_To_ticks>
<== NOT EXECUTED
40020c60: 90 07 60 40 add %i5, 0x40, %o0
<== NOT EXECUTED
expire = ticks + cpu->Watchdog.ticks;
40020c64: d4 1f 20 30 ldd [ %i4 + 0x30 ], %o2
<== NOT EXECUTED
_Watchdog_Insert(header, the_watchdog, expire);
40020c68: 86 82 c0 08 addcc %o3, %o0, %g3
<== NOT EXECUTED
40020c6c: 84 42 a0 00 addx %o2, 0, %g2
<== NOT EXECUTED
40020c70: 96 10 00 03 mov %g3, %o3
<== NOT EXECUTED
40020c74: 94 10 00 02 mov %g2, %o2
<== NOT EXECUTED
40020c78: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
40020c7c: 40 00 19 db call 400273e8 <_Watchdog_Insert>
<== NOT EXECUTED
40020c80: 90 07 20 38 add %i4, 0x38, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40020c84: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40020c88: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020c8c: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( &queue_context );
40020c90: 40 00 11 0d call 400250c4 <_Thread_Priority_update>
<== NOT EXECUTED
40020c94: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
}
40020c98: 81 c7 e0 08 ret
<== NOT EXECUTED
40020c9c: 81 e8 00 00 restore
<== NOT EXECUTED
40011750 <_POSIX_signals_Abnormal_termination_handler>:
sigset_t _POSIX_signals_Pending;
void _POSIX_signals_Abnormal_termination_handler(
int signo RTEMS_UNUSED )
{
40011750: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
exit( 1 );
40011754: 40 00 24 8d call 4001a988 <exit>
<== NOT EXECUTED
40011758: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
4001175c: 01 00 00 00 nop
<== NOT EXECUTED
40011594 <_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 ) {
40011594: 83 2a 20 01 sll %o0, 1, %g1
40011598: 05 10 00 da sethi %hi(0x40036800), %g2
4001159c: 82 00 40 08 add %g1, %o0, %g1
400115a0: 84 10 a0 14 or %g2, 0x14, %g2
400115a4: 83 28 60 02 sll %g1, 2, %g1
400115a8: c4 00 80 01 ld [ %g2 + %g1 ], %g2
400115ac: 90 02 3f ff add %o0, -1, %o0
400115b0: 80 a0 a0 02 cmp %g2, 2
400115b4: 84 10 20 01 mov 1, %g2
400115b8: 02 80 00 07 be 400115d4 <_POSIX_signals_Clear_process_signals+0x40>
<== NEVER TAKEN
400115bc: 91 28 80 08 sll %g2, %o0, %o0
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
400115c0: 03 10 00 da sethi %hi(0x40036800), %g1
400115c4: c4 00 61 a0 ld [ %g1 + 0x1a0 ], %g2 ! 400369a0 <_POSIX_signals_Pending>
400115c8: 90 28 80 08 andn %g2, %o0, %o0
}
}
400115cc: 81 c3 e0 08 retl
400115d0: d0 20 61 a0 st %o0, [ %g1 + 0x1a0 ]
return _Chain_Immutable_head( the_chain )->next;
400115d4: 05 10 00 da sethi %hi(0x40036800), %g2
<== NOT EXECUTED
400115d8: 84 10 a1 a4 or %g2, 0x1a4, %g2 ! 400369a4 <_POSIX_signals_Siginfo>
<== NOT EXECUTED
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
400115dc: c6 00 80 01 ld [ %g2 + %g1 ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
400115e0: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
400115e4: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
400115e8: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
400115ec: 02 bf ff f6 be 400115c4 <_POSIX_signals_Clear_process_signals+0x30>
<== NOT EXECUTED
400115f0: 03 10 00 da sethi %hi(0x40036800), %g1
<== NOT EXECUTED
}
400115f4: 81 c3 e0 08 retl
<== NOT EXECUTED
400115f8: 01 00 00 00 nop
<== NOT EXECUTED
400115fc <_POSIX_signals_Clear_signals>:
siginfo_t *info,
bool is_global,
bool check_blocked,
bool do_signals_acquire_release
)
{
400115fc: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
40011600: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
40011604: 86 06 7f ff add %i1, -1, %g3
<== NOT EXECUTED
*/
if ( check_blocked )
signals_unblocked = api->signals_unblocked;
else
signals_unblocked = SIGNAL_ALL_MASK;
40011608: 88 10 3f ff mov -1, %g4
<== NOT EXECUTED
if ( check_blocked )
4001160c: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
40011610: 02 80 00 03 be 4001161c <_POSIX_signals_Clear_signals+0x20>
<== NOT EXECUTED
40011614: 85 28 80 03 sll %g2, %g3, %g2
<== NOT EXECUTED
signals_unblocked = api->signals_unblocked;
40011618: 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 ) {
4001161c: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
40011620: 02 80 00 04 be 40011630 <_POSIX_signals_Clear_signals+0x34>
<== NOT EXECUTED
40011624: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40011628: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Thread_queue_Context_initialize( &queue_context );
_POSIX_signals_Acquire( &queue_context );
}
if ( is_global ) {
4001162c: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
40011630: 22 80 00 10 be,a 40011670 <_POSIX_signals_Clear_signals+0x74>
<== NOT EXECUTED
40011634: f8 06 20 6c ld [ %i0 + 0x6c ], %i4
<== NOT EXECUTED
if ( mask & (_POSIX_signals_Pending & signals_unblocked) ) {
40011638: 07 10 00 da sethi %hi(0x40036800), %g3
<== NOT EXECUTED
4001163c: c6 00 e1 a0 ld [ %g3 + 0x1a0 ], %g3 ! 400369a0 <_POSIX_signals_Pending>
<== NOT EXECUTED
40011640: 84 08 80 03 and %g2, %g3, %g2
<== NOT EXECUTED
40011644: 80 88 80 04 btst %g2, %g4
<== NOT EXECUTED
40011648: 12 80 00 12 bne 40011690 <_POSIX_signals_Clear_signals+0x94>
<== NOT EXECUTED
4001164c: 86 10 20 00 clr %g3
<== NOT EXECUTED
api->signals_pending &= ~mask;
do_callout = true;
}
}
if ( do_signals_acquire_release ) {
40011650: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
40011654: 22 80 00 05 be,a 40011668 <_POSIX_signals_Clear_signals+0x6c>
<== NOT EXECUTED
40011658: b0 08 e0 01 and %g3, 1, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001165c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40011660: 01 00 00 00 nop
<== NOT EXECUTED
_POSIX_signals_Release( &queue_context );
}
return do_callout;
}
40011664: b0 08 e0 01 and %g3, 1, %i0
<== NOT EXECUTED
40011668: 81 c7 e0 08 ret
<== NOT EXECUTED
4001166c: 81 e8 00 00 restore
<== NOT EXECUTED
if ( mask & (api->signals_pending & signals_unblocked) ) {
40011670: b6 0f 00 02 and %i4, %g2, %i3
<== NOT EXECUTED
40011674: 80 8e c0 04 btst %i3, %g4
<== NOT EXECUTED
40011678: 02 bf ff f6 be 40011650 <_POSIX_signals_Clear_signals+0x54>
<== NOT EXECUTED
4001167c: 86 10 20 00 clr %g3
<== NOT EXECUTED
api->signals_pending &= ~mask;
40011680: 84 2f 00 02 andn %i4, %g2, %g2
<== NOT EXECUTED
do_callout = true;
40011684: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
api->signals_pending &= ~mask;
40011688: 10 bf ff f2 b 40011650 <_POSIX_signals_Clear_signals+0x54>
<== NOT EXECUTED
4001168c: c4 26 20 6c st %g2, [ %i0 + 0x6c ]
<== NOT EXECUTED
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
40011690: 85 2e 60 01 sll %i1, 1, %g2
<== NOT EXECUTED
40011694: 07 10 00 da sethi %hi(0x40036800), %g3
<== NOT EXECUTED
40011698: 84 00 80 19 add %g2, %i1, %g2
<== NOT EXECUTED
4001169c: 86 10 e0 14 or %g3, 0x14, %g3
<== NOT EXECUTED
400116a0: 85 28 a0 02 sll %g2, 2, %g2
<== NOT EXECUTED
400116a4: c6 00 c0 02 ld [ %g3 + %g2 ], %g3
<== NOT EXECUTED
400116a8: 80 a0 e0 02 cmp %g3, 2
<== NOT EXECUTED
400116ac: 22 80 00 08 be,a 400116cc <_POSIX_signals_Clear_signals+0xd0>
<== NOT EXECUTED
400116b0: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
400116b4: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
_POSIX_signals_Clear_process_signals( signo );
400116b8: 7f ff ff b7 call 40011594 <_POSIX_signals_Clear_process_signals>
<== NOT EXECUTED
400116bc: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
do_callout = true;
400116c0: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
400116c4: 10 bf ff e3 b 40011650 <_POSIX_signals_Clear_signals+0x54>
<== NOT EXECUTED
400116c8: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
_Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] );
400116cc: 07 10 00 da sethi %hi(0x40036800), %g3
<== NOT EXECUTED
400116d0: 86 10 e1 a4 or %g3, 0x1a4, %g3 ! 400369a4 <_POSIX_signals_Siginfo>
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
400116d4: f8 00 80 03 ld [ %g2 + %g3 ], %i4
<== NOT EXECUTED
return &the_chain->Tail.Node;
400116d8: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
400116dc: 88 01 00 03 add %g4, %g3, %g4
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
400116e0: 80 a7 00 04 cmp %i4, %g4
<== NOT EXECUTED
400116e4: 02 80 00 17 be 40011740 <_POSIX_signals_Clear_signals+0x144>
<== NOT EXECUTED
400116e8: b6 00 80 03 add %g2, %g3, %i3
<== NOT EXECUTED
new_first = old_first->next;
400116ec: c8 07 00 00 ld [ %i4 ], %g4
<== NOT EXECUTED
head->next = new_first;
400116f0: c8 20 80 03 st %g4, [ %g2 + %g3 ]
<== NOT EXECUTED
_POSIX_signals_Clear_process_signals( signo );
400116f4: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
400116f8: 7f ff ff a7 call 40011594 <_POSIX_signals_Clear_process_signals>
<== NOT EXECUTED
400116fc: f6 21 20 04 st %i3, [ %g4 + 4 ]
<== NOT EXECUTED
*info = psiginfo->Info;
40011700: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
40011704: c4 26 80 00 st %g2, [ %i2 ]
<== NOT EXECUTED
40011708: c4 07 20 0c ld [ %i4 + 0xc ], %g2
<== NOT EXECUTED
4001170c: c4 26 a0 04 st %g2, [ %i2 + 4 ]
<== NOT EXECUTED
old_last = tail->previous;
40011710: 05 10 00 da sethi %hi(0x40036800), %g2
<== NOT EXECUTED
40011714: c6 07 20 10 ld [ %i4 + 0x10 ], %g3
<== NOT EXECUTED
40011718: c6 26 a0 08 st %g3, [ %i2 + 8 ]
<== NOT EXECUTED
4001171c: 84 10 a1 94 or %g2, 0x194, %g2
<== NOT EXECUTED
40011720: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
the_node->next = tail;
40011724: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
40011728: c8 27 00 00 st %g4, [ %i4 ]
<== NOT EXECUTED
tail->previous = the_node;
4001172c: f8 20 a0 08 st %i4, [ %g2 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
40011730: f8 20 c0 00 st %i4, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40011734: c6 27 20 04 st %g3, [ %i4 + 4 ]
<== NOT EXECUTED
40011738: 10 bf ff df b 400116b4 <_POSIX_signals_Clear_signals+0xb8>
<== NOT EXECUTED
4001173c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
_POSIX_signals_Clear_process_signals( signo );
40011740: 7f ff ff 95 call 40011594 <_POSIX_signals_Clear_process_signals>
<== NOT EXECUTED
40011744: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40011748: 10 bf ff db b 400116b4 <_POSIX_signals_Clear_signals+0xb8>
<== NOT EXECUTED
4001174c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
40031b98 <_POSIX_signals_Default_vectors>:
40031b98: 00 00 00 00 ff ff ff ff 00 00 00 01 00 00 00 00 ................
40031ba8: ff ff ff ff 40 01 17 50 00 00 00 00 ff ff ff ff ....@..P........
40031bb8: 40 01 17 50 00 00 00 00 ff ff ff ff 40 01 17 50 @..P........@..P
40031bc8: 00 00 00 00 ff ff ff ff 40 01 17 50 00 00 00 00 ........@..P....
40031bd8: ff ff ff ff 40 01 17 50 00 00 00 00 ff ff ff ff ....@..P........
40031be8: 40 01 17 50 00 00 00 00 ff ff ff ff 40 01 17 50 @..P........@..P
40031bf8: 00 00 00 00 ff ff ff ff 40 01 17 50 00 00 00 00 ........@..P....
40031c08: ff ff ff ff 40 01 17 50 00 00 00 00 ff ff ff ff ....@..P........
40031c18: 40 01 17 50 00 00 00 00 ff ff ff ff 40 01 17 50 @..P........@..P
40031c28: 00 00 00 00 ff ff ff ff 40 01 17 50 00 00 00 00 ........@..P....
40031c38: ff ff ff ff 40 01 17 50 00 00 00 00 ff ff ff ff ....@..P........
40031c48: 40 01 17 50 00 00 00 00 ff ff ff ff 40 01 17 50 @..P........@..P
40031c58: 00 00 00 00 ff ff ff ff 40 01 17 50 00 00 00 00 ........@..P....
40031c68: ff ff ff ff 40 01 17 50 00 00 00 00 ff ff ff ff ....@..P........
40031c78: 40 01 17 50 00 00 00 00 ff ff ff ff 40 01 17 50 @..P........@..P
40031c88: 00 00 00 00 ff ff ff ff 40 01 17 50 00 00 00 00 ........@..P....
40031c98: ff ff ff ff 40 01 17 50 00 00 00 00 ff ff ff ff ....@..P........
40031ca8: 40 01 17 50 00 00 00 00 ff ff ff ff 40 01 17 50 @..P........@..P
40031cb8: 00 00 00 00 ff ff ff ff 40 01 17 50 00 00 00 00 ........@..P....
40031cc8: ff ff ff ff 40 01 17 50 00 00 00 00 ff ff ff ff ....@..P........
40031cd8: 40 01 17 50 00 00 00 00 ff ff ff ff 40 01 17 50 @..P........@..P
40031ce8: 00 00 00 00 ff ff ff ff 40 01 17 50 00 00 00 00 ........@..P....
40031cf8: ff ff ff ff 40 01 17 50 00 00 00 00 ff ff ff ff ....@..P........
40031d08: 40 01 17 50 00 00 00 00 ff ff ff ff 40 01 17 50 @..P........@..P
40011148 <_POSIX_signals_Send>:
int _POSIX_signals_Send(
pid_t pid,
int sig,
const union sigval *value
)
{
40011148: 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() )
4001114c: 7f ff d9 8f call 40007788 <getpid>
<== NOT EXECUTED
40011150: 01 00 00 00 nop
<== NOT EXECUTED
40011154: 80 a2 00 18 cmp %o0, %i0
<== NOT EXECUTED
40011158: 12 80 00 e7 bne 400114f4 <_POSIX_signals_Send+0x3ac>
<== NOT EXECUTED
4001115c: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
40011160: 02 80 00 df be 400114dc <_POSIX_signals_Send+0x394>
<== NOT EXECUTED
40011164: b8 06 7f ff add %i1, -1, %i4
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
40011168: 80 a7 20 1f cmp %i4, 0x1f
<== NOT EXECUTED
4001116c: 18 80 00 dc bgu 400114dc <_POSIX_signals_Send+0x394>
<== NOT EXECUTED
40011170: 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 )
40011174: 37 10 00 da sethi %hi(0x40036800), %i3
<== NOT EXECUTED
40011178: ba 07 40 19 add %i5, %i1, %i5
<== NOT EXECUTED
4001117c: b6 16 e0 14 or %i3, 0x14, %i3
<== NOT EXECUTED
40011180: 83 2f 60 02 sll %i5, 2, %g1
<== NOT EXECUTED
40011184: 82 06 c0 01 add %i3, %g1, %g1
<== NOT EXECUTED
40011188: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
4001118c: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
40011190: 02 80 00 56 be 400112e8 <_POSIX_signals_Send+0x1a0>
<== NOT EXECUTED
40011194: 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 ) )
40011198: 82 06 7f fc add %i1, -4, %g1
<== NOT EXECUTED
4001119c: 80 88 7f fb btst -5, %g1
<== NOT EXECUTED
400111a0: 02 80 00 46 be 400112b8 <_POSIX_signals_Send+0x170>
<== NOT EXECUTED
400111a4: 80 a6 60 0b cmp %i1, 0xb
<== NOT EXECUTED
400111a8: 02 80 00 44 be 400112b8 <_POSIX_signals_Send+0x170>
<== NOT EXECUTED
400111ac: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
400111b0: f2 27 bf f4 st %i1, [ %fp + -12 ]
<== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
400111b4: b9 28 40 1c sll %g1, %i4, %i4
<== NOT EXECUTED
siginfo->si_code = SI_USER;
if ( !value ) {
400111b8: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
400111bc: 02 80 00 99 be 40011420 <_POSIX_signals_Send+0x2d8>
<== NOT EXECUTED
400111c0: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
400111c4: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
400111c8: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Per_CPU_Control *_Thread_Dispatch_disable_critical(
const ISR_lock_Context *lock_context
)
{
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
400111cc: b4 10 00 06 mov %g6, %i2
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
400111d0: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
return cpu->executing;
400111d4: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
400111d8: 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 ) ) {
400111dc: c4 02 21 5c ld [ %o0 + 0x15c ], %g2
<== NOT EXECUTED
400111e0: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
400111e4: c2 00 a0 68 ld [ %g2 + 0x68 ], %g1
<== NOT EXECUTED
400111e8: 80 8f 00 01 btst %i4, %g1
<== NOT EXECUTED
400111ec: 12 80 00 1a bne 40011254 <_POSIX_signals_Send+0x10c>
<== NOT EXECUTED
400111f0: 03 10 00 d3 sethi %hi(0x40034c00), %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;
400111f4: c4 00 63 d8 ld [ %g1 + 0x3d8 ], %g2 ! 40034fd8 <_POSIX_signals_Wait_queue>
<== NOT EXECUTED
if ( heads != NULL ) {
400111f8: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
400111fc: 02 80 00 3d be 400112f0 <_POSIX_signals_Send+0x1a8>
<== NOT EXECUTED
40011200: 17 10 00 c7 sethi %hi(0x40031c00), %o3
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40011204: c2 00 80 00 ld [ %g2 ], %g1
<== NOT EXECUTED
return &the_chain->Tail.Node;
40011208: 84 00 a0 04 add %g2, 4, %g2
<== NOT EXECUTED
Chain_Control *the_chain = &heads->Heads.Fifo;
for ( the_node = _Chain_First( the_chain );
4001120c: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40011210: 32 80 00 0d bne,a 40011244 <_POSIX_signals_Send+0xfc>
<== NOT EXECUTED
40011214: d0 00 7f f8 ld [ %g1 + -8 ], %o0
<== NOT EXECUTED
40011218: 10 80 00 37 b 400112f4 <_POSIX_signals_Send+0x1ac>
<== NOT EXECUTED
4001121c: 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)
40011220: c6 01 20 68 ld [ %g4 + 0x68 ], %g3
<== NOT EXECUTED
40011224: 80 8f 00 03 btst %i4, %g3
<== NOT EXECUTED
40011228: 12 80 00 0c bne 40011258 <_POSIX_signals_Send+0x110>
<== NOT EXECUTED
4001122c: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
the_node = the_node->next ) {
40011230: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
40011234: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40011238: 02 80 00 2e be 400112f0 <_POSIX_signals_Send+0x1a8>
<== NOT EXECUTED
4001123c: 17 10 00 c7 sethi %hi(0x40031c00), %o3
<== NOT EXECUTED
40011240: d0 00 7f f8 ld [ %g1 + -8 ], %o0
<== NOT EXECUTED
if (the_thread->Wait.option & mask)
40011244: c6 02 20 48 ld [ %o0 + 0x48 ], %g3
<== NOT EXECUTED
40011248: 80 8f 00 03 btst %i4, %g3
<== NOT EXECUTED
4001124c: 02 bf ff f5 be 40011220 <_POSIX_signals_Send+0xd8>
<== NOT EXECUTED
40011250: 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 ) ) {
40011254: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
40011258: 40 00 01 d6 call 400119b0 <_POSIX_signals_Unblock_thread>
<== NOT EXECUTED
4001125c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40011260: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40011264: 12 80 00 1b bne 400112d0 <_POSIX_signals_Send+0x188>
<== NOT EXECUTED
40011268: 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 );
4001126c: 40 00 01 66 call 40011804 <_POSIX_signals_Set_process_signals>
<== NOT EXECUTED
40011270: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40011274: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
40011278: 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 ) {
4001127c: bb 2f 60 02 sll %i5, 2, %i5
<== NOT EXECUTED
40011280: c4 06 c0 1d ld [ %i3 + %i5 ], %g2
<== NOT EXECUTED
40011284: 80 a0 a0 02 cmp %g2, 2
<== NOT EXECUTED
40011288: 02 80 00 6c be 40011438 <_POSIX_signals_Send+0x2f0>
<== NOT EXECUTED
4001128c: 09 10 00 da sethi %hi(0x40036800), %g4
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40011290: 82 10 00 03 mov %g3, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40011294: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40011298: 01 00 00 00 nop
<== NOT EXECUTED
*
* @param[in] cpu_self The current processor.
*/
RTEMS_INLINE_ROUTINE void _Thread_Dispatch_enable( Per_CPU_Control *cpu_self )
{
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4001129c: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
400112a0: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
400112a4: 02 80 00 7f be 400114a0 <_POSIX_signals_Send+0x358>
<== NOT EXECUTED
400112a8: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
}
_ISR_Local_enable( level );
} else {
_Assert( disable_level > 0 );
cpu_self->thread_dispatch_disable_level = disable_level - 1;
400112ac: 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;
}
400112b0: 81 c7 e0 08 ret
<== NOT EXECUTED
400112b4: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
return pthread_kill( pthread_self(), sig );
400112b8: 40 00 02 6f call 40011c74 <pthread_self>
<== NOT EXECUTED
400112bc: 01 00 00 00 nop
<== NOT EXECUTED
400112c0: 40 00 02 2b call 40011b6c <pthread_kill>
<== NOT EXECUTED
400112c4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400112c8: 81 c7 e0 08 ret
<== NOT EXECUTED
400112cc: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
400112d0: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
400112d4: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
400112d8: 02 80 00 72 be 400114a0 <_POSIX_signals_Send+0x358>
<== NOT EXECUTED
400112dc: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
return 0;
400112e0: b0 10 20 00 clr %i0
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
400112e4: c2 26 a0 18 st %g1, [ %i2 + 0x18 ]
<== NOT EXECUTED
400112e8: 81 c7 e0 08 ret
<== NOT EXECUTED
400112ec: 81 e8 00 00 restore
<== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
400112f0: 9e 10 3f ff mov -1, %o7
<== NOT EXECUTED
400112f4: 94 10 3f ff mov -1, %o2
<== NOT EXECUTED
400112f8: 90 10 20 00 clr %o0
<== NOT EXECUTED
400112fc: 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);
40011300: 13 04 00 00 sethi %hi(0x10000000), %o1
<== NOT EXECUTED
40011304: 96 12 e1 8c or %o3, 0x18c, %o3
<== NOT EXECUTED
if ( !_Objects_Information_table[ the_api ] )
40011308: 83 2b 20 02 sll %o4, 2, %g1
<== NOT EXECUTED
4001130c: c2 02 c0 01 ld [ %o3 + %g1 ], %g1
<== NOT EXECUTED
40011310: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40011314: 02 80 00 39 be 400113f8 <_POSIX_signals_Send+0x2b0>
<== NOT EXECUTED
40011318: 80 a3 20 03 cmp %o4, 3
<== NOT EXECUTED
the_info = _Objects_Information_table[ the_api ][ 1 ];
4001131c: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
if ( !the_info )
40011320: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40011324: 02 80 00 35 be 400113f8 <_POSIX_signals_Send+0x2b0>
<== NOT EXECUTED
40011328: 80 a3 20 03 cmp %o4, 3
<== NOT EXECUTED
maximum = the_info->maximum;
4001132c: f0 10 60 10 lduh [ %g1 + 0x10 ], %i0
<== NOT EXECUTED
for ( index = 1 ; index <= maximum ; index++ ) {
40011330: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
40011334: 02 80 00 30 be 400113f4 <_POSIX_signals_Send+0x2ac>
<== NOT EXECUTED
40011338: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
4001133c: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
40011340: b1 2e 20 02 sll %i0, 2, %i0
<== NOT EXECUTED
40011344: b0 06 00 01 add %i0, %g1, %i0
<== NOT EXECUTED
the_thread = (Thread_Control *) object_table[ index ];
40011348: c4 00 40 00 ld [ %g1 ], %g2
<== NOT EXECUTED
if ( !the_thread )
4001134c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40011350: 22 80 00 26 be,a 400113e8 <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
40011354: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
40011358: c6 00 a0 38 ld [ %g2 + 0x38 ], %g3
<== NOT EXECUTED
4001135c: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
<== NOT EXECUTED
if ( _Thread_Get_priority( the_thread ) > interested_priority )
40011360: 80 a1 00 0f cmp %g4, %o7
<== NOT EXECUTED
40011364: 18 80 00 20 bgu 400113e4 <_POSIX_signals_Send+0x29c>
<== NOT EXECUTED
40011368: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
<== NOT EXECUTED
4001136c: 02 80 00 29 be 40011410 <_POSIX_signals_Send+0x2c8>
<== NOT EXECUTED
40011370: 80 a0 c0 0a cmp %g3, %o2
<== NOT EXECUTED
if ( !_POSIX_signals_Is_interested( api, mask ) )
40011374: da 00 a1 5c ld [ %g2 + 0x15c ], %o5
<== NOT EXECUTED
40011378: da 03 60 68 ld [ %o5 + 0x68 ], %o5
<== NOT EXECUTED
4001137c: 80 8f 00 0d btst %i4, %o5
<== NOT EXECUTED
40011380: 02 80 00 19 be 400113e4 <_POSIX_signals_Send+0x29c>
<== NOT EXECUTED
40011384: 80 a3 c0 04 cmp %o7, %g4
<== NOT EXECUTED
if ( _Thread_Get_priority( the_thread ) < interested_priority ) {
40011388: 38 80 00 15 bgu,a 400113dc <_POSIX_signals_Send+0x294>
<== NOT EXECUTED
4001138c: 9e 10 00 04 mov %g4, %o7
<== NOT EXECUTED
40011390: 02 80 00 26 be 40011428 <_POSIX_signals_Send+0x2e0>
<== NOT EXECUTED
40011394: 80 a2 80 03 cmp %o2, %g3
<== NOT EXECUTED
if ( interested && !_States_Is_ready( interested->current_state ) ) {
40011398: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001139c: 22 80 00 13 be,a 400113e8 <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
400113a0: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
400113a4: da 02 20 1c ld [ %o0 + 0x1c ], %o5
<== NOT EXECUTED
400113a8: 80 a3 60 00 cmp %o5, 0
<== NOT EXECUTED
400113ac: 22 80 00 0f be,a 400113e8 <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
400113b0: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
if ( _States_Is_ready( the_thread->current_state ) ) {
400113b4: e0 00 a0 1c ld [ %g2 + 0x1c ], %l0
<== NOT EXECUTED
400113b8: 80 a4 20 00 cmp %l0, 0
<== NOT EXECUTED
400113bc: 02 80 00 07 be 400113d8 <_POSIX_signals_Send+0x290>
<== NOT EXECUTED
400113c0: 80 8b 40 09 btst %o5, %o1
<== NOT EXECUTED
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
400113c4: 32 80 00 09 bne,a 400113e8 <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
400113c8: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
400113cc: 80 8c 00 09 btst %l0, %o1
<== NOT EXECUTED
400113d0: 22 80 00 06 be,a 400113e8 <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
400113d4: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
400113d8: 9e 10 00 04 mov %g4, %o7
<== NOT EXECUTED
400113dc: 94 10 00 03 mov %g3, %o2
<== NOT EXECUTED
400113e0: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
400113e4: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
for ( index = 1 ; index <= maximum ; index++ ) {
400113e8: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
400113ec: 32 bf ff d8 bne,a 4001134c <_POSIX_signals_Send+0x204>
<== NOT EXECUTED
400113f0: c4 00 40 00 ld [ %g1 ], %g2
<== NOT EXECUTED
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
400113f4: 80 a3 20 03 cmp %o4, 3
<== NOT EXECUTED
400113f8: 12 bf ff c4 bne 40011308 <_POSIX_signals_Send+0x1c0>
<== NOT EXECUTED
400113fc: 98 10 20 03 mov 3, %o4
<== NOT EXECUTED
if ( interested ) {
40011400: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40011404: 12 bf ff 95 bne 40011258 <_POSIX_signals_Send+0x110>
<== NOT EXECUTED
40011408: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
4001140c: 30 bf ff 98 b,a 4001126c <_POSIX_signals_Send+0x124>
<== NOT EXECUTED
if ( _Thread_Get_priority( the_thread ) > interested_priority )
40011410: 28 bf ff da bleu,a 40011378 <_POSIX_signals_Send+0x230>
<== NOT EXECUTED
40011414: da 00 a1 5c ld [ %g2 + 0x15c ], %o5
<== NOT EXECUTED
40011418: 10 bf ff f4 b 400113e8 <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
4001141c: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
40011420: 10 bf ff 6b b 400111cc <_POSIX_signals_Send+0x84>
<== NOT EXECUTED
40011424: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
if ( _Thread_Get_priority( the_thread ) < interested_priority ) {
40011428: 08 bf ff dd bleu 4001139c <_POSIX_signals_Send+0x254>
<== NOT EXECUTED
4001142c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40011430: 10 bf ff eb b 400113dc <_POSIX_signals_Send+0x294>
<== NOT EXECUTED
40011434: 9e 10 00 04 mov %g4, %o7
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40011438: c4 01 21 94 ld [ %g4 + 0x194 ], %g2
<== NOT EXECUTED
4001143c: b8 11 21 94 or %g4, 0x194, %i4
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
40011440: b6 07 20 04 add %i4, 4, %i3
<== NOT EXECUTED
40011444: 80 a0 80 1b cmp %g2, %i3
<== NOT EXECUTED
40011448: 02 80 00 31 be 4001150c <_POSIX_signals_Send+0x3c4>
<== NOT EXECUTED
4001144c: 01 00 00 00 nop
<== NOT EXECUTED
new_first = old_first->next;
40011450: c2 00 80 00 ld [ %g2 ], %g1
<== NOT EXECUTED
new_first->previous = head;
40011454: f8 20 60 04 st %i4, [ %g1 + 4 ]
<== NOT EXECUTED
psiginfo->Info = *siginfo;
40011458: f6 07 bf fc ld [ %fp + -4 ], %i3
<== NOT EXECUTED
4001145c: f2 07 bf f8 ld [ %fp + -8 ], %i1
<== NOT EXECUTED
head->next = new_first;
40011460: c2 21 21 94 st %g1, [ %g4 + 0x194 ]
<== NOT EXECUTED
_Chain_Append_unprotected(
40011464: 03 10 00 da sethi %hi(0x40036800), %g1
<== NOT EXECUTED
psiginfo->Info = *siginfo;
40011468: c8 07 bf f4 ld [ %fp + -12 ], %g4
<== NOT EXECUTED
4001146c: c8 20 a0 08 st %g4, [ %g2 + 8 ]
<== NOT EXECUTED
_Chain_Append_unprotected(
40011470: 82 10 61 a4 or %g1, 0x1a4, %g1
<== NOT EXECUTED
psiginfo->Info = *siginfo;
40011474: f2 20 a0 0c st %i1, [ %g2 + 0xc ]
<== NOT EXECUTED
_Chain_Append_unprotected(
40011478: b8 07 40 01 add %i5, %g1, %i4
<== NOT EXECUTED
return &the_chain->Tail.Node;
4001147c: ba 07 60 04 add %i5, 4, %i5
<== NOT EXECUTED
old_last = tail->previous;
40011480: c8 07 20 08 ld [ %i4 + 8 ], %g4
<== NOT EXECUTED
return &the_chain->Tail.Node;
40011484: ba 07 40 01 add %i5, %g1, %i5
<== NOT EXECUTED
psiginfo->Info = *siginfo;
40011488: f6 20 a0 10 st %i3, [ %g2 + 0x10 ]
<== NOT EXECUTED
the_node->next = tail;
4001148c: fa 20 80 00 st %i5, [ %g2 ]
<== NOT EXECUTED
tail->previous = the_node;
40011490: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
40011494: c4 21 00 00 st %g2, [ %g4 ]
<== NOT EXECUTED
the_node->previous = old_last;
40011498: 10 bf ff 7e b 40011290 <_POSIX_signals_Send+0x148>
<== NOT EXECUTED
4001149c: c8 20 a0 04 st %g4, [ %g2 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400114a0: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
400114a4: c4 0e a0 1c ldub [ %i2 + 0x1c ], %g2
<== NOT EXECUTED
400114a8: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
400114ac: 12 80 00 07 bne 400114c8 <_POSIX_signals_Send+0x380>
<== NOT EXECUTED
400114b0: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
400114b4: c0 26 a0 18 clr [ %i2 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400114b8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400114bc: 01 00 00 00 nop
<== NOT EXECUTED
return 0;
400114c0: 81 c7 e0 08 ret
<== NOT EXECUTED
400114c4: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
400114c8: c2 27 bf ec st %g1, [ %fp + -20 ]
<== NOT EXECUTED
400114cc: 40 00 13 b5 call 400163a0 <_Thread_Do_dispatch>
<== NOT EXECUTED
400114d0: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
400114d4: 10 bf ff f9 b 400114b8 <_POSIX_signals_Send+0x370>
<== NOT EXECUTED
400114d8: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
400114dc: 40 00 25 26 call 4001a974 <__errno>
<== NOT EXECUTED
400114e0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400114e4: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400114e8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400114ec: 81 c7 e0 08 ret
<== NOT EXECUTED
400114f0: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ESRCH );
400114f4: 40 00 25 20 call 4001a974 <__errno>
<== NOT EXECUTED
400114f8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400114fc: 82 10 20 03 mov 3, %g1
<== NOT EXECUTED
40011500: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40011504: 81 c7 e0 08 ret
<== NOT EXECUTED
40011508: 81 e8 00 00 restore
<== NOT EXECUTED
4001150c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40011510: 01 00 00 00 nop
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
40011514: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
40011518: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4001151c: 02 80 00 09 be 40011540 <_POSIX_signals_Send+0x3f8>
<== NOT EXECUTED
40011520: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
40011524: c2 26 a0 18 st %g1, [ %i2 + 0x18 ]
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EAGAIN );
40011528: 40 00 25 13 call 4001a974 <__errno>
<== NOT EXECUTED
4001152c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40011530: 82 10 20 0b mov 0xb, %g1
<== NOT EXECUTED
40011534: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40011538: 81 c7 e0 08 ret
<== NOT EXECUTED
4001153c: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40011540: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
40011544: c4 0e a0 1c ldub [ %i2 + 0x1c ], %g2
<== NOT EXECUTED
40011548: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4001154c: 12 80 00 06 bne 40011564 <_POSIX_signals_Send+0x41c>
<== NOT EXECUTED
40011550: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
40011554: c0 26 a0 18 clr [ %i2 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40011558: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001155c: 01 00 00 00 nop
<== NOT EXECUTED
40011560: 30 bf ff f2 b,a 40011528 <_POSIX_signals_Send+0x3e0>
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
40011564: c2 27 bf ec st %g1, [ %fp + -20 ]
<== NOT EXECUTED
40011568: 40 00 13 8e call 400163a0 <_Thread_Do_dispatch>
<== NOT EXECUTED
4001156c: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
40011570: 10 bf ff fa b 40011558 <_POSIX_signals_Send+0x410>
<== NOT EXECUTED
40011574: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
40011804 <_POSIX_signals_Set_process_signals>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40011804: 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;
40011808: 07 10 00 da sethi %hi(0x40036800), %g3
<== NOT EXECUTED
4001180c: c4 00 e1 a0 ld [ %g3 + 0x1a0 ], %g2 ! 400369a0 <_POSIX_signals_Pending>
<== NOT EXECUTED
40011810: 90 10 80 08 or %g2, %o0, %o0
<== NOT EXECUTED
40011814: d0 20 e1 a0 st %o0, [ %g3 + 0x1a0 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40011818: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001181c: 01 00 00 00 nop
<== NOT EXECUTED
_POSIX_signals_Release( &queue_context );
}
40011820: 81 c3 e0 08 retl
<== NOT EXECUTED
40011824: 01 00 00 00 nop
<== NOT EXECUTED
400119b0 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
400119b0: 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 ];
400119b4: 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 ) ) {
400119b8: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
<== NOT EXECUTED
400119bc: 05 04 00 01 sethi %hi(0x10000400), %g2
<== NOT EXECUTED
400119c0: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
400119c4: 82 06 7f ff add %i1, -1, %g1
<== NOT EXECUTED
400119c8: b8 08 c0 02 and %g3, %g2, %i4
<== NOT EXECUTED
400119cc: 83 29 00 01 sll %g4, %g1, %g1
<== NOT EXECUTED
400119d0: 80 a7 00 02 cmp %i4, %g2
<== NOT EXECUTED
400119d4: 02 80 00 19 be 40011a38 <_POSIX_signals_Unblock_thread+0x88>
<== NOT EXECUTED
400119d8: b6 07 60 70 add %i5, 0x70, %i3
<== NOT EXECUTED
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( api->signals_unblocked & mask ) {
400119dc: c4 07 60 68 ld [ %i5 + 0x68 ], %g2
<== NOT EXECUTED
400119e0: 80 88 40 02 btst %g1, %g2
<== NOT EXECUTED
400119e4: 02 80 00 05 be 400119f8 <_POSIX_signals_Unblock_thread+0x48>
<== NOT EXECUTED
400119e8: 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 ) ) {
400119ec: 80 88 c0 01 btst %g3, %g1
<== NOT EXECUTED
400119f0: 12 80 00 4b bne 40011b1c <_POSIX_signals_Unblock_thread+0x16c>
<== NOT EXECUTED
400119f4: 82 10 24 0d mov 0x40d, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400119f8: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Assert( _Thread_State_is_owner( the_thread ) );
cpu_of_thread = _Thread_Get_CPU( the_thread );
action->handler = handler;
400119fc: 05 10 00 46 sethi %hi(0x40011800), %g2
<== NOT EXECUTED
40011a00: 84 10 a0 c4 or %g2, 0xc4, %g2 ! 400118c4 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
40011a04: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
} else {
_Atomic_Fetch_or_ulong( &cpu_target->message, 0, ATOMIC_ORDER_RELEASE );
_CPU_SMP_Send_interrupt( _Per_CPU_Get_index( cpu_target ) );
}
#else
cpu_self->dispatch_necessary = true;
40011a08: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
40011a0c: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Append_if_is_off_chain_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
if ( _Chain_Is_node_off_chain( the_node ) ) {
40011a10: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
40011a14: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40011a18: 22 80 00 1a be,a 40011a80 <_POSIX_signals_Unblock_thread+0xd0>
<== NOT EXECUTED
40011a1c: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40011a20: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40011a24: 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 );
40011a28: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
}
40011a2c: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
40011a30: 81 c7 e0 08 ret
<== NOT EXECUTED
40011a34: 81 e8 00 00 restore
<== NOT EXECUTED
if ( (the_thread->Wait.option & mask) || (api->signals_unblocked & mask) ) {
40011a38: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
<== NOT EXECUTED
40011a3c: 80 88 40 02 btst %g1, %g2
<== NOT EXECUTED
40011a40: 32 80 00 16 bne,a 40011a98 <_POSIX_signals_Unblock_thread+0xe8>
<== NOT EXECUTED
40011a44: 82 10 24 0d mov 0x40d, %g1
<== NOT EXECUTED
40011a48: c4 07 60 68 ld [ %i5 + 0x68 ], %g2
<== NOT EXECUTED
40011a4c: 80 88 40 02 btst %g1, %g2
<== NOT EXECUTED
40011a50: 12 80 00 12 bne 40011a98 <_POSIX_signals_Unblock_thread+0xe8>
<== NOT EXECUTED
40011a54: 82 10 24 0d mov 0x40d, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40011a58: 91 d0 20 09 ta 9
<== NOT EXECUTED
40011a5c: 05 10 00 46 sethi %hi(0x40011800), %g2
<== NOT EXECUTED
40011a60: 84 10 a0 c4 or %g2, 0xc4, %g2 ! 400118c4 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
40011a64: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
40011a68: c8 29 a0 1c stb %g4, [ %g6 + 0x1c ]
<== NOT EXECUTED
40011a6c: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
40011a70: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40011a74: 12 bf ff eb bne 40011a20 <_POSIX_signals_Unblock_thread+0x70>
<== NOT EXECUTED
40011a78: 01 00 00 00 nop
<== NOT EXECUTED
old_last = tail->previous;
40011a7c: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
return &the_chain->Tail.Node;
40011a80: 86 06 20 e4 add %i0, 0xe4, %g3
<== NOT EXECUTED
the_node->next = tail;
40011a84: c6 27 60 70 st %g3, [ %i5 + 0x70 ]
<== NOT EXECUTED
tail->previous = the_node;
40011a88: f6 26 20 e8 st %i3, [ %i0 + 0xe8 ]
<== NOT EXECUTED
old_last->next = the_node;
40011a8c: f6 20 80 00 st %i3, [ %g2 ]
<== NOT EXECUTED
the_node->previous = old_last;
40011a90: 10 bf ff e4 b 40011a20 <_POSIX_signals_Unblock_thread+0x70>
<== NOT EXECUTED
40011a94: c4 27 60 74 st %g2, [ %i5 + 0x74 ]
<== NOT EXECUTED
the_thread->Wait.return_code = STATUS_INTERRUPTED;
40011a98: c2 26 20 4c st %g1, [ %i0 + 0x4c ]
<== NOT EXECUTED
if ( !info ) {
40011a9c: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40011aa0: 02 80 00 2e be 40011b58 <_POSIX_signals_Unblock_thread+0x1a8>
<== NOT EXECUTED
40011aa4: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
<== NOT EXECUTED
*the_info = *info;
40011aa8: c4 06 80 00 ld [ %i2 ], %g2
<== NOT EXECUTED
40011aac: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
40011ab0: c4 06 a0 04 ld [ %i2 + 4 ], %g2
<== NOT EXECUTED
40011ab4: c4 20 60 04 st %g2, [ %g1 + 4 ]
<== NOT EXECUTED
40011ab8: c4 06 a0 08 ld [ %i2 + 8 ], %g2
<== NOT EXECUTED
40011abc: c4 20 60 08 st %g2, [ %g1 + 8 ]
<== NOT EXECUTED
_Thread_queue_Extract_with_proxy( the_thread );
40011ac0: 40 00 14 ef call 40016e7c <_Thread_queue_Extract_with_proxy>
<== NOT EXECUTED
40011ac4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40011ac8: 91 d0 20 09 ta 9
<== NOT EXECUTED
40011acc: 05 10 00 46 sethi %hi(0x40011800), %g2
<== NOT EXECUTED
40011ad0: 84 10 a0 c4 or %g2, 0xc4, %g2 ! 400118c4 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
40011ad4: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
40011ad8: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
40011adc: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
<== NOT EXECUTED
if ( _Chain_Is_node_off_chain( the_node ) ) {
40011ae0: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
40011ae4: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40011ae8: 12 80 00 07 bne 40011b04 <_POSIX_signals_Unblock_thread+0x154>
<== NOT EXECUTED
40011aec: 86 06 20 e4 add %i0, 0xe4, %g3
<== NOT EXECUTED
old_last = tail->previous;
40011af0: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
the_node->next = tail;
40011af4: c6 27 60 70 st %g3, [ %i5 + 0x70 ]
<== NOT EXECUTED
tail->previous = the_node;
40011af8: f6 26 20 e8 st %i3, [ %i0 + 0xe8 ]
<== NOT EXECUTED
old_last->next = the_node;
40011afc: f6 20 80 00 st %i3, [ %g2 ]
<== NOT EXECUTED
the_node->previous = old_last;
40011b00: c4 27 60 74 st %g2, [ %i5 + 0x74 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40011b04: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40011b08: 01 00 00 00 nop
<== NOT EXECUTED
return _POSIX_signals_Unblock_thread_done( the_thread, api, true );
40011b0c: b0 10 20 01 mov 1, %i0 ! 1 <_TLS_Alignment>
<== NOT EXECUTED
}
40011b10: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
40011b14: 81 c7 e0 08 ret
<== NOT EXECUTED
40011b18: 81 e8 00 00 restore
<== NOT EXECUTED
the_thread->Wait.return_code = STATUS_INTERRUPTED;
40011b1c: c2 26 20 4c st %g1, [ %i0 + 0x4c ]
<== NOT EXECUTED
_Thread_queue_Extract_with_proxy( the_thread );
40011b20: 40 00 14 d7 call 40016e7c <_Thread_queue_Extract_with_proxy>
<== NOT EXECUTED
40011b24: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40011b28: 91 d0 20 09 ta 9
<== NOT EXECUTED
40011b2c: 05 10 00 46 sethi %hi(0x40011800), %g2
<== NOT EXECUTED
40011b30: 84 10 a0 c4 or %g2, 0xc4, %g2 ! 400118c4 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
40011b34: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
40011b38: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
40011b3c: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
<== NOT EXECUTED
if ( _Chain_Is_node_off_chain( the_node ) ) {
40011b40: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
40011b44: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40011b48: 12 bf ff b6 bne 40011a20 <_POSIX_signals_Unblock_thread+0x70>
<== NOT EXECUTED
40011b4c: 01 00 00 00 nop
<== NOT EXECUTED
old_last = tail->previous;
40011b50: 10 bf ff cc b 40011a80 <_POSIX_signals_Unblock_thread+0xd0>
<== NOT EXECUTED
40011b54: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
the_info->si_code = SI_USER;
40011b58: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
the_info->si_signo = signo;
40011b5c: f2 20 40 00 st %i1, [ %g1 ]
<== NOT EXECUTED
the_info->si_code = SI_USER;
40011b60: c4 20 60 04 st %g2, [ %g1 + 4 ]
<== NOT EXECUTED
40011b64: 10 bf ff d7 b 40011ac0 <_POSIX_signals_Unblock_thread+0x110>
<== NOT EXECUTED
40011b68: c0 20 60 08 clr [ %g1 + 8 ]
<== NOT EXECUTED
40011578 <_kill_r>:
int _kill_r(
struct _reent *ptr,
pid_t pid,
int sig
)
{
40011578: 82 10 00 0a mov %o2, %g1
<== NOT EXECUTED
return _POSIX_signals_Send( pid, sig, NULL );
4001157c: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
40011580: 94 10 20 00 clr %o2
<== NOT EXECUTED
40011584: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
40011588: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4001158c: 7f ff fe ef call 40011148 <_POSIX_signals_Send>
<== NOT EXECUTED
40011590: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4005e054 <nanosleep>:
{
4005e054: 9d e3 bf a0 save %sp, -96, %sp
4005e058: 92 10 20 00 clr %o1
4005e05c: 94 10 00 18 mov %i0, %o2
4005e060: 96 10 00 19 mov %i1, %o3
4005e064: 7f ff ff 8e call 4005de9c <clock_nanosleep.part.6>
4005e068: 90 10 20 01 mov 1, %o0
if ( eno != 0 ) {
4005e06c: b0 92 20 00 orcc %o0, 0, %i0
4005e070: 12 80 00 04 bne 4005e080 <nanosleep+0x2c>
<== NEVER TAKEN
4005e074: 01 00 00 00 nop
}
4005e078: 81 c7 e0 08 ret
4005e07c: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( eno );
4005e080: 7f ff 90 45 call 40042194 <__errno>
<== NOT EXECUTED
4005e084: 01 00 00 00 nop
<== NOT EXECUTED
4005e088: f0 22 00 00 st %i0, [ %o0 ]
<== NOT EXECUTED
}
4005e08c: 81 c7 e0 08 ret
<== NOT EXECUTED
4005e090: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
40020514 <pthread_attr_destroy>:
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
40020514: 82 92 20 00 orcc %o0, 0, %g1
40020518: 02 80 00 09 be 4002053c <pthread_attr_destroy+0x28>
<== NEVER TAKEN
4002051c: 90 10 20 16 mov 0x16, %o0
40020520: c4 00 40 00 ld [ %g1 ], %g2
40020524: 80 a0 a0 00 cmp %g2, 0
40020528: 02 80 00 05 be 4002053c <pthread_attr_destroy+0x28>
<== NEVER TAKEN
4002052c: 01 00 00 00 nop
return EINVAL;
attr->is_initialized = false;
40020530: c0 20 40 00 clr [ %g1 ]
return 0;
40020534: 81 c3 e0 08 retl
40020538: 90 10 20 00 clr %o0
}
4002053c: 81 c3 e0 08 retl
<== NOT EXECUTED
40020540: 01 00 00 00 nop
<== NOT EXECUTED
40020544 <pthread_attr_getschedpolicy>:
int pthread_attr_getschedpolicy(
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
40020544: 80 a2 20 00 cmp %o0, 0
40020548: 02 80 00 0c be 40020578 <pthread_attr_getschedpolicy+0x34>
<== NEVER TAKEN
4002054c: 01 00 00 00 nop
40020550: c2 02 00 00 ld [ %o0 ], %g1
40020554: 80 a0 60 00 cmp %g1, 0
40020558: 02 80 00 08 be 40020578 <pthread_attr_getschedpolicy+0x34>
<== NEVER TAKEN
4002055c: 80 a2 60 00 cmp %o1, 0
40020560: 02 80 00 06 be 40020578 <pthread_attr_getschedpolicy+0x34>
<== NEVER TAKEN
40020564: 01 00 00 00 nop
return EINVAL;
*policy = attr->schedpolicy;
40020568: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4002056c: c2 22 40 00 st %g1, [ %o1 ]
return 0;
40020570: 81 c3 e0 08 retl
40020574: 90 10 20 00 clr %o0
}
40020578: 81 c3 e0 08 retl
<== NOT EXECUTED
4002057c: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
40020580 <pthread_attr_init>:
* 16.1.1 Thread Creation Attributes, P1003.1c/Draft 10, p, 140
*/
int pthread_attr_init(
pthread_attr_t *attr
)
{
40020580: 9d e3 bf a0 save %sp, -96, %sp
if ( !attr )
40020584: 82 96 20 00 orcc %i0, 0, %g1
40020588: 02 80 00 0b be 400205b4 <pthread_attr_init+0x34>
<== NEVER TAKEN
4002058c: 94 10 20 60 mov 0x60, %o2
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Copy_attributes(
pthread_attr_t *dst_attr,
const pthread_attr_t *src_attr
)
{
*dst_attr = *src_attr;
40020590: 90 10 00 01 mov %g1, %o0
40020594: 13 10 01 98 sethi %hi(0x40066000), %o1
return EINVAL;
_POSIX_Threads_Initialize_attributes( attr );
return 0;
40020598: b0 10 20 00 clr %i0
4002059c: 40 00 94 12 call 400455e4 <memcpy>
400205a0: 92 12 60 68 or %o1, 0x68, %o1
_Assert(
dst_attr->affinitysetsize == sizeof(dst_attr->affinitysetpreallocated)
);
dst_attr->affinityset = &dst_attr->affinitysetpreallocated;
400205a4: 84 02 20 5c add %o0, 0x5c, %g2
400205a8: c4 22 20 58 st %g2, [ %o0 + 0x58 ]
400205ac: 81 c7 e0 08 ret
400205b0: 81 e8 00 00 restore
}
400205b4: 81 c7 e0 08 ret
<== NOT EXECUTED
400205b8: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
400205bc <pthread_attr_setdetachstate>:
int pthread_attr_setdetachstate(
pthread_attr_t *attr,
int detachstate
)
{
if ( !attr || !attr->is_initialized )
400205bc: 82 92 20 00 orcc %o0, 0, %g1
400205c0: 02 80 00 0b be 400205ec <pthread_attr_setdetachstate+0x30>
<== NEVER TAKEN
400205c4: 90 10 20 16 mov 0x16, %o0
400205c8: c4 00 40 00 ld [ %g1 ], %g2
400205cc: 80 a0 a0 00 cmp %g2, 0
400205d0: 02 80 00 07 be 400205ec <pthread_attr_setdetachstate+0x30>
<== NEVER TAKEN
400205d4: 80 a2 60 01 cmp %o1, 1
return EINVAL;
switch ( detachstate ) {
400205d8: 18 80 00 05 bgu 400205ec <pthread_attr_setdetachstate+0x30>
<== NEVER TAKEN
400205dc: 01 00 00 00 nop
case PTHREAD_CREATE_DETACHED:
case PTHREAD_CREATE_JOINABLE:
attr->detachstate = detachstate;
400205e0: d2 20 60 50 st %o1, [ %g1 + 0x50 ]
return 0;
400205e4: 81 c3 e0 08 retl
400205e8: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
400205ec: 81 c3 e0 08 retl
<== NOT EXECUTED
400205f0: 01 00 00 00 nop
<== NOT EXECUTED
400205f4 <pthread_attr_setinheritsched>:
int pthread_attr_setinheritsched(
pthread_attr_t *attr,
int inheritsched
)
{
if ( !attr || !attr->is_initialized )
400205f4: 82 92 20 00 orcc %o0, 0, %g1
400205f8: 02 80 00 0c be 40020628 <pthread_attr_setinheritsched+0x34>
<== NEVER TAKEN
400205fc: 90 10 20 16 mov 0x16, %o0
40020600: c4 00 40 00 ld [ %g1 ], %g2
40020604: 80 a0 a0 00 cmp %g2, 0
40020608: 02 80 00 08 be 40020628 <pthread_attr_setinheritsched+0x34>
<== NEVER TAKEN
4002060c: 84 02 7f ff add %o1, -1, %g2
return EINVAL;
switch ( inheritsched ) {
40020610: 80 a0 a0 01 cmp %g2, 1
40020614: 18 80 00 05 bgu 40020628 <pthread_attr_setinheritsched+0x34>
<== NEVER TAKEN
40020618: 90 10 20 86 mov 0x86, %o0
case PTHREAD_INHERIT_SCHED:
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
4002061c: d2 20 60 10 st %o1, [ %g1 + 0x10 ]
return 0;
40020620: 81 c3 e0 08 retl
40020624: 90 10 20 00 clr %o0
default:
return ENOTSUP;
}
}
40020628: 81 c3 e0 08 retl
<== NOT EXECUTED
4002062c: 01 00 00 00 nop
<== NOT EXECUTED
40020630 <pthread_attr_setschedparam>:
int pthread_attr_setschedparam(
pthread_attr_t *attr,
const struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
40020630: 82 92 20 00 orcc %o0, 0, %g1
40020634: 02 80 00 16 be 4002068c <pthread_attr_setschedparam+0x5c>
<== NEVER TAKEN
40020638: 01 00 00 00 nop
4002063c: c4 00 40 00 ld [ %g1 ], %g2
40020640: 80 a0 a0 00 cmp %g2, 0
40020644: 02 80 00 12 be 4002068c <pthread_attr_setschedparam+0x5c>
<== NEVER TAKEN
40020648: 80 a2 60 00 cmp %o1, 0
4002064c: 02 80 00 10 be 4002068c <pthread_attr_setschedparam+0x5c>
<== NEVER TAKEN
40020650: 01 00 00 00 nop
return EINVAL;
attr->schedparam = *param;
40020654: c4 1a 40 00 ldd [ %o1 ], %g2
40020658: c4 38 60 18 std %g2, [ %g1 + 0x18 ]
return 0;
4002065c: 90 10 20 00 clr %o0
attr->schedparam = *param;
40020660: c4 1a 60 08 ldd [ %o1 + 8 ], %g2
40020664: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
40020668: c4 1a 60 10 ldd [ %o1 + 0x10 ], %g2
4002066c: c4 38 60 28 std %g2, [ %g1 + 0x28 ]
40020670: c4 1a 60 18 ldd [ %o1 + 0x18 ], %g2
40020674: c4 38 60 30 std %g2, [ %g1 + 0x30 ]
40020678: c4 1a 60 20 ldd [ %o1 + 0x20 ], %g2
4002067c: c4 38 60 38 std %g2, [ %g1 + 0x38 ]
40020680: c4 1a 60 28 ldd [ %o1 + 0x28 ], %g2
return 0;
40020684: 81 c3 e0 08 retl
40020688: c4 38 60 40 std %g2, [ %g1 + 0x40 ]
}
4002068c: 81 c3 e0 08 retl
<== NOT EXECUTED
40020690: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
40020694 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
40020694: 82 92 20 00 orcc %o0, 0, %g1
40020698: 02 80 00 10 be 400206d8 <pthread_attr_setschedpolicy+0x44>
<== NEVER TAKEN
4002069c: 90 10 20 16 mov 0x16, %o0
400206a0: c4 00 40 00 ld [ %g1 ], %g2
400206a4: 80 a0 a0 00 cmp %g2, 0
400206a8: 02 80 00 0c be 400206d8 <pthread_attr_setschedpolicy+0x44>
<== NEVER TAKEN
400206ac: 80 a2 60 04 cmp %o1, 4
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
400206b0: 18 80 00 0a bgu 400206d8 <pthread_attr_setschedpolicy+0x44>
<== NEVER TAKEN
400206b4: 90 10 20 86 mov 0x86, %o0
400206b8: 84 10 20 01 mov 1, %g2
400206bc: 85 28 80 09 sll %g2, %o1, %g2
400206c0: 80 88 a0 17 btst 0x17, %g2
400206c4: 02 80 00 05 be 400206d8 <pthread_attr_setschedpolicy+0x44>
<== NEVER TAKEN
400206c8: 01 00 00 00 nop
attr->schedpolicy = policy;
400206cc: d2 20 60 14 st %o1, [ %g1 + 0x14 ]
return 0;
400206d0: 81 c3 e0 08 retl
400206d4: 90 10 20 00 clr %o0
}
}
400206d8: 81 c3 e0 08 retl
<== NOT EXECUTED
400206dc: 01 00 00 00 nop
<== NOT EXECUTED
400206e0 <pthread_attr_setstacksize>:
int pthread_attr_setstacksize(
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
400206e0: 82 92 20 00 orcc %o0, 0, %g1
400206e4: 02 80 00 09 be 40020708 <pthread_attr_setstacksize+0x28>
<== NEVER TAKEN
400206e8: 90 10 20 16 mov 0x16, %o0
400206ec: c4 00 40 00 ld [ %g1 ], %g2
400206f0: 80 a0 a0 00 cmp %g2, 0
400206f4: 02 80 00 05 be 40020708 <pthread_attr_setstacksize+0x28>
<== NEVER TAKEN
400206f8: 01 00 00 00 nop
return EINVAL;
attr->stacksize = stacksize;
400206fc: d2 20 60 08 st %o1, [ %g1 + 8 ]
return 0;
40020700: 81 c3 e0 08 retl
40020704: 90 10 20 00 clr %o0
}
40020708: 81 c3 e0 08 retl
<== NOT EXECUTED
4002070c: 01 00 00 00 nop
<== NOT EXECUTED
4001f6e4 <pthread_cond_destroy>:
/**
* 11.4.2 Initializing and Destroying a Condition Variable,
* P1003.1c/Draft 10, p. 87
*/
int pthread_cond_destroy( pthread_cond_t *cond )
{
4001f6e4: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Condition_variables_Control *the_cond;
unsigned long flags;
Thread_queue_Context queue_context;
the_cond = _POSIX_Condition_variables_Get( cond );
POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
4001f6e8: 80 a6 20 00 cmp %i0, 0
4001f6ec: 02 80 00 1e be 4001f764 <pthread_cond_destroy+0x80>
<== NEVER TAKEN
4001f6f0: 05 06 37 ec sethi %hi(0x18dfb000), %g2
4001f6f4: c2 06 00 00 ld [ %i0 ], %g1
4001f6f8: 82 1e 00 01 xor %i0, %g1, %g1
4001f6fc: 84 10 a1 fe or %g2, 0x1fe, %g2
4001f700: 82 18 40 02 xor %g1, %g2, %g1
4001f704: 80 88 7f fe btst -2, %g1
4001f708: 12 80 00 12 bne 4001f750 <pthread_cond_destroy+0x6c>
<== NEVER TAKEN
4001f70c: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001f710: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Thread_queue_Context_initialize( &queue_context );
_POSIX_Condition_variables_Acquire( the_cond, &queue_context );
if ( !_Thread_queue_Is_empty( &the_cond->Queue.Queue ) ) {
4001f714: c4 06 20 0c ld [ %i0 + 0xc ], %g2
4001f718: 80 a0 a0 00 cmp %g2, 0
4001f71c: 02 80 00 06 be 4001f734 <pthread_cond_destroy+0x50>
<== ALWAYS TAKEN
4001f720: 01 00 00 00 nop
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001f724: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001f728: 01 00 00 00 nop
<== NOT EXECUTED
_POSIX_Condition_variables_Release( the_cond, &queue_context );
return EBUSY;
4001f72c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001f730: 91 e8 20 10 restore %g0, 0x10, %o0
<== NOT EXECUTED
4001f734: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001f738: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Destroy(
POSIX_Condition_variables_Control *the_cond
)
{
the_cond->flags = ~the_cond->flags;
4001f73c: c2 06 00 00 ld [ %i0 ], %g1
4001f740: 82 38 00 01 xnor %g0, %g1, %g1
4001f744: c2 26 00 00 st %g1, [ %i0 ]
}
_POSIX_Condition_variables_Release( the_cond, &queue_context );
_POSIX_Condition_variables_Destroy( the_cond );
return 0;
}
4001f748: 81 c7 e0 08 ret
4001f74c: 91 e8 20 00 restore %g0, 0, %o0
POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
4001f750: 40 00 00 5e call 4001f8c8 <_POSIX_Condition_variables_Auto_initialization>
<== NOT EXECUTED
4001f754: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001f758: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001f75c: 12 bf ff ed bne 4001f710 <pthread_cond_destroy+0x2c>
<== NOT EXECUTED
4001f760: 01 00 00 00 nop
<== NOT EXECUTED
4001f764: 81 c7 e0 08 ret
<== NOT EXECUTED
4001f768: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
4001f76c <pthread_cond_init>:
{
POSIX_Condition_variables_Control *the_cond;
the_cond = _POSIX_Condition_variables_Get( cond );
if ( the_cond == NULL ) {
4001f76c: 82 92 20 00 orcc %o0, 0, %g1
4001f770: 02 80 00 1a be 4001f7d8 <pthread_cond_init+0x6c>
<== NEVER TAKEN
4001f774: 80 a2 60 00 cmp %o1, 0
return EINVAL;
}
if ( attr == NULL ) {
4001f778: 22 80 00 1b be,a 4001f7e4 <pthread_cond_init+0x78>
<== ALWAYS TAKEN
4001f77c: 13 10 01 98 sethi %hi(0x40066000), %o1
attr = &_POSIX_Condition_variables_Default_attributes;
}
if ( !attr->is_initialized ) {
4001f780: c4 02 40 00 ld [ %o1 ], %g2
4001f784: 80 a0 a0 00 cmp %g2, 0
4001f788: 02 80 00 15 be 4001f7dc <pthread_cond_init+0x70>
<== NEVER TAKEN
4001f78c: 90 10 20 16 mov 0x16, %o0
return EINVAL;
}
if ( !_POSIX_Is_valid_pshared( attr->process_shared ) ) {
4001f790: c4 02 60 10 ld [ %o1 + 0x10 ], %g2
4001f794: 80 a0 a0 01 cmp %g2, 1
4001f798: 18 80 00 11 bgu 4001f7dc <pthread_cond_init+0x70>
<== NEVER TAKEN
4001f79c: 05 06 37 ec sethi %hi(0x18dfb000), %g2
4001f7a0: c6 02 60 08 ld [ %o1 + 8 ], %g3
4001f7a4: c8 02 60 0c ld [ %o1 + 0xc ], %g4
)
{
#if defined(RTEMS_SMP)
_SMP_ticket_lock_Initialize( &queue->Lock );
#endif
queue->heads = NULL;
4001f7a8: c0 20 60 0c clr [ %g1 + 0xc ]
queue->owner = NULL;
4001f7ac: c0 20 60 10 clr [ %g1 + 0x10 ]
flags = (uintptr_t) the_cond ^ POSIX_CONDITION_VARIABLES_MAGIC;
4001f7b0: 84 10 a1 fe or %g2, 0x1fe, %g2
queue->name = name;
4001f7b4: c0 20 60 14 clr [ %g1 + 0x14 ]
4001f7b8: 84 18 40 02 xor %g1, %g2, %g2
the_cond->mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
4001f7bc: c0 20 60 18 clr [ %g1 + 0x18 ]
if ( the_attr->clock == CLOCK_MONOTONIC ) {
4001f7c0: 80 a0 e0 00 cmp %g3, 0
4001f7c4: 02 80 00 0a be 4001f7ec <pthread_cond_init+0x80>
<== ALWAYS TAKEN
4001f7c8: 84 08 bf fe and %g2, -2, %g2
the_cond->flags = flags;
4001f7cc: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
return EINVAL;
}
_POSIX_Condition_variables_Initialize( the_cond, attr );
return 0;
4001f7d0: 81 c3 e0 08 retl
4001f7d4: 90 10 20 00 clr %o0
return EINVAL;
4001f7d8: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
}
4001f7dc: 81 c3 e0 08 retl
<== NOT EXECUTED
4001f7e0: 01 00 00 00 nop
<== NOT EXECUTED
attr = &_POSIX_Condition_variables_Default_attributes;
4001f7e4: 10 bf ff e7 b 4001f780 <pthread_cond_init+0x14>
4001f7e8: 92 12 60 40 or %o1, 0x40, %o1
if ( the_attr->clock == CLOCK_MONOTONIC ) {
4001f7ec: 80 a1 20 04 cmp %g4, 4
4001f7f0: 32 bf ff f8 bne,a 4001f7d0 <pthread_cond_init+0x64>
<== ALWAYS TAKEN
4001f7f4: c4 20 40 00 st %g2, [ %g1 ]
flags |= POSIX_CONDITION_VARIABLES_CLOCK_MONOTONIC;
4001f7f8: 84 10 a0 01 or %g2, 1, %g2
<== NOT EXECUTED
return 0;
4001f7fc: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001f800: 81 c3 e0 08 retl
<== NOT EXECUTED
4001f804: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
40020710 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
40020710: 9d e3 bf 20 save %sp, -224, %sp
Thread_Entry_information entry = {
40020714: 03 10 00 94 sethi %hi(0x40025000), %g1
40020718: 82 10 63 b0 or %g1, 0x3b0, %g1 ! 400253b0 <_Thread_Entry_adaptor_pointer>
4002071c: f4 27 bf c8 st %i2, [ %fp + -56 ]
size_t stacksize;
Objects_Name name;
int error;
ISR_lock_Context lock_context;
if ( !start_routine )
40020720: 80 a6 a0 00 cmp %i2, 0
Thread_Entry_information entry = {
40020724: c2 27 bf c4 st %g1, [ %fp + -60 ]
int schedpolicy = SCHED_RR;
40020728: 82 10 20 02 mov 2, %g1
Thread_Entry_information entry = {
4002072c: f6 27 bf cc st %i3, [ %fp + -52 ]
if ( !start_routine )
40020730: 02 80 00 b0 be 400209f0 <pthread_create+0x2e0>
<== NEVER TAKEN
40020734: c2 27 bf bc st %g1, [ %fp + -68 ]
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
40020738: 80 a6 60 00 cmp %i1, 0
4002073c: 22 80 00 a5 be,a 400209d0 <pthread_create+0x2c0>
<== NEVER TAKEN
40020740: 33 10 01 98 sethi %hi(0x40066000), %i1
<== NOT EXECUTED
if ( !the_attr->is_initialized )
40020744: c2 06 40 00 ld [ %i1 ], %g1
40020748: 80 a0 60 00 cmp %g1, 0
4002074c: 02 80 00 9e be 400209c4 <pthread_create+0x2b4>
<== NEVER TAKEN
40020750: 03 10 01 a2 sethi %hi(0x40068800), %g1
* stack space if it is allowed to allocate it itself.
*
* NOTE: If the user provides the stack we will let it drop below
* twice the minimum.
*/
if ( the_attr->stackaddr != NULL ) {
40020754: c4 06 60 04 ld [ %i1 + 4 ], %g2
40020758: e6 06 60 08 ld [ %i1 + 8 ], %l3
4002075c: 80 a0 a0 00 cmp %g2, 0
40020760: 02 80 00 9e be 400209d8 <pthread_create+0x2c8>
<== ALWAYS TAKEN
40020764: c2 00 63 c0 ld [ %g1 + 0x3c0 ], %g1
if ( !_Stack_Is_enough(the_attr->stacksize) ) {
40020768: 80 a0 40 13 cmp %g1, %l3
<== NOT EXECUTED
4002076c: 18 80 00 97 bgu 400209c8 <pthread_create+0x2b8>
<== NOT EXECUTED
40020770: a0 10 20 16 mov 0x16, %l0
<== NOT EXECUTED
* If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
* inherits scheduling attributes from the creating thread. If it is
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
40020774: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
<== NOT EXECUTED
40020778: 80 a0 60 01 cmp %g1, 1
4002077c: 02 80 00 a1 be 40020a00 <pthread_create+0x2f0>
40020780: e4 01 a0 20 ld [ %g6 + 0x20 ], %l2
40020784: 80 a0 60 02 cmp %g1, 2
40020788: 12 80 00 90 bne 400209c8 <pthread_create+0x2b8>
<== NEVER TAKEN
4002078c: a0 10 20 16 mov 0x16, %l0
);
_Assert( error == 0 );
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
40020790: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
schedparam = the_attr->schedparam;
40020794: d4 1e 60 18 ldd [ %i1 + 0x18 ], %o2
40020798: f4 1e 60 20 ldd [ %i1 + 0x20 ], %i2
4002079c: f8 1e 60 28 ldd [ %i1 + 0x28 ], %i4
400207a0: c4 1e 60 30 ldd [ %i1 + 0x30 ], %g2
400207a4: d0 1e 60 38 ldd [ %i1 + 0x38 ], %o0
400207a8: e0 1e 60 40 ldd [ %i1 + 0x40 ], %l0
schedpolicy = the_attr->schedpolicy;
400207ac: c2 27 bf bc st %g1, [ %fp + -68 ]
schedparam = the_attr->schedparam;
400207b0: d4 3f bf d0 std %o2, [ %fp + -48 ]
400207b4: f4 3f bf d8 std %i2, [ %fp + -40 ]
400207b8: f8 3f bf e0 std %i4, [ %fp + -32 ]
400207bc: c4 3f bf e8 std %g2, [ %fp + -24 ]
400207c0: d0 3f bf f0 std %o0, [ %fp + -16 ]
400207c4: e0 3f bf f8 std %l0, [ %fp + -8 ]
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
return ENOTSUP;
400207c8: a0 10 20 86 mov 0x86, %l0
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
400207cc: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400207d0: 80 a0 60 00 cmp %g1, 0
400207d4: 12 80 00 7d bne 400209c8 <pthread_create+0x2b8>
<== NEVER TAKEN
400207d8: d0 07 bf bc ld [ %fp + -68 ], %o0
error = _POSIX_Thread_Translate_sched_param(
400207dc: 96 07 bf b8 add %fp, -72, %o3
400207e0: 94 07 bf b4 add %fp, -76, %o2
400207e4: 40 00 74 2d call 4003d898 <_POSIX_Thread_Translate_sched_param>
400207e8: 92 07 bf d0 add %fp, -48, %o1
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( error != 0 ) {
400207ec: a0 92 20 00 orcc %o0, 0, %l0
400207f0: 32 80 00 82 bne,a 400209f8 <pthread_create+0x2e8>
<== NEVER TAKEN
400207f4: b0 10 00 10 mov %l0, %i0
<== NOT EXECUTED
return error;
}
normal_prio = schedparam.sched_priority;
400207f8: f6 07 bf d0 ld [ %fp + -48 ], %i3
scheduler = _Thread_Scheduler_get_home( executing );
core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );
400207fc: 92 10 00 1b mov %i3, %o1
40020800: 94 07 bf b3 add %fp, -77, %o2
40020804: 29 10 01 7a sethi %hi(0x4005e800), %l4
40020808: 7f ff ff 1c call 40020478 <_POSIX_Priority_To_core>
4002080c: 90 15 21 50 or %l4, 0x150, %o0 ! 4005e950 <_Scheduler_Table>
if ( !valid ) {
40020810: c2 0f bf b3 ldub [ %fp + -77 ], %g1
core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );
40020814: b8 10 00 08 mov %o0, %i4
if ( !valid ) {
40020818: 80 a0 60 00 cmp %g1, 0
4002081c: 02 80 00 6a be 400209c4 <pthread_create+0x2b4>
<== NEVER TAKEN
40020820: ba 10 00 09 mov %o1, %i5
return EINVAL;
}
if ( schedpolicy == SCHED_SPORADIC ) {
40020824: c2 07 bf bc ld [ %fp + -68 ], %g1
40020828: 80 a0 60 04 cmp %g1, 4
4002082c: 22 80 00 02 be,a 40020834 <pthread_create+0x124>
<== NEVER TAKEN
40020830: f6 07 bf d4 ld [ %fp + -44 ], %i3
<== NOT EXECUTED
low_prio = schedparam.sched_ss_low_priority;
} else {
low_prio = normal_prio;
}
core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid );
40020834: 92 10 00 1b mov %i3, %o1
40020838: 94 07 bf b3 add %fp, -77, %o2
4002083c: 7f ff ff 0f call 40020478 <_POSIX_Priority_To_core>
40020840: 90 15 21 50 or %l4, 0x150, %o0
if ( !valid ) {
40020844: c2 0f bf b3 ldub [ %fp + -77 ], %g1
core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid );
40020848: b4 10 00 08 mov %o0, %i2
if ( !valid ) {
4002084c: 80 a0 60 00 cmp %g1, 0
40020850: 02 80 00 5d be 400209c4 <pthread_create+0x2b4>
<== NEVER TAKEN
40020854: b6 10 00 09 mov %o1, %i3
return EINVAL;
}
if ( the_attr->affinityset == NULL ) {
40020858: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
4002085c: 80 a0 60 00 cmp %g1, 0
40020860: 22 80 00 5a be,a 400209c8 <pthread_create+0x2b8>
<== NEVER TAKEN
40020864: a0 10 20 16 mov 0x16, %l0
<== NOT EXECUTED
_RTEMS_Lock_allocator();
40020868: 40 00 02 fc call 40021458 <_RTEMS_Lock_allocator>
4002086c: 2b 10 01 be sethi %hi(0x4006f800), %l5
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate(void)
{
_Objects_Allocator_lock();
_Thread_Kill_zombies();
40020870: 40 00 18 8b call 40026a9c <_Thread_Kill_zombies>
40020874: 01 00 00 00 nop
return (Thread_Control *)
40020878: 40 00 0a f2 call 40023440 <_Objects_Allocate_unprotected>
4002087c: 90 15 62 b8 or %l5, 0x2b8, %o0
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
40020880: a2 92 20 00 orcc %o0, 0, %l1
40020884: 02 80 00 66 be 40020a1c <pthread_create+0x30c>
<== NEVER TAKEN
40020888: 82 07 bf ac add %fp, -84, %g1
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
4002088c: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
40020890: 9a 10 20 01 mov 1, %o5
40020894: c2 07 bf b8 ld [ %fp + -72 ], %g1
40020898: f8 3f bf a0 std %i4, [ %fp + -96 ]
4002089c: 98 10 00 13 mov %l3, %o4
400208a0: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
400208a4: 94 15 21 50 or %l4, 0x150, %o2
400208a8: c2 07 bf b4 ld [ %fp + -76 ], %g1
400208ac: c2 23 a0 68 st %g1, [ %sp + 0x68 ]
400208b0: 82 10 20 01 mov 1, %g1
400208b4: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
400208b8: 92 10 00 11 mov %l1, %o1
400208bc: c2 07 bf a0 ld [ %fp + -96 ], %g1
400208c0: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
400208c4: 90 15 62 b8 or %l5, 0x2b8, %o0
400208c8: c2 07 bf a4 ld [ %fp + -92 ], %g1
400208cc: c0 27 bf ac clr [ %fp + -84 ]
400208d0: c0 23 a0 70 clr [ %sp + 0x70 ]
400208d4: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
400208d8: 40 00 12 fa call 400254c0 <_Thread_Initialize>
400208dc: d6 06 60 04 ld [ %i1 + 4 ], %o3
budget_algorithm,
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
400208e0: 80 a2 20 00 cmp %o0, 0
400208e4: 02 80 00 52 be 40020a2c <pthread_create+0x31c>
<== NEVER TAKEN
400208e8: 92 10 00 11 mov %l1, %o1
_POSIX_Threads_Free( the_thread );
_Objects_Allocator_unlock();
return EAGAIN;
}
if ( the_attr->detachstate == PTHREAD_CREATE_DETACHED ) {
400208ec: c4 06 60 50 ld [ %i1 + 0x50 ], %g2
400208f0: 80 a0 a0 00 cmp %g2, 0
400208f4: 12 80 00 03 bne 40020900 <pthread_create+0x1f0>
<== NEVER TAKEN
400208f8: c2 04 61 70 ld [ %l1 + 0x170 ], %g1
<== NOT EXECUTED
the_thread->Life.state |= THREAD_LIFE_DETACHED;
400208fc: 82 10 60 10 or %g1, 0x10, %g1
<== NOT EXECUTED
}
the_thread->Life.state |= THREAD_LIFE_CHANGE_DEFERRED;
40020900: 82 10 60 08 or %g1, 8, %g1
<== NOT EXECUTED
40020904: c2 24 61 70 st %g1, [ %l1 + 0x170 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40020908: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &lock_context );
4002090c: c2 27 bf c0 st %g1, [ %fp + -64 ]
status = _Scheduler_Set_affinity(
40020910: d4 06 60 58 ld [ %i1 + 0x58 ], %o2
40020914: d2 06 60 54 ld [ %i1 + 0x54 ], %o1
40020918: 40 00 11 01 call 40024d1c <_Scheduler_Set_affinity>
4002091c: 90 10 00 11 mov %l1, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40020920: c2 07 bf c0 ld [ %fp + -64 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40020924: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020928: 01 00 00 00 nop
the_thread,
the_attr->affinitysetsize,
the_attr->affinityset
);
_ISR_lock_ISR_enable( &lock_context );
if ( !status ) {
4002092c: 80 a2 20 00 cmp %o0, 0
40020930: 02 80 00 45 be 40020a44 <pthread_create+0x334>
<== NEVER TAKEN
40020934: 92 10 00 11 mov %l1, %o1
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
executing_api = executing->API_Extensions[ THREAD_API_POSIX ];
api->signals_unblocked = executing_api->signals_unblocked;
40020938: c2 04 a1 5c ld [ %l2 + 0x15c ], %g1
4002093c: c4 00 60 68 ld [ %g1 + 0x68 ], %g2
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
40020940: d0 04 61 5c ld [ %l1 + 0x15c ], %o0
the_thread->was_created_with_inherited_scheduler =
( the_attr->inheritsched == PTHREAD_INHERIT_SCHED );
40020944: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
40020948: 82 18 60 01 xor %g1, 1, %g1
api->signals_unblocked = executing_api->signals_unblocked;
4002094c: c4 22 20 68 st %g2, [ %o0 + 0x68 ]
( the_attr->inheritsched == PTHREAD_INHERIT_SCHED );
40020950: 80 a0 00 01 cmp %g0, %g1
40020954: 82 60 3f ff subx %g0, -1, %g1
40020958: c2 2c 60 8b stb %g1, [ %l1 + 0x8b ]
RTEMS_INLINE_ROUTINE void _Priority_Node_set_priority(
Priority_Node *node,
Priority_Control priority
)
{
node->priority = priority;
4002095c: f4 3a 20 38 std %i2, [ %o0 + 0x38 ]
_Priority_Node_set_priority( &api->Sporadic.Low_priority, core_low_prio );
api->Sporadic.sched_ss_repl_period =
the_attr->schedparam.sched_ss_repl_period;
api->Sporadic.sched_ss_init_budget =
the_attr->schedparam.sched_ss_init_budget;
api->Sporadic.sched_ss_max_repl =
40020960: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
api->Sporadic.sched_ss_repl_period =
40020964: f4 1e 60 20 ldd [ %i1 + 0x20 ], %i2
40020968: f8 1e 60 28 ldd [ %i1 + 0x28 ], %i4
api->Sporadic.sched_ss_init_budget =
4002096c: c4 1e 60 30 ldd [ %i1 + 0x30 ], %g2
40020970: d8 1e 60 38 ldd [ %i1 + 0x38 ], %o4
40020974: d8 3a 20 58 std %o4, [ %o0 + 0x58 ]
api->Sporadic.sched_ss_max_repl =
40020978: c2 22 20 60 st %g1, [ %o0 + 0x60 ]
api->Sporadic.sched_ss_repl_period =
4002097c: f4 3a 20 40 std %i2, [ %o0 + 0x40 ]
40020980: f8 3a 20 48 std %i4, [ %o0 + 0x48 ]
api->Sporadic.sched_ss_init_budget =
40020984: c4 3a 20 50 std %g2, [ %o0 + 0x50 ]
the_attr->schedparam.sched_ss_max_repl;
if ( schedpolicy == SCHED_SPORADIC ) {
40020988: c2 07 bf bc ld [ %fp + -68 ], %g1
4002098c: 80 a0 60 04 cmp %g1, 4
40020990: 02 80 00 33 be 40020a5c <pthread_create+0x34c>
<== NEVER TAKEN
40020994: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40020998: 91 d0 20 09 ta 9
<== NOT EXECUTED
}
/*
* POSIX threads are allocated and started in one operation.
*/
_ISR_lock_ISR_disable( &lock_context );
4002099c: c2 27 bf c0 st %g1, [ %fp + -64 ]
status = _Thread_Start( the_thread, &entry, &lock_context );
400209a0: 94 07 bf c0 add %fp, -64, %o2
400209a4: 92 07 bf c4 add %fp, -60, %o1
400209a8: 40 00 19 09 call 40026dcc <_Thread_Start>
400209ac: 90 10 00 11 mov %l1, %o0
#endif
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
400209b0: c2 04 60 08 ld [ %l1 + 8 ], %g1
_RTEMS_Unlock_allocator();
400209b4: 40 00 02 ae call 4002146c <_RTEMS_Unlock_allocator>
400209b8: c2 26 00 00 st %g1, [ %i0 ]
_Objects_Allocator_unlock();
return 0;
400209bc: 81 c7 e0 08 ret
400209c0: 91 e8 00 10 restore %g0, %l0, %o0
return EINVAL;
400209c4: a0 10 20 16 mov 0x16, %l0
<== NOT EXECUTED
}
400209c8: 81 c7 e0 08 ret
<== NOT EXECUTED
400209cc: 91 e8 00 10 restore %g0, %l0, %o0
<== NOT EXECUTED
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
400209d0: 10 bf ff 5d b 40020744 <pthread_create+0x34>
<== NOT EXECUTED
400209d4: b2 16 60 68 or %i1, 0x68, %i1
<== NOT EXECUTED
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
400209d8: 83 28 60 01 sll %g1, 1, %g1
400209dc: 80 a4 c0 01 cmp %l3, %g1
400209e0: 2a bf ff 65 bcs,a 40020774 <pthread_create+0x64>
<== NEVER TAKEN
400209e4: a6 10 00 01 mov %g1, %l3
<== NOT EXECUTED
switch ( the_attr->inheritsched ) {
400209e8: 10 bf ff 64 b 40020778 <pthread_create+0x68>
400209ec: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
return EFAULT;
400209f0: a0 10 20 0e mov 0xe, %l0
<== NOT EXECUTED
}
400209f4: b0 10 00 10 mov %l0, %i0
<== NOT EXECUTED
400209f8: 81 c7 e0 08 ret
<== NOT EXECUTED
400209fc: 81 e8 00 00 restore
<== NOT EXECUTED
error = pthread_getschedparam(
40020a00: 40 00 00 d2 call 40020d48 <pthread_self>
40020a04: a0 10 20 86 mov 0x86, %l0
40020a08: 94 07 bf d0 add %fp, -48, %o2
40020a0c: 40 00 00 17 call 40020a68 <pthread_getschedparam>
40020a10: 92 07 bf bc add %fp, -68, %o1
break;
40020a14: 10 bf ff 6f b 400207d0 <pthread_create+0xc0>
40020a18: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40020a1c: 40 00 02 94 call 4002146c <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40020a20: a0 10 20 0b mov 0xb, %l0
<== NOT EXECUTED
return EAGAIN;
40020a24: 81 c7 e0 08 ret
<== NOT EXECUTED
40020a28: 91 e8 00 10 restore %g0, %l0, %o0
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information.Objects, &the_pthread->Object );
40020a2c: 90 15 62 b8 or %l5, 0x2b8, %o0
<== NOT EXECUTED
40020a30: 40 00 0b 84 call 40023840 <_Objects_Free>
<== NOT EXECUTED
40020a34: a0 10 20 0b mov 0xb, %l0
<== NOT EXECUTED
40020a38: 40 00 02 8d call 4002146c <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40020a3c: b0 10 00 10 mov %l0, %i0
<== NOT EXECUTED
return EAGAIN;
40020a40: 30 bf ff ee b,a 400209f8 <pthread_create+0x2e8>
<== NOT EXECUTED
40020a44: 90 15 62 b8 or %l5, 0x2b8, %o0
<== NOT EXECUTED
40020a48: 40 00 0b 7e call 40023840 <_Objects_Free>
<== NOT EXECUTED
40020a4c: a0 10 20 16 mov 0x16, %l0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
40020a50: 40 00 02 87 call 4002146c <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40020a54: b0 10 00 10 mov %l0, %i0
<== NOT EXECUTED
return EINVAL;
40020a58: 30 bf ff e8 b,a 400209f8 <pthread_create+0x2e8>
<== NOT EXECUTED
_POSIX_Threads_Sporadic_timer( &api->Sporadic.Timer );
40020a5c: 40 00 00 64 call 40020bec <_POSIX_Threads_Sporadic_timer>
<== NOT EXECUTED
40020a60: 90 02 20 08 add %o0, 8, %o0
<== NOT EXECUTED
40020a64: 30 bf ff cd b,a 40020998 <pthread_create+0x288>
<== NOT EXECUTED
4003d978 <pthread_exit>:
#include <pthread.h>
#include <rtems/score/threadimpl.h>
void pthread_exit( void *value_ptr )
{
4003d978: 9d e3 bf a0 save %sp, -96, %sp
disable_level = cpu_self->thread_dispatch_disable_level;
4003d97c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4003d980: 82 00 60 01 inc %g1
4003d984: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4003d988: ba 10 00 06 mov %g6, %i5
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 );
4003d98c: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
4003d990: 94 10 00 18 mov %i0, %o2
4003d994: 7f ff a4 8a call 40026bbc <_Thread_Exit>
4003d998: 92 10 20 04 mov 4, %o1
_Thread_Dispatch_direct( cpu_self );
4003d99c: 7f ff 9e 6e call 40025354 <_Thread_Dispatch_direct>
4003d9a0: 90 10 00 1d mov %i5, %o0
4003d9a4: 01 00 00 00 nop
<== NOT EXECUTED
40020a68 <pthread_getschedparam>:
int pthread_getschedparam(
pthread_t thread,
int *policy,
struct sched_param *param
)
{
40020a68: 9d e3 bf 78 save %sp, -136, %sp
Thread_queue_Context queue_context;
Thread_CPU_budget_algorithms budget_algorithm;
const Scheduler_Control *scheduler;
Priority_Control priority;
if ( policy == NULL || param == NULL ) {
40020a6c: 80 a6 60 00 cmp %i1, 0
40020a70: 02 80 00 2b be 40020b1c <pthread_getschedparam+0xb4>
<== NEVER TAKEN
40020a74: 80 a6 a0 00 cmp %i2, 0
40020a78: 02 80 00 29 be 40020b1c <pthread_getschedparam+0xb4>
<== NEVER TAKEN
40020a7c: 90 10 00 18 mov %i0, %o0
return EINVAL;
}
_Thread_queue_Context_initialize( &queue_context );
the_thread = _Thread_Get( thread, &queue_context.Lock_context.Lock_context );
40020a80: 92 07 bf dc add %fp, -36, %o1
40020a84: 40 00 12 52 call 400253cc <_Thread_Get>
40020a88: b0 10 20 03 mov 3, %i0
if ( the_thread == NULL ) {
40020a8c: 80 a2 20 00 cmp %o0, 0
40020a90: 02 80 00 21 be 40020b14 <pthread_getschedparam+0xac>
<== NEVER TAKEN
40020a94: a2 10 00 08 mov %o0, %l1
40020a98: f6 02 21 5c ld [ %o0 + 0x15c ], %i3
)
{
const POSIX_API_Control *api;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
param->sched_ss_low_priority = _POSIX_Priority_From_core(
40020a9c: d4 06 e0 3c ld [ %i3 + 0x3c ], %o2
40020aa0: d2 06 e0 38 ld [ %i3 + 0x38 ], %o1
40020aa4: 25 10 01 7a sethi %hi(0x4005e800), %l2
40020aa8: 7f ff fe 91 call 400204ec <_POSIX_Priority_From_core>
40020aac: 90 14 a1 50 or %l2, 0x150, %o0 ! 4005e950 <_Scheduler_Table>
scheduler,
api->Sporadic.Low_priority.priority
);
param->sched_ss_repl_period = api->Sporadic.sched_ss_repl_period;
param->sched_ss_init_budget = api->Sporadic.sched_ss_init_budget;
40020ab0: c4 1e e0 58 ldd [ %i3 + 0x58 ], %g2
<== NOT EXECUTED
40020ab4: f8 1e e0 50 ldd [ %i3 + 0x50 ], %i4
<== NOT EXECUTED
param->sched_ss_repl_period = api->Sporadic.sched_ss_repl_period;
40020ab8: d8 1e e0 40 ldd [ %i3 + 0x40 ], %o4
<== NOT EXECUTED
40020abc: d4 1e e0 48 ldd [ %i3 + 0x48 ], %o2
<== NOT EXECUTED
param->sched_ss_max_repl = api->Sporadic.sched_ss_max_repl;
40020ac0: c2 06 e0 60 ld [ %i3 + 0x60 ], %g1
<== NOT EXECUTED
40020ac4: c2 26 a0 28 st %g1, [ %i2 + 0x28 ]
<== NOT EXECUTED
param->sched_ss_init_budget = api->Sporadic.sched_ss_init_budget;
40020ac8: f8 3e a0 18 std %i4, [ %i2 + 0x18 ]
<== NOT EXECUTED
40020acc: c4 3e a0 20 std %g2, [ %i2 + 0x20 ]
<== NOT EXECUTED
param->sched_ss_repl_period = api->Sporadic.sched_ss_repl_period;
40020ad0: d8 3e a0 08 std %o4, [ %i2 + 8 ]
<== NOT EXECUTED
40020ad4: d4 3e a0 10 std %o2, [ %i2 + 0x10 ]
<== NOT EXECUTED
param->sched_ss_low_priority = _POSIX_Priority_From_core(
40020ad8: d0 26 a0 04 st %o0, [ %i2 + 4 ]
<== NOT EXECUTED
_Thread_Wait_acquire_critical( the_thread, &queue_context );
scheduler = _Thread_Scheduler_get_home( the_thread );
_POSIX_Threads_Get_sched_param_sporadic( the_thread, scheduler, param );
priority = the_thread->Real_priority.priority;
40020adc: c4 1c 60 30 ldd [ %l1 + 0x30 ], %g2
<== NOT EXECUTED
budget_algorithm = the_thread->budget_algorithm;
40020ae0: fa 04 60 90 ld [ %l1 + 0x90 ], %i5
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40020ae4: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40020ae8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020aec: 01 00 00 00 nop
_Thread_Wait_release( the_thread, &queue_context );
param->sched_priority = _POSIX_Priority_From_core( scheduler, priority );
40020af0: 92 10 00 02 mov %g2, %o1
40020af4: 94 10 00 03 mov %g3, %o2
40020af8: 7f ff fe 7d call 400204ec <_POSIX_Priority_From_core>
40020afc: 90 14 a1 50 or %l2, 0x150, %o0
40020b00: d0 26 80 00 st %o0, [ %i2 ]
*policy = _POSIX_Thread_Translate_to_sched_policy( budget_algorithm );
return 0;
40020b04: b0 10 20 00 clr %i0
*policy = _POSIX_Thread_Translate_to_sched_policy( budget_algorithm );
40020b08: 40 00 73 5a call 4003d870 <_POSIX_Thread_Translate_to_sched_policy>
40020b0c: 90 10 00 1d mov %i5, %o0
40020b10: d0 26 40 00 st %o0, [ %i1 ]
return 0;
40020b14: 81 c7 e0 08 ret
40020b18: 81 e8 00 00 restore
return EINVAL;
40020b1c: b0 10 20 16 mov 0x16, %i0
<== NOT EXECUTED
}
40020b20: 81 c7 e0 08 ret
<== NOT EXECUTED
40020b24: 81 e8 00 00 restore
<== NOT EXECUTED
40006fcc <pthread_getspecific>:
ISR_Level level;
_ISR_Local_disable( level );
#endif
executing = _Thread_Executing;
40006fcc: c6 01 a0 20 ld [ %g6 + 0x20 ], %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006fd0: 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 );
40006fd4: 86 00 e1 60 add %g3, 0x160, %g3
RBTree_Node *parent;
link = _RBTree_Root_const_reference( the_rbtree );
parent = NULL;
while ( *link != NULL ) {
40006fd8: c4 00 c0 00 ld [ %g3 ], %g2
40006fdc: 80 a0 a0 00 cmp %g2, 0
40006fe0: 02 80 00 0d be 40007014 <pthread_getspecific+0x48>
40006fe4: 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;
40006fe8: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
parent = *link;
if ( ( *equal )( key, parent ) ) {
40006fec: 80 a2 00 04 cmp %o0, %g4
40006ff0: 22 80 00 0e be,a 40007028 <pthread_getspecific+0x5c>
40006ff4: d0 00 e0 20 ld [ %g3 + 0x20 ], %o0
return ( *map )( parent );
} else if ( ( *less )( key, parent ) ) {
40006ff8: 1a bf ff f8 bcc 40006fd8 <pthread_getspecific+0xc>
40006ffc: 86 00 a0 04 add %g2, 4, %g3
return &RB_LEFT( the_node, Node );
40007000: 86 10 00 02 mov %g2, %g3
while ( *link != NULL ) {
40007004: c4 00 c0 00 ld [ %g3 ], %g2
40007008: 80 a0 a0 00 cmp %g2, 0
4000700c: 12 bf ff f7 bne 40006fe8 <pthread_getspecific+0x1c>
<== NEVER TAKEN
40007010: 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;
40007014: 90 10 20 00 clr %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007018: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000701c: 01 00 00 00 nop
}
_POSIX_Keys_Key_value_release( executing, &lock_context );
return value;
}
40007020: 81 c3 e0 08 retl
40007024: 01 00 00 00 nop
40007028: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000702c: 01 00 00 00 nop
40007030: 81 c3 e0 08 retl
40007034: 01 00 00 00 nop
40006f5c <pthread_key_create>:
*/
int pthread_key_create(
pthread_key_t *key,
void (*destructor)( void * )
)
{
40006f5c: 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 );
40006f60: 3b 10 00 5c sethi %hi(0x40017000), %i5
40006f64: 40 00 08 63 call 400090f0 <_Objects_Allocate>
40006f68: 90 17 60 ac or %i5, 0xac, %o0 ! 400170ac <_POSIX_Keys_Information>
POSIX_Keys_Control *the_key;
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
40006f6c: 80 a2 20 00 cmp %o0, 0
40006f70: 02 80 00 13 be 40006fbc <pthread_key_create+0x60>
<== NEVER TAKEN
40006f74: 86 02 20 14 add %o0, 0x14, %g3
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40006f78: c2 12 20 0a lduh [ %o0 + 0xa ], %g1
tail->previous = head;
40006f7c: c6 22 20 1c st %g3, [ %o0 + 0x1c ]
return &the_chain->Tail.Node;
40006f80: 84 02 20 18 add %o0, 0x18, %g2
_Objects_Allocator_unlock();
return EAGAIN;
}
the_key->destructor = destructor;
40006f84: f2 22 20 10 st %i1, [ %o0 + 0x10 ]
40006f88: ba 17 60 ac or %i5, 0xac, %i5
head->next = tail;
40006f8c: c4 22 20 14 st %g2, [ %o0 + 0x14 ]
40006f90: 83 28 60 02 sll %g1, 2, %g1
head->previous = NULL;
40006f94: c0 22 20 18 clr [ %o0 + 0x18 ]
Objects_Control *the_object,
uint32_t name
)
{
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
40006f98: c0 22 20 0c clr [ %o0 + 0xc ]
information->local_table[ index ] = the_object;
40006f9c: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
40006fa0: c4 02 20 08 ld [ %o0 + 8 ], %g2
40006fa4: 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;
40006fa8: c4 26 00 00 st %g2, [ %i0 ]
* previous thread life protection state and thus may not return if the
* executing thread was restarted or deleted in the mean-time.
*/
RTEMS_INLINE_ROUTINE void _Objects_Allocator_unlock( void )
{
_RTEMS_Unlock_allocator();
40006fac: 40 00 01 9b call 40007618 <_RTEMS_Unlock_allocator>
40006fb0: b0 10 20 00 clr %i0
_Objects_Allocator_unlock();
return 0;
}
40006fb4: 81 c7 e0 08 ret
40006fb8: 81 e8 00 00 restore
40006fbc: 40 00 01 97 call 40007618 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40006fc0: b0 10 20 0b mov 0xb, %i0
<== NOT EXECUTED
return EAGAIN;
40006fc4: 81 c7 e0 08 ret
<== NOT EXECUTED
40006fc8: 81 e8 00 00 restore
<== NOT EXECUTED
40020bfc <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
)
{
40020bfc: 9d e3 bf 98 save %sp, -104, %sp
_RTEMS_Lock_allocator();
40020c00: 40 00 06 4e call 40022538 <_RTEMS_Lock_allocator>
40020c04: 33 10 01 66 sethi %hi(0x40059800), %i1
_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 *)
40020c08: 90 10 00 18 mov %i0, %o0
the_key = _POSIX_Keys_Get( key );
if ( the_key != NULL ) {
_POSIX_Keys_Destroy( the_key );
eno = 0;
} else {
eno = EINVAL;
40020c0c: b0 10 20 16 mov 0x16, %i0
40020c10: 40 00 0f ff call 40024c0c <_Objects_Get_no_protection>
40020c14: 92 16 60 f4 or %i1, 0xf4, %o1
if ( the_key != NULL ) {
40020c18: 80 a2 20 00 cmp %o0, 0
40020c1c: 02 80 00 24 be 40020cac <pthread_key_delete+0xb0>
40020c20: b8 10 00 08 mov %o0, %i4
_Objects_Close( &_POSIX_Keys_Information, &the_key->Object );
40020c24: 92 10 00 08 mov %o0, %o1
40020c28: 40 00 0e c6 call 40024740 <_Objects_Close>
40020c2c: 90 16 60 f4 or %i1, 0xf4, %o0
return _Chain_Immutable_head( the_chain )->next;
40020c30: fa 07 20 14 ld [ %i4 + 0x14 ], %i5
return &the_chain->Tail.Node;
40020c34: b4 07 20 18 add %i4, 0x18, %i2
while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) {
40020c38: 80 a6 80 1d cmp %i2, %i5
40020c3c: 02 80 00 19 be 40020ca0 <pthread_key_delete+0xa4>
40020c40: 92 10 00 1c mov %i4, %o1
40020c44: 37 10 01 66 sethi %hi(0x40059800), %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 );
40020c48: b6 16 e1 30 or %i3, 0x130, %i3 ! 40059930 <_POSIX_Keys_Keypool>
<== NOT EXECUTED
the_thread = key_value_pair->thread;
40020c4c: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40020c50: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
40020c54: c2 27 bf fc st %g1, [ %fp + -4 ]
_RBTree_Extract(
40020c58: 92 07 60 08 add %i5, 8, %o1
40020c5c: 40 00 10 9d call 40024ed0 <_RBTree_Extract>
40020c60: 90 02 21 60 add %o0, 0x160, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40020c64: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40020c68: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020c6c: 01 00 00 00 nop
next = the_node->next;
40020c70: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
40020c74: c2 07 60 04 ld [ %i5 + 4 ], %g1
next->previous = previous;
40020c78: c2 20 a0 04 st %g1, [ %g2 + 4 ]
40020c7c: 92 10 00 1d mov %i5, %o1
previous->next = next;
40020c80: c4 20 40 00 st %g2, [ %g1 ]
40020c84: 40 00 06 8e call 400226bc <_Freechain_Put>
40020c88: 90 10 00 1b mov %i3, %o0
return _Chain_Immutable_head( the_chain )->next;
40020c8c: fa 07 20 14 ld [ %i4 + 0x14 ], %i5
while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) {
40020c90: 80 a7 40 1a cmp %i5, %i2
40020c94: 32 bf ff ef bne,a 40020c50 <pthread_key_delete+0x54>
<== NEVER TAKEN
40020c98: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
<== NOT EXECUTED
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
40020c9c: 92 10 00 1c mov %i4, %o1
40020ca0: 90 16 60 f4 or %i1, 0xf4, %o0
40020ca4: 40 00 0f 73 call 40024a70 <_Objects_Free>
40020ca8: b0 10 20 00 clr %i0
_RTEMS_Unlock_allocator();
40020cac: 40 00 06 28 call 4002254c <_RTEMS_Unlock_allocator>
40020cb0: 01 00 00 00 nop
}
_Objects_Allocator_unlock();
return eno;
}
40020cb4: 81 c7 e0 08 ret
40020cb8: 81 e8 00 00 restore
40011b6c <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 )
{
40011b6c: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
40011b70: 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 ) ) {
40011b74: 80 a7 60 1f cmp %i5, 0x1f
<== NOT EXECUTED
40011b78: 18 80 00 28 bgu 40011c18 <pthread_kill+0xac>
<== NOT EXECUTED
40011b7c: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
return EINVAL;
}
the_thread = _Thread_Get( thread, &lock_context );
40011b80: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
40011b84: 40 00 12 66 call 4001651c <_Thread_Get>
<== NOT EXECUTED
40011b88: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( the_thread == NULL ) {
40011b8c: 86 92 20 00 orcc %o0, 0, %g3
<== NOT EXECUTED
40011b90: 02 80 00 22 be 40011c18 <pthread_kill+0xac>
<== NOT EXECUTED
40011b94: 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 ) {
40011b98: 83 2e 60 01 sll %i1, 1, %g1
<== NOT EXECUTED
40011b9c: 82 00 40 19 add %g1, %i1, %g1
<== NOT EXECUTED
40011ba0: 85 28 60 02 sll %g1, 2, %g2
<== NOT EXECUTED
40011ba4: 03 10 00 da sethi %hi(0x40036800), %g1
<== NOT EXECUTED
40011ba8: 82 10 60 14 or %g1, 0x14, %g1 ! 40036814 <_POSIX_signals_Vectors>
<== NOT EXECUTED
40011bac: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
40011bb0: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
40011bb4: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
40011bb8: 02 80 00 24 be 40011c48 <pthread_kill+0xdc>
<== NOT EXECUTED
40011bbc: 01 00 00 00 nop
<== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
40011bc0: c8 00 e1 5c ld [ %g3 + 0x15c ], %g4
<== NOT EXECUTED
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
40011bc4: c4 01 20 6c ld [ %g4 + 0x6c ], %g2
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
40011bc8: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
return 1u << (sig - 1);
40011bcc: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
40011bd0: bb 28 c0 1d sll %g3, %i5, %i5
<== NOT EXECUTED
40011bd4: ba 10 80 1d or %g2, %i5, %i5
<== NOT EXECUTED
40011bd8: fa 21 20 6c st %i5, [ %g4 + 0x6c ]
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40011bdc: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40011be0: b8 10 00 06 mov %g6, %i4
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40011be4: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40011be8: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40011bec: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40011bf0: 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 );
40011bf4: 94 10 20 00 clr %o2 ! 0 <PROM_START>
<== NOT EXECUTED
40011bf8: 7f ff ff 6e call 400119b0 <_POSIX_signals_Unblock_thread>
<== NOT EXECUTED
40011bfc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
40011c00: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
40011c04: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
40011c08: 02 80 00 06 be 40011c20 <pthread_kill+0xb4>
<== NOT EXECUTED
40011c0c: 84 00 7f ff add %g1, -1, %g2
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
40011c10: c4 27 20 18 st %g2, [ %i4 + 0x18 ]
<== NOT EXECUTED
_Thread_Dispatch_enable( cpu_self );
return 0;
40011c14: 82 10 20 00 clr %g1
<== NOT EXECUTED
}
40011c18: 81 c7 e0 08 ret
<== NOT EXECUTED
40011c1c: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40011c20: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
40011c24: c4 0f 20 1c ldub [ %i4 + 0x1c ], %g2
<== NOT EXECUTED
40011c28: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40011c2c: 12 80 00 0d bne 40011c60 <pthread_kill+0xf4>
<== NOT EXECUTED
40011c30: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
40011c34: c0 27 20 18 clr [ %i4 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40011c38: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40011c3c: 01 00 00 00 nop
<== NOT EXECUTED
return 0;
40011c40: 10 bf ff f6 b 40011c18 <pthread_kill+0xac>
<== NOT EXECUTED
40011c44: 82 10 20 00 clr %g1 ! 0 <PROM_START>
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40011c48: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40011c4c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40011c50: 01 00 00 00 nop
<== NOT EXECUTED
return 0;
40011c54: 82 10 20 00 clr %g1 ! 0 <PROM_START>
<== NOT EXECUTED
}
40011c58: 81 c7 e0 08 ret
<== NOT EXECUTED
40011c5c: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
40011c60: c2 27 bf f4 st %g1, [ %fp + -12 ]
<== NOT EXECUTED
40011c64: 40 00 11 cf call 400163a0 <_Thread_Do_dispatch>
<== NOT EXECUTED
40011c68: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40011c6c: 10 bf ff f3 b 40011c38 <pthread_kill+0xcc>
<== NOT EXECUTED
40011c70: c2 07 bf f4 ld [ %fp + -12 ], %g1
<== NOT EXECUTED
4001fd0c <pthread_mutex_destroy>:
*/
int pthread_mutex_destroy(
pthread_mutex_t *mutex
)
{
4001fd0c: 9d e3 bf a0 save %sp, -96, %sp
unsigned long flags;
Thread_queue_Context queue_context;
int eno;
the_mutex = _POSIX_Mutex_Get( mutex );
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
4001fd10: 80 a6 20 00 cmp %i0, 0
4001fd14: 02 80 00 18 be 4001fd74 <pthread_mutex_destroy+0x68>
<== NEVER TAKEN
4001fd18: 05 25 87 04 sethi %hi(0x961c1000), %g2
4001fd1c: c2 06 00 00 ld [ %i0 ], %g1
4001fd20: 82 1e 00 01 xor %i0, %g1, %g1
4001fd24: 84 10 a3 b8 or %g2, 0x3b8, %g2
4001fd28: 82 18 40 02 xor %g1, %g2, %g1
4001fd2c: 80 88 7f f8 btst -8, %g1
4001fd30: 12 80 00 0c bne 4001fd60 <pthread_mutex_destroy+0x54>
<== NEVER TAKEN
4001fd34: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001fd38: 91 d0 20 09 ta 9
<== NOT EXECUTED
_POSIX_Mutex_Acquire( the_mutex, &queue_context );
if ( _POSIX_Mutex_Get_owner( the_mutex ) == NULL ) {
4001fd3c: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
4001fd40: 80 a0 a0 00 cmp %g2, 0
4001fd44: 22 80 00 0e be,a 4001fd7c <pthread_mutex_destroy+0x70>
<== ALWAYS TAKEN
4001fd48: c4 06 00 00 ld [ %i0 ], %g2
the_mutex->flags = ~the_mutex->flags;
eno = 0;
} else {
eno = EBUSY;
4001fd4c: b0 10 20 10 mov 0x10, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001fd50: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001fd54: 01 00 00 00 nop
<== NOT EXECUTED
}
_POSIX_Mutex_Release( the_mutex, &queue_context );
return eno;
}
4001fd58: 81 c7 e0 08 ret
<== NOT EXECUTED
4001fd5c: 81 e8 00 00 restore
<== NOT EXECUTED
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
4001fd60: 40 00 01 0d call 40020194 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
4001fd64: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001fd68: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001fd6c: 12 bf ff f3 bne 4001fd38 <pthread_mutex_destroy+0x2c>
<== NOT EXECUTED
4001fd70: 01 00 00 00 nop
<== NOT EXECUTED
4001fd74: 81 c7 e0 08 ret
<== NOT EXECUTED
4001fd78: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
the_mutex->flags = ~the_mutex->flags;
4001fd7c: 84 38 00 02 xnor %g0, %g2, %g2
<== NOT EXECUTED
4001fd80: c4 26 00 00 st %g2, [ %i0 ]
<== NOT EXECUTED
eno = 0;
4001fd84: b0 10 20 00 clr %i0
<== NOT EXECUTED
4001fd88: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001fd8c: 01 00 00 00 nop
}
4001fd90: 81 c7 e0 08 ret
4001fd94: 81 e8 00 00 restore
4001fd98 <pthread_mutex_init>:
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr
)
{
4001fd98: 9d e3 bf 98 save %sp, -104, %sp
POSIX_Mutex_Protocol protocol;
unsigned long flags;
Priority_Control priority;
const Scheduler_Control *scheduler;
if ( attr ) the_attr = attr;
4001fd9c: 80 a6 60 00 cmp %i1, 0
4001fda0: 02 80 00 0f be 4001fddc <pthread_mutex_init+0x44>
<== ALWAYS TAKEN
4001fda4: ba 10 00 18 mov %i0, %i5
else the_attr = &_POSIX_Mutex_Default_attributes;
/* Check for NULL mutex */
if ( !mutex )
4001fda8: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4001fdac: 02 80 00 44 be 4001febc <pthread_mutex_init+0x124>
<== NOT EXECUTED
4001fdb0: 01 00 00 00 nop
<== NOT EXECUTED
* value in an uninitialized variable to make this fail.
*
* Thus, we do not look at *mutex.
*/
if ( !the_attr->is_initialized )
4001fdb4: c2 06 40 00 ld [ %i1 ], %g1
<== NOT EXECUTED
4001fdb8: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001fdbc: 02 80 00 06 be 4001fdd4 <pthread_mutex_init+0x3c>
<== NOT EXECUTED
4001fdc0: b0 10 20 16 mov 0x16, %i0
<== NOT EXECUTED
return EINVAL;
if ( !_POSIX_Is_valid_pshared( the_attr->process_shared ) ) {
4001fdc4: c2 06 60 04 ld [ %i1 + 4 ], %g1
<== NOT EXECUTED
4001fdc8: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4001fdcc: 28 80 00 16 bleu,a 4001fe24 <pthread_mutex_init+0x8c>
<== NOT EXECUTED
4001fdd0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
<== NOT EXECUTED
);
the_mutex->Recursive.nest_level = 0;
_Priority_Node_initialize( &the_mutex->Priority_ceiling, priority );
the_mutex->scheduler = scheduler;
return 0;
}
4001fdd4: 81 c7 e0 08 ret
<== NOT EXECUTED
4001fdd8: 81 e8 00 00 restore
<== NOT EXECUTED
if ( !mutex )
4001fddc: 80 a6 20 00 cmp %i0, 0
4001fde0: 02 80 00 37 be 4001febc <pthread_mutex_init+0x124>
<== NEVER TAKEN
4001fde4: 03 25 87 04 sethi %hi(0x961c1000), %g1
flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
4001fde8: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 <RAM_END+0x55dc13b8>
4001fdec: 82 1e 00 01 xor %i0, %g1, %g1
flags &= ~POSIX_MUTEX_FLAGS_MASK;
4001fdf0: 82 08 7f f8 and %g1, -8, %g1
the_mutex->flags = flags;
4001fdf4: c2 26 00 00 st %g1, [ %i0 ]
scheduler = NULL;
4001fdf8: 84 10 20 00 clr %g2
priority = 0;
4001fdfc: 90 10 20 00 clr %o0
4001fe00: 92 10 20 00 clr %o1
queue->heads = NULL;
4001fe04: c0 27 60 0c clr [ %i5 + 0xc ]
queue->owner = NULL;
4001fe08: c0 27 60 10 clr [ %i5 + 0x10 ]
queue->name = name;
4001fe0c: c0 27 60 14 clr [ %i5 + 0x14 ]
the_mutex->Recursive.nest_level = 0;
4001fe10: c0 27 60 18 clr [ %i5 + 0x18 ]
RTEMS_INLINE_ROUTINE void _Priority_Node_initialize(
Priority_Node *node,
Priority_Control priority
)
{
node->priority = priority;
4001fe14: d0 3f 60 30 std %o0, [ %i5 + 0x30 ]
the_mutex->scheduler = scheduler;
4001fe18: c4 27 60 38 st %g2, [ %i5 + 0x38 ]
return 0;
4001fe1c: 81 c7 e0 08 ret
4001fe20: 91 e8 20 00 restore %g0, 0, %o0
switch ( the_attr->protocol ) {
4001fe24: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4001fe28: 02 80 00 27 be 4001fec4 <pthread_mutex_init+0x12c>
<== NOT EXECUTED
4001fe2c: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
4001fe30: 02 80 00 27 be 4001fecc <pthread_mutex_init+0x134>
<== NOT EXECUTED
4001fe34: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001fe38: 12 bf ff e7 bne 4001fdd4 <pthread_mutex_init+0x3c>
<== NOT EXECUTED
4001fe3c: 84 10 20 00 clr %g2
<== NOT EXECUTED
switch ( the_attr->type ) {
4001fe40: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
<== NOT EXECUTED
4001fe44: 80 a0 60 03 cmp %g1, 3
<== NOT EXECUTED
4001fe48: 18 bf ff e3 bgu 4001fdd4 <pthread_mutex_init+0x3c>
<== NOT EXECUTED
4001fe4c: b0 10 20 16 mov 0x16, %i0
<== NOT EXECUTED
if ( the_attr->type == PTHREAD_MUTEX_RECURSIVE ) {
4001fe50: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
4001fe54: 03 25 87 04 sethi %hi(0x961c1000), %g1
<== NOT EXECUTED
4001fe58: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 <RAM_END+0x55dc13b8>
<== NOT EXECUTED
4001fe5c: 82 1f 40 01 xor %i5, %g1, %g1
<== NOT EXECUTED
flags &= ~POSIX_MUTEX_FLAGS_MASK;
4001fe60: 82 08 7f f8 and %g1, -8, %g1
<== NOT EXECUTED
if ( the_attr->type == PTHREAD_MUTEX_RECURSIVE ) {
4001fe64: 12 80 00 03 bne 4001fe70 <pthread_mutex_init+0xd8>
<== NOT EXECUTED
4001fe68: 82 10 80 01 or %g2, %g1, %g1
<== NOT EXECUTED
flags |= POSIX_MUTEX_RECURSIVE;
4001fe6c: 82 10 60 04 or %g1, 4, %g1
<== NOT EXECUTED
if ( protocol == POSIX_MUTEX_PRIORITY_CEILING ) {
4001fe70: 80 a0 a0 02 cmp %g2, 2
<== NOT EXECUTED
4001fe74: 12 80 00 18 bne 4001fed4 <pthread_mutex_init+0x13c>
<== NOT EXECUTED
4001fe78: c2 27 40 00 st %g1, [ %i5 ]
<== NOT EXECUTED
prio_ceiling = the_attr->prio_ceiling;
4001fe7c: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
if ( prio_ceiling == INT_MAX ) {
4001fe80: 03 1f ff ff sethi %hi(0x7ffffc00), %g1
<== NOT EXECUTED
4001fe84: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff <RAM_END+0x3fbfffff>
<== NOT EXECUTED
4001fe88: 80 a2 40 01 cmp %o1, %g1
<== NOT EXECUTED
4001fe8c: 12 80 00 05 bne 4001fea0 <pthread_mutex_init+0x108>
<== NOT EXECUTED
4001fe90: 39 10 01 7a sethi %hi(0x4005e800), %i4
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE int _POSIX_Priority_Get_maximum(
const Scheduler_Control *scheduler
)
{
_Assert( (int) scheduler->maximum_priority > 1 );
return (int) scheduler->maximum_priority - 1;
4001fe94: 82 17 21 50 or %i4, 0x150, %g1 ! 4005e950 <_Scheduler_Table>
<== NOT EXECUTED
4001fe98: d2 00 60 44 ld [ %g1 + 0x44 ], %o1
<== NOT EXECUTED
4001fe9c: 92 02 7f ff add %o1, -1, %o1
<== NOT EXECUTED
priority = _POSIX_Priority_To_core( scheduler, prio_ceiling, &valid );
4001fea0: 94 07 bf ff add %fp, -1, %o2
<== NOT EXECUTED
4001fea4: 40 00 01 75 call 40020478 <_POSIX_Priority_To_core>
<== NOT EXECUTED
4001fea8: 90 17 21 50 or %i4, 0x150, %o0
<== NOT EXECUTED
if ( !valid ) {
4001feac: c2 0f bf ff ldub [ %fp + -1 ], %g1
<== NOT EXECUTED
4001feb0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001feb4: 12 bf ff d4 bne 4001fe04 <pthread_mutex_init+0x6c>
<== NOT EXECUTED
4001feb8: 84 17 21 50 or %i4, 0x150, %g2
<== NOT EXECUTED
return EINVAL;
4001febc: 81 c7 e0 08 ret
<== NOT EXECUTED
4001fec0: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
protocol = POSIX_MUTEX_PRIORITY_INHERIT;
4001fec4: 10 bf ff df b 4001fe40 <pthread_mutex_init+0xa8>
<== NOT EXECUTED
4001fec8: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
break;
4001fecc: 10 bf ff dd b 4001fe40 <pthread_mutex_init+0xa8>
<== NOT EXECUTED
4001fed0: 84 10 20 02 mov 2, %g2
<== NOT EXECUTED
scheduler = NULL;
4001fed4: 84 10 20 00 clr %g2
<== NOT EXECUTED
priority = 0;
4001fed8: 90 10 20 00 clr %o0
<== NOT EXECUTED
4001fedc: 10 bf ff ca b 4001fe04 <pthread_mutex_init+0x6c>
<== NOT EXECUTED
4001fee0: 92 10 20 00 clr %o1
<== NOT EXECUTED
40020230 <pthread_mutex_unlock>:
*/
int pthread_mutex_unlock(
pthread_mutex_t *mutex
)
{
40020230: 9d e3 bf 70 save %sp, -144, %sp
Thread_queue_Context queue_context;
Thread_Control *executing;
Status_Control status;
the_mutex = _POSIX_Mutex_Get( mutex );
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40020234: 80 a6 20 00 cmp %i0, 0
40020238: 02 80 00 32 be 40020300 <pthread_mutex_unlock+0xd0>
<== NEVER TAKEN
4002023c: 05 25 87 04 sethi %hi(0x961c1000), %g2
40020240: fa 06 00 00 ld [ %i0 ], %i5
40020244: 82 1e 00 1d xor %i0, %i5, %g1
40020248: 84 10 a3 b8 or %g2, 0x3b8, %g2
4002024c: 82 18 40 02 xor %g1, %g2, %g1
40020250: 80 88 7f f8 btst -8, %g1
40020254: 12 80 00 26 bne 400202ec <pthread_mutex_unlock+0xbc>
<== NEVER TAKEN
40020258: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002025c: 91 d0 20 09 ta 9
<== NOT EXECUTED
40020260: c2 27 bf dc st %g1, [ %fp + -36 ]
executing = _POSIX_Mutex_Acquire( the_mutex, &queue_context );
switch ( _POSIX_Mutex_Get_protocol( flags ) ) {
40020264: ba 8f 60 03 andcc %i5, 3, %i5
40020268: 02 80 00 28 be 40020308 <pthread_mutex_unlock+0xd8>
<== ALWAYS TAKEN
4002026c: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
40020270: 80 a7 60 02 cmp %i5, 2
<== NOT EXECUTED
40020274: 12 80 00 0a bne 4002029c <pthread_mutex_unlock+0x6c>
<== NOT EXECUTED
40020278: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
<== NOT EXECUTED
unsigned int nest_level;
ISR_lock_Context lock_context;
Per_CPU_Control *cpu_self;
Thread_queue_Heads *heads;
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
4002027c: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
40020280: 22 80 00 37 be,a 4002035c <pthread_mutex_unlock+0x12c>
<== NOT EXECUTED
40020284: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40020288: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002028c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020290: 01 00 00 00 nop
<== NOT EXECUTED
40020294: 81 c7 e0 08 ret
<== NOT EXECUTED
40020298: 91 e8 20 01 restore %g0, 1, %o0
<== NOT EXECUTED
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
4002029c: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
400202a0: 12 bf ff fa bne 40020288 <pthread_mutex_unlock+0x58>
<== NOT EXECUTED
400202a4: 01 00 00 00 nop
<== NOT EXECUTED
nest_level = the_mutex->Recursive.nest_level;
400202a8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
if ( nest_level > 0 ) {
400202ac: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400202b0: 12 80 00 2e bne 40020368 <pthread_mutex_unlock+0x138>
<== NOT EXECUTED
400202b4: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
400202b8: c0 26 20 10 clr [ %i0 + 0x10 ]
<== NOT EXECUTED
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
400202bc: d2 06 20 0c ld [ %i0 + 0xc ], %o1
<== NOT EXECUTED
if ( heads == NULL ) {
400202c0: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
400202c4: 02 80 00 2f be 40020380 <pthread_mutex_unlock+0x150>
<== NOT EXECUTED
400202c8: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
_Thread_queue_Surrender(
400202cc: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
400202d0: 90 06 20 0c add %i0, 0xc, %o0
<== NOT EXECUTED
400202d4: 19 10 01 91 sethi %hi(0x40064400), %o4
<== NOT EXECUTED
400202d8: b0 10 20 00 clr %i0
<== NOT EXECUTED
400202dc: 40 00 16 68 call 40025c7c <_Thread_queue_Surrender>
<== NOT EXECUTED
400202e0: 98 13 23 04 or %o4, 0x304, %o4
<== NOT EXECUTED
);
break;
}
return _POSIX_Get_error( status );
}
400202e4: 81 c7 e0 08 ret
<== NOT EXECUTED
400202e8: 81 e8 00 00 restore
<== NOT EXECUTED
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
400202ec: 7f ff ff aa call 40020194 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
400202f0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400202f4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400202f8: 12 bf ff d9 bne 4002025c <pthread_mutex_unlock+0x2c>
<== NOT EXECUTED
400202fc: 01 00 00 00 nop
<== NOT EXECUTED
40020300: 81 c7 e0 08 ret
<== NOT EXECUTED
40020304: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
40020308: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4002030c: 80 a2 00 01 cmp %o0, %g1
40020310: 12 bf ff de bne 40020288 <pthread_mutex_unlock+0x58>
<== NEVER TAKEN
40020314: 01 00 00 00 nop
nest_level = the_mutex->Recursive.nest_level;
40020318: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
if ( nest_level > 0 ) {
4002031c: 80 a0 60 00 cmp %g1, 0
40020320: 12 80 00 12 bne 40020368 <pthread_mutex_unlock+0x138>
<== NEVER TAKEN
40020324: 82 00 7f ff add %g1, -1, %g1
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40020328: c0 26 20 10 clr [ %i0 + 0x10 ]
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
4002032c: d2 06 20 0c ld [ %i0 + 0xc ], %o1
if ( heads == NULL ) {
40020330: 80 a2 60 00 cmp %o1, 0
40020334: 02 80 00 13 be 40020380 <pthread_mutex_unlock+0x150>
<== ALWAYS TAKEN
40020338: 94 10 00 08 mov %o0, %o2
_Thread_queue_Surrender(
4002033c: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
40020340: 90 06 20 0c add %i0, 0xc, %o0
<== NOT EXECUTED
40020344: 19 10 01 91 sethi %hi(0x40064400), %o4
<== NOT EXECUTED
40020348: b0 10 20 00 clr %i0
<== NOT EXECUTED
4002034c: 40 00 16 4c call 40025c7c <_Thread_queue_Surrender>
<== NOT EXECUTED
40020350: 98 13 23 2c or %o4, 0x32c, %o4
<== NOT EXECUTED
40020354: 81 c7 e0 08 ret
<== NOT EXECUTED
40020358: 81 e8 00 00 restore
<== NOT EXECUTED
return STATUS_NOT_OWNER;
}
nest_level = the_mutex->Recursive.nest_level;
if ( nest_level > 0 ) {
4002035c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40020360: 02 80 00 0d be 40020394 <pthread_mutex_unlock+0x164>
<== NOT EXECUTED
40020364: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
the_mutex->Recursive.nest_level = nest_level - 1;
40020368: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4002036c: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40020370: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020374: 01 00 00 00 nop
<== NOT EXECUTED
40020378: 81 c7 e0 08 ret
<== NOT EXECUTED
4002037c: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40020380: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40020384: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020388: 01 00 00 00 nop
4002038c: 81 c7 e0 08 ret
40020390: 91 e8 20 00 restore %g0, 0, %o0
40020394: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
_Thread_Resource_count_decrement( executing );
_Thread_queue_Context_clear_priority_updates( queue_context );
_Thread_Wait_acquire_default_critical( executing, &lock_context );
_Thread_Priority_remove(
40020398: b6 06 20 20 add %i0, 0x20, %i3
<== NOT EXECUTED
4002039c: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
400203a0: 40 00 13 44 call 400250b0 <_Thread_Priority_remove>
<== NOT EXECUTED
400203a4: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
400203a8: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
400203ac: 82 00 60 01 inc %g1
<== NOT EXECUTED
400203b0: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
);
_Thread_Wait_release_default_critical( executing, &lock_context );
cpu_self = _Thread_queue_Dispatch_disable( queue_context );
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
400203b4: d0 06 20 0c ld [ %i0 + 0xc ], %o0
<== NOT EXECUTED
if ( heads != NULL ) {
400203b8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400203bc: 02 80 00 2a be 40020464 <pthread_mutex_unlock+0x234>
<== NOT EXECUTED
400203c0: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
const Thread_queue_Operations *operations;
Thread_Control *new_owner;
operations = POSIX_MUTEX_PRIORITY_CEILING_TQ_OPERATIONS;
new_owner = ( *operations->first )( heads );
400203c4: 39 10 01 91 sethi %hi(0x40064400), %i4
<== NOT EXECUTED
400203c8: b8 17 23 18 or %i4, 0x318, %i4 ! 40064718 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
400203cc: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
<== NOT EXECUTED
400203d0: 9f c0 40 00 call %g1
<== NOT EXECUTED
400203d4: 01 00 00 00 nop
<== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
400203d8: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
<== NOT EXECUTED
new_owner = ( *operations->first )( heads );
400203dc: b4 10 00 08 mov %o0, %i2
<== NOT EXECUTED
_POSIX_Mutex_Set_owner( the_mutex, new_owner );
_Thread_Resource_count_increment( new_owner );
_Thread_Priority_add(
400203e0: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
400203e4: 40 00 13 2e call 4002509c <_Thread_Priority_add>
<== NOT EXECUTED
400203e8: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
new_owner,
&the_mutex->Priority_ceiling,
queue_context
);
_Thread_queue_Extract_critical(
400203ec: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
400203f0: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
400203f4: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
400203f8: 40 00 15 e0 call 40025b78 <_Thread_queue_Extract_critical>
<== NOT EXECUTED
400203fc: 90 06 20 0c add %i0, 0xc, %o0
<== NOT EXECUTED
} else {
_POSIX_Mutex_Set_owner( the_mutex, NULL );
_POSIX_Mutex_Release( the_mutex, queue_context );
}
_Thread_Priority_update( queue_context );
40020400: 40 00 13 31 call 400250c4 <_Thread_Priority_update>
<== NOT EXECUTED
40020404: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
40020408: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4002040c: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
40020410: 02 80 00 06 be 40020428 <pthread_mutex_unlock+0x1f8>
<== NOT EXECUTED
40020414: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
40020418: b0 10 20 00 clr %i0
<== NOT EXECUTED
4002041c: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
40020420: 81 c7 e0 08 ret
<== NOT EXECUTED
40020424: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40020428: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4002042c: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
<== NOT EXECUTED
40020430: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40020434: 12 80 00 07 bne 40020450 <pthread_mutex_unlock+0x220>
<== NOT EXECUTED
40020438: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4002043c: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40020440: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020444: 01 00 00 00 nop
<== NOT EXECUTED
40020448: 81 c7 e0 08 ret
<== NOT EXECUTED
4002044c: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
40020450: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
40020454: 40 00 13 78 call 40025234 <_Thread_Do_dispatch>
<== NOT EXECUTED
40020458: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4002045c: 10 bf ff f9 b 40020440 <pthread_mutex_unlock+0x210>
<== NOT EXECUTED
40020460: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40020464: c0 26 20 10 clr [ %i0 + 0x10 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40020468: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002046c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020470: 01 00 00 00 nop
<== NOT EXECUTED
40020474: 30 bf ff e3 b,a 40020400 <pthread_mutex_unlock+0x1d0>
<== NOT EXECUTED
40010d30 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
40010d30: 80 a2 20 00 cmp %o0, 0
40010d34: 02 80 00 07 be 40010d50 <pthread_once+0x20>
<== NEVER TAKEN
40010d38: 80 a2 60 00 cmp %o1, 0
40010d3c: 02 80 00 05 be 40010d50 <pthread_once+0x20>
<== NEVER TAKEN
40010d40: 01 00 00 00 nop
return EINVAL;
return _Once( &once_control->_flags, init_routine );
40010d44: 82 13 c0 00 mov %o7, %g1
40010d48: 40 00 03 b4 call 40011c18 <_Once>
40010d4c: 9e 10 40 00 mov %g1, %o7
}
40010d50: 81 c3 e0 08 retl
<== NOT EXECUTED
40010d54: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
40020ea8 <pthread_setspecific>:
int pthread_setspecific(
pthread_key_t key,
const void *value
)
{
40020ea8: 9d e3 bf 98 save %sp, -104, %sp
40020eac: ba 10 00 18 mov %i0, %i5
Thread_Control *executing;
int eno;
executing = _Thread_Get_executing();
if ( value != NULL ) {
40020eb0: 80 a6 60 00 cmp %i1, 0
40020eb4: 02 80 00 52 be 40020ffc <pthread_setspecific+0x154>
40020eb8: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40020ebc: 91 d0 20 09 ta 9
<== NOT EXECUTED
return &RB_ROOT( the_rbtree );
40020ec0: b6 07 21 60 add %i4, 0x160, %i3
link = _RBTree_Root_const_reference( the_rbtree );
40020ec4: 86 10 00 1b mov %i3, %g3
while ( *link != NULL ) {
40020ec8: c4 00 c0 00 ld [ %g3 ], %g2
40020ecc: 80 a0 a0 00 cmp %g2, 0
40020ed0: 02 80 00 0d be 40020f04 <pthread_setspecific+0x5c>
40020ed4: 86 00 bf f8 add %g2, -8, %g3
return *the_left == the_right->key;
40020ed8: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
if ( ( *equal )( key, parent ) ) {
40020edc: 80 a7 40 04 cmp %i5, %g4
40020ee0: 22 80 00 31 be,a 40020fa4 <pthread_setspecific+0xfc>
<== NEVER TAKEN
40020ee4: f2 20 e0 20 st %i1, [ %g3 + 0x20 ]
<== NOT EXECUTED
} else if ( ( *less )( key, parent ) ) {
40020ee8: 1a bf ff f8 bcc 40020ec8 <pthread_setspecific+0x20>
<== ALWAYS TAKEN
40020eec: 86 00 a0 04 add %g2, 4, %g3
return &RB_LEFT( the_node, Node );
40020ef0: 86 10 00 02 mov %g2, %g3
<== NOT EXECUTED
while ( *link != NULL ) {
40020ef4: c4 00 c0 00 ld [ %g3 ], %g2
<== NOT EXECUTED
40020ef8: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40020efc: 12 bf ff f7 bne 40020ed8 <pthread_setspecific+0x30>
<== NOT EXECUTED
40020f00: 86 00 bf f8 add %g2, -8, %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40020f04: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020f08: 01 00 00 00 nop
_RTEMS_Lock_allocator();
40020f0c: 40 00 05 8b call 40022538 <_RTEMS_Lock_allocator>
40020f10: b0 10 20 16 mov 0x16, %i0 ! 16 <_TLS_Alignment+0x15>
return (POSIX_Keys_Control *)
40020f14: 90 10 00 1d mov %i5, %o0
40020f18: 13 10 01 66 sethi %hi(0x40059800), %o1
40020f1c: 40 00 0f 3c call 40024c0c <_Objects_Get_no_protection>
40020f20: 92 12 60 f4 or %o1, 0xf4, %o1 ! 400598f4 <_POSIX_Keys_Information>
if ( the_key != NULL ) {
40020f24: b4 92 20 00 orcc %o0, 0, %i2
40020f28: 02 80 00 31 be 40020fec <pthread_setspecific+0x144>
<== NEVER TAKEN
40020f2c: 01 00 00 00 nop
key_value_pair = _POSIX_Keys_Key_value_allocate();
40020f30: 7f ff ff ce call 40020e68 <_POSIX_Keys_Key_value_allocate>
40020f34: b0 10 20 0c mov 0xc, %i0 ! c <_TLS_Alignment+0xb>
if ( key_value_pair != NULL ) {
40020f38: 80 a2 20 00 cmp %o0, 0
40020f3c: 02 80 00 2c be 40020fec <pthread_setspecific+0x144>
<== NEVER TAKEN
40020f40: 88 10 00 08 mov %o0, %g4
<== NOT EXECUTED
old_last = tail->previous;
40020f44: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
<== NOT EXECUTED
return &the_chain->Tail.Node;
40020f48: 84 06 a0 18 add %i2, 0x18, %g2
<== NOT EXECUTED
key_value_pair->key = key;
40020f4c: fa 22 20 18 st %i5, [ %o0 + 0x18 ]
<== NOT EXECUTED
_RBTree_Initialize_node( &key_value_pair->Lookup_node );
40020f50: b0 02 20 08 add %o0, 8, %i0
<== NOT EXECUTED
key_value_pair->thread = executing;
40020f54: f8 22 20 1c st %i4, [ %o0 + 0x1c ]
<== NOT EXECUTED
key_value_pair->value = RTEMS_DECONST( void *, value );
40020f58: f2 22 20 20 st %i1, [ %o0 + 0x20 ]
<== NOT EXECUTED
the_node->next = tail;
40020f5c: c4 22 00 00 st %g2, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
40020f60: d0 26 a0 1c st %o0, [ %i2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40020f64: d0 20 40 00 st %o0, [ %g1 ]
<== NOT EXECUTED
the_node->previous = old_last;
40020f68: c2 22 20 04 st %g1, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40020f6c: 91 d0 20 09 ta 9
<== NOT EXECUTED
parent = NULL;
40020f70: b8 10 20 00 clr %i4
link = _RBTree_Root_reference( the_rbtree );
40020f74: 86 10 00 1b mov %i3, %g3
while ( *link != NULL ) {
40020f78: c4 00 c0 00 ld [ %g3 ], %g2
40020f7c: 80 a0 a0 00 cmp %g2, 0
40020f80: 22 80 00 41 be,a 40021084 <pthread_setspecific+0x1dc>
40020f84: f8 21 20 10 st %i4, [ %g4 + 0x10 ]
if ( ( *less )( key, parent ) ) {
40020f88: f8 00 a0 10 ld [ %g2 + 0x10 ], %i4
40020f8c: 80 a7 40 1c cmp %i5, %i4
40020f90: 1a 80 00 03 bcc 40020f9c <pthread_setspecific+0xf4>
<== ALWAYS TAKEN
40020f94: 86 00 a0 04 add %g2, 4, %g3
return &RB_LEFT( the_node, Node );
40020f98: 86 10 00 02 mov %g2, %g3
<== NOT EXECUTED
link = _RBTree_Root_const_reference( the_rbtree );
40020f9c: 10 bf ff f7 b 40020f78 <pthread_setspecific+0xd0>
40020fa0: b8 10 00 02 mov %g2, %i4
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40020fa4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020fa8: 01 00 00 00 nop
<== NOT EXECUTED
} else {
eno = _POSIX_Keys_Delete_value( key, executing );
}
return eno;
}
40020fac: 81 c7 e0 08 ret
<== NOT EXECUTED
40020fb0: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
_RBTree_Extract(
40020fb4: 40 00 0f c7 call 40024ed0 <_RBTree_Extract>
40020fb8: c2 27 bf fc st %g1, [ %fp + -4 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40020fbc: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40020fc0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40020fc4: 01 00 00 00 nop
next = the_node->next;
40020fc8: c4 07 00 00 ld [ %i4 ], %g2
previous = the_node->previous;
40020fcc: c2 07 20 04 ld [ %i4 + 4 ], %g1
next->previous = previous;
40020fd0: c2 20 a0 04 st %g1, [ %g2 + 4 ]
_Freechain_Put( &_POSIX_Keys_Keypool, key_value_pair );
40020fd4: 11 10 01 66 sethi %hi(0x40059800), %o0
previous->next = next;
40020fd8: c4 20 40 00 st %g2, [ %g1 ]
40020fdc: 92 10 00 1c mov %i4, %o1
eno = 0;
40020fe0: b0 10 20 00 clr %i0
40020fe4: 40 00 05 b6 call 400226bc <_Freechain_Put>
40020fe8: 90 12 21 30 or %o0, 0x130, %o0
_RTEMS_Unlock_allocator();
40020fec: 40 00 05 58 call 4002254c <_RTEMS_Unlock_allocator>
40020ff0: 01 00 00 00 nop
return eno;
40020ff4: 81 c7 e0 08 ret
40020ff8: 81 e8 00 00 restore
_RTEMS_Lock_allocator();
40020ffc: 40 00 05 4f call 40022538 <_RTEMS_Lock_allocator>
40021000: 01 00 00 00 nop
return (POSIX_Keys_Control *)
40021004: 90 10 00 18 mov %i0, %o0
40021008: 13 10 01 66 sethi %hi(0x40059800), %o1
eno = EINVAL;
4002100c: b0 10 20 16 mov 0x16, %i0
40021010: 40 00 0e ff call 40024c0c <_Objects_Get_no_protection>
40021014: 92 12 60 f4 or %o1, 0xf4, %o1
if ( the_key != NULL ) {
40021018: 80 a2 20 00 cmp %o0, 0
4002101c: 02 bf ff f4 be 40020fec <pthread_setspecific+0x144>
<== NEVER TAKEN
40021020: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40021024: 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(
40021028: 90 07 21 60 add %i4, 0x160, %o0
4002102c: 84 10 00 08 mov %o0, %g2
while ( *link != NULL ) {
40021030: d2 00 80 00 ld [ %g2 ], %o1
40021034: 80 a2 60 00 cmp %o1, 0
40021038: 02 80 00 0d be 4002106c <pthread_setspecific+0x1c4>
<== NEVER TAKEN
4002103c: b8 02 7f f8 add %o1, -8, %i4
return *the_left == the_right->key;
40021040: c4 07 20 18 ld [ %i4 + 0x18 ], %g2
if ( ( *equal )( key, parent ) ) {
40021044: 80 a7 40 02 cmp %i5, %g2
40021048: 02 bf ff db be 40020fb4 <pthread_setspecific+0x10c>
4002104c: 01 00 00 00 nop
} else if ( ( *less )( key, parent ) ) {
40021050: 1a bf ff f8 bcc 40021030 <pthread_setspecific+0x188>
<== ALWAYS TAKEN
40021054: 84 02 60 04 add %o1, 4, %g2
return &RB_LEFT( the_node, Node );
40021058: 84 10 00 09 mov %o1, %g2
<== NOT EXECUTED
while ( *link != NULL ) {
4002105c: d2 00 80 00 ld [ %g2 ], %o1
<== NOT EXECUTED
40021060: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
40021064: 12 bf ff f7 bne 40021040 <pthread_setspecific+0x198>
<== NOT EXECUTED
40021068: b8 02 7f f8 add %o1, -8, %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002106c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40021070: 01 00 00 00 nop
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
40021074: 40 00 05 36 call 4002254c <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40021078: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
return eno;
4002107c: 81 c7 e0 08 ret
<== NOT EXECUTED
40021080: 81 e8 00 00 restore
<== NOT EXECUTED
RB_SET( child, parent, Node );
40021084: 84 10 20 01 mov 1, %g2
40021088: c0 21 20 0c clr [ %g4 + 0xc ]
_RBTree_Insert_color( the_rbtree, the_node );
4002108c: 92 10 00 18 mov %i0, %o1
RB_SET( child, parent, Node );
40021090: c0 21 20 08 clr [ %g4 + 8 ]
_RBTree_Insert_color( the_rbtree, the_node );
40021094: 90 10 00 1b mov %i3, %o0
RB_SET( child, parent, Node );
40021098: c4 21 20 14 st %g2, [ %g4 + 0x14 ]
*link = child;
4002109c: f0 20 c0 00 st %i0, [ %g3 ]
_RBTree_Insert_color( the_rbtree, the_node );
400210a0: 40 00 10 ee call 40025458 <_RBTree_Insert_color>
400210a4: c2 27 bf fc st %g1, [ %fp + -4 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400210a8: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400210ac: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400210b0: 01 00 00 00 nop
eno = 0;
400210b4: 10 bf ff ce b 40020fec <pthread_setspecific+0x144>
400210b8: b0 10 20 00 clr %i0 ! 0 <PROM_START>
4003d9a8 <sigaction>:
int sigaction(
int sig,
const struct sigaction *__restrict act,
struct sigaction *__restrict oact
)
{
4003d9a8: 9d e3 bf 98 save %sp, -104, %sp
Thread_queue_Context queue_context;
if ( !sig )
4003d9ac: 80 a6 20 00 cmp %i0, 0
4003d9b0: 02 80 00 43 be 4003dabc <sigaction+0x114>
<== NEVER TAKEN
4003d9b4: 82 06 3f ff add %i0, -1, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
4003d9b8: 80 a0 60 1f cmp %g1, 0x1f
4003d9bc: 18 80 00 40 bgu 4003dabc <sigaction+0x114>
<== NEVER TAKEN
4003d9c0: 80 a6 20 09 cmp %i0, 9
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
4003d9c4: 02 80 00 3e be 4003dabc <sigaction+0x114>
<== NEVER TAKEN
4003d9c8: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4003d9cc: 91 d0 20 09 ta 9
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_queue_Context_initialize( &queue_context );
_POSIX_signals_Acquire( &queue_context );
if ( oact )
4003d9d0: 80 a6 a0 00 cmp %i2, 0
4003d9d4: 02 80 00 0d be 4003da08 <sigaction+0x60>
<== NEVER TAKEN
4003d9d8: 85 2e 20 01 sll %i0, 1, %g2
*oact = _POSIX_signals_Vectors[ sig ];
4003d9dc: 07 10 01 c1 sethi %hi(0x40070400), %g3
4003d9e0: 84 00 80 18 add %g2, %i0, %g2
4003d9e4: 86 10 e2 ec or %g3, 0x2ec, %g3
4003d9e8: 85 28 a0 02 sll %g2, 2, %g2
4003d9ec: fa 00 c0 02 ld [ %g3 + %g2 ], %i5
4003d9f0: 88 00 c0 02 add %g3, %g2, %g4
4003d9f4: c6 01 20 04 ld [ %g4 + 4 ], %g3
4003d9f8: c4 01 20 08 ld [ %g4 + 8 ], %g2
4003d9fc: fa 26 80 00 st %i5, [ %i2 ]
4003da00: c6 26 a0 04 st %g3, [ %i2 + 4 ]
4003da04: c4 26 a0 08 st %g2, [ %i2 + 8 ]
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
4003da08: 80 a6 60 00 cmp %i1, 0
4003da0c: 02 80 00 16 be 4003da64 <sigaction+0xbc>
<== NEVER TAKEN
4003da10: 01 00 00 00 nop
/*
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
if ( act->sa_handler == SIG_DFL ) {
4003da14: c4 06 60 08 ld [ %i1 + 8 ], %g2
4003da18: 80 a0 a0 00 cmp %g2, 0
4003da1c: 02 80 00 16 be 4003da74 <sigaction+0xcc>
<== NEVER TAKEN
4003da20: 85 2e 20 01 sll %i0, 1, %g2
4003da24: c2 27 bf fc st %g1, [ %fp + -4 ]
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
4003da28: 40 00 10 cc call 40041d58 <_POSIX_signals_Clear_process_signals>
4003da2c: 90 10 00 18 mov %i0, %o0
_POSIX_signals_Vectors[ sig ] = *act;
4003da30: 87 2e 20 01 sll %i0, 1, %g3
<== NOT EXECUTED
4003da34: fa 06 40 00 ld [ %i1 ], %i5
<== NOT EXECUTED
4003da38: b0 00 c0 18 add %g3, %i0, %i0
<== NOT EXECUTED
4003da3c: 05 10 01 c1 sethi %hi(0x40070400), %g2
<== NOT EXECUTED
4003da40: b1 2e 20 02 sll %i0, 2, %i0
<== NOT EXECUTED
4003da44: 84 10 a2 ec or %g2, 0x2ec, %g2
<== NOT EXECUTED
4003da48: c8 06 60 04 ld [ %i1 + 4 ], %g4
<== NOT EXECUTED
4003da4c: fa 20 80 18 st %i5, [ %g2 + %i0 ]
<== NOT EXECUTED
4003da50: b0 00 80 18 add %g2, %i0, %i0
<== NOT EXECUTED
4003da54: c6 06 60 08 ld [ %i1 + 8 ], %g3
<== NOT EXECUTED
4003da58: c8 26 20 04 st %g4, [ %i0 + 4 ]
<== NOT EXECUTED
4003da5c: c6 26 20 08 st %g3, [ %i0 + 8 ]
<== NOT EXECUTED
4003da60: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4003da64: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4003da68: 01 00 00 00 nop
}
_POSIX_signals_Release( &queue_context );
return 0;
}
4003da6c: 81 c7 e0 08 ret
4003da70: 91 e8 20 00 restore %g0, 0, %o0
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
4003da74: 07 10 01 99 sethi %hi(0x40066400), %g3
<== NOT EXECUTED
4003da78: b0 00 80 18 add %g2, %i0, %i0
<== NOT EXECUTED
4003da7c: 86 10 e0 c4 or %g3, 0xc4, %g3
<== NOT EXECUTED
4003da80: b1 2e 20 02 sll %i0, 2, %i0
<== NOT EXECUTED
4003da84: fa 00 c0 18 ld [ %g3 + %i0 ], %i5
<== NOT EXECUTED
4003da88: 05 10 01 c1 sethi %hi(0x40070400), %g2
<== NOT EXECUTED
4003da8c: 86 00 c0 18 add %g3, %i0, %g3
<== NOT EXECUTED
4003da90: 84 10 a2 ec or %g2, 0x2ec, %g2
<== NOT EXECUTED
4003da94: c8 00 e0 04 ld [ %g3 + 4 ], %g4
<== NOT EXECUTED
4003da98: fa 20 80 18 st %i5, [ %g2 + %i0 ]
<== NOT EXECUTED
4003da9c: b0 00 80 18 add %g2, %i0, %i0
<== NOT EXECUTED
4003daa0: c6 00 e0 08 ld [ %g3 + 8 ], %g3
<== NOT EXECUTED
4003daa4: c8 26 20 04 st %g4, [ %i0 + 4 ]
<== NOT EXECUTED
4003daa8: c6 26 20 08 st %g3, [ %i0 + 8 ]
<== NOT EXECUTED
4003daac: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4003dab0: 01 00 00 00 nop
<== NOT EXECUTED
}
4003dab4: 81 c7 e0 08 ret
<== NOT EXECUTED
4003dab8: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
4003dabc: 40 00 11 b6 call 40042194 <__errno>
<== NOT EXECUTED
4003dac0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4003dac4: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4003dac8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4003dacc: 81 c7 e0 08 ret
<== NOT EXECUTED
4003dad0: 81 e8 00 00 restore
<== NOT EXECUTED
40011c80 <sigemptyset>:
#include <rtems/seterr.h>
int sigemptyset(
sigset_t *set
)
{
40011c80: 9d e3 bf a0 save %sp, -96, %sp
if ( !set )
40011c84: 80 a6 20 00 cmp %i0, 0
40011c88: 02 80 00 05 be 40011c9c <sigemptyset+0x1c>
<== NEVER TAKEN
40011c8c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
*set = 0;
40011c90: c0 26 00 00 clr [ %i0 ]
return 0;
}
40011c94: 81 c7 e0 08 ret
40011c98: 91 e8 20 00 restore %g0, 0, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
40011c9c: 40 00 23 36 call 4001a974 <__errno>
<== NOT EXECUTED
40011ca0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40011ca4: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40011ca8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40011cac: 81 c7 e0 08 ret
<== NOT EXECUTED
40011cb0: 81 e8 00 00 restore
<== NOT EXECUTED