RTEMS-5
Annotated Report
Fri Aug 10 13:28:33 2018
40005c74 <_POSIX_Condition_variables_Auto_initialization>:
#include <string.h>
bool _POSIX_Condition_variables_Auto_initialization(
POSIX_Condition_variables_Control *the_cond
)
{
40005c74: 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 ) {
40005c78: 94 10 20 1c mov 0x1c, %o2
<== NOT EXECUTED
memset( &zero, 0, sizeof( zero ) );
40005c7c: c0 27 bf e4 clr [ %fp + -28 ]
<== NOT EXECUTED
if ( memcmp( the_cond, &zero, sizeof( *the_cond ) ) != 0 ) {
40005c80: 92 07 bf e4 add %fp, -28, %o1
<== NOT EXECUTED
memset( &zero, 0, sizeof( zero ) );
40005c84: c0 27 bf e8 clr [ %fp + -24 ]
<== NOT EXECUTED
if ( memcmp( the_cond, &zero, sizeof( *the_cond ) ) != 0 ) {
40005c88: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
memset( &zero, 0, sizeof( zero ) );
40005c8c: c0 27 bf ec clr [ %fp + -20 ]
<== NOT EXECUTED
40005c90: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
40005c94: c0 27 bf f4 clr [ %fp + -12 ]
<== NOT EXECUTED
40005c98: c0 27 bf f8 clr [ %fp + -8 ]
<== NOT EXECUTED
if ( memcmp( the_cond, &zero, sizeof( *the_cond ) ) != 0 ) {
40005c9c: 40 00 20 68 call 4000de3c <memcmp>
<== NOT EXECUTED
40005ca0: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
40005ca4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005ca8: 12 80 00 08 bne 40005cc8 <_POSIX_Condition_variables_Auto_initialization+0x54>
<== NOT EXECUTED
40005cac: 82 10 20 00 clr %g1
<== NOT EXECUTED
return false;
}
flags = (uintptr_t) the_cond ^ POSIX_CONDITION_VARIABLES_MAGIC;
40005cb0: 03 06 37 ec sethi %hi(0x18dfb000), %g1
<== NOT EXECUTED
40005cb4: 82 10 61 fe or %g1, 0x1fe, %g1 ! 18dfb1fe <RAM_SIZE+0x189fb1fe>
<== NOT EXECUTED
40005cb8: 82 1e 00 01 xor %i0, %g1, %g1
<== NOT EXECUTED
flags &= ~POSIX_CONDITION_VARIABLES_FLAGS_MASK;
40005cbc: 82 08 7f fe and %g1, -2, %g1
<== NOT EXECUTED
the_cond->flags = flags;
40005cc0: c2 26 00 00 st %g1, [ %i0 ]
<== NOT EXECUTED
return true;
40005cc4: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
}
40005cc8: b0 08 60 01 and %g1, 1, %i0
<== NOT EXECUTED
40005ccc: 81 c7 e0 08 ret
<== NOT EXECUTED
40005cd0: 81 e8 00 00 restore
<== NOT EXECUTED
4000fb40 <_POSIX_Condition_variables_Default_attributes>:
4000fb40: 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 01 ................
...
40005b94 <_POSIX_Condition_variables_Signal_support>:
int _POSIX_Condition_variables_Signal_support(
pthread_cond_t *cond,
bool is_broadcast
)
{
40005b94: 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 );
40005b98: 80 a6 20 00 cmp %i0, 0
40005b9c: 02 80 00 28 be 40005c3c <_POSIX_Condition_variables_Signal_support+0xa8>
<== NEVER TAKEN
40005ba0: 05 06 37 ec sethi %hi(0x18dfb000), %g2
40005ba4: c2 06 00 00 ld [ %i0 ], %g1
40005ba8: 82 1e 00 01 xor %i0, %g1, %g1
40005bac: 84 10 a1 fe or %g2, 0x1fe, %g2
40005bb0: 82 18 40 02 xor %g1, %g2, %g1
40005bb4: 80 88 7f fe btst -2, %g1
40005bb8: 12 80 00 1c bne 40005c28 <_POSIX_Condition_variables_Signal_support+0x94>
<== NEVER TAKEN
40005bbc: 3b 10 00 3e sethi %hi(0x4000f800), %i5
<== NOT EXECUTED
if ( heads != NULL ) {
Thread_Control *the_thread;
the_thread = ( *operations->first )( heads );
_Thread_queue_Extract_critical(
40005bc0: b8 06 20 0c add %i0, 0xc, %i4
<== NOT EXECUTED
the_thread = ( *operations->first )( heads );
40005bc4: ba 17 61 fc or %i5, 0x1fc, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005bc8: 91 d0 20 09 ta 9
<== NOT EXECUTED
)
{
#if defined( RTEMS_SMP )
context->Lock_context.isr_level = level;
#else
context->isr_level = level;
40005bcc: c2 27 bf dc st %g1, [ %fp + -36 ]
heads = the_cond->Queue.Queue.heads;
40005bd0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
if ( heads != NULL ) {
40005bd4: 90 90 60 00 orcc %g1, 0, %o0
40005bd8: 22 80 00 0f be,a 40005c14 <_POSIX_Condition_variables_Signal_support+0x80>
40005bdc: c0 26 20 18 clr [ %i0 + 0x18 ]
the_thread = ( *operations->first )( heads );
40005be0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40005be4: 9f c0 40 00 call %g1
40005be8: 01 00 00 00 nop
_Thread_queue_Extract_critical(
40005bec: 96 07 bf dc add %fp, -36, %o3
40005bf0: 94 10 00 08 mov %o0, %o2
40005bf4: 92 10 00 1d mov %i5, %o1
40005bf8: 40 00 10 17 call 40009c54 <_Thread_queue_Extract_critical>
40005bfc: 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 );
40005c00: 80 a6 60 00 cmp %i1, 0
40005c04: 12 bf ff f1 bne 40005bc8 <_POSIX_Condition_variables_Signal_support+0x34>
40005c08: 01 00 00 00 nop
return 0;
}
40005c0c: 81 c7 e0 08 ret
40005c10: 91 e8 20 00 restore %g0, 0, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40005c14: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005c18: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005c1c: 01 00 00 00 nop
40005c20: 81 c7 e0 08 ret
40005c24: 91 e8 20 00 restore %g0, 0, %o0
POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
40005c28: 40 00 00 07 call 40005c44 <_POSIX_Condition_variables_Auto_initialization>
<== NOT EXECUTED
40005c2c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40005c30: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005c34: 12 bf ff e3 bne 40005bc0 <_POSIX_Condition_variables_Signal_support+0x2c>
<== NOT EXECUTED
40005c38: 3b 10 00 3e sethi %hi(0x4000f800), %i5
<== NOT EXECUTED
40005c3c: 81 c7 e0 08 ret
<== NOT EXECUTED
40005c40: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
40005e18 <_POSIX_Condition_variables_Wait_support>:
int _POSIX_Condition_variables_Wait_support(
pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
40005e18: 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 );
40005e1c: 80 a6 20 00 cmp %i0, 0
40005e20: 02 80 00 44 be 40005f30 <_POSIX_Condition_variables_Wait_support+0x118>
<== NEVER TAKEN
40005e24: 05 06 37 ec sethi %hi(0x18dfb000), %g2
40005e28: fa 06 00 00 ld [ %i0 ], %i5
40005e2c: 82 1e 00 1d xor %i0, %i5, %g1
40005e30: 84 10 a1 fe or %g2, 0x1fe, %g2
40005e34: 82 18 40 02 xor %g1, %g2, %g1
40005e38: 80 88 7f fe btst -2, %g1
40005e3c: 12 80 00 38 bne 40005f1c <_POSIX_Condition_variables_Wait_support+0x104>
<== NEVER TAKEN
40005e40: 80 a6 a0 00 cmp %i2, 0
_Thread_queue_Context_initialize( &queue_context );
if ( abstime != NULL ) {
40005e44: 02 80 00 3d be 40005f38 <_POSIX_Condition_variables_Wait_support+0x120>
40005e48: 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 ) {
40005e4c: 12 80 00 13 bne 40005e98 <_POSIX_Condition_variables_Wait_support+0x80>
<== NEVER TAKEN
40005e50: f4 27 bf e8 st %i2, [ %fp + -24 ]
<== NOT EXECUTED
queue_context->enqueue_callout = enqueue_callout;
40005e54: 03 10 00 17 sethi %hi(0x40005c00), %g1
<== NOT EXECUTED
40005e58: 82 10 61 d8 or %g1, 0x1d8, %g1 ! 40005dd8 <_POSIX_Condition_variables_Enqueue_with_timeout_realtime>
<== NOT EXECUTED
40005e5c: c2 27 bf e4 st %g1, [ %fp + -28 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005e60: 91 d0 20 09 ta 9
<== NOT EXECUTED
40005e64: 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
40005e68: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
&& the_cond->mutex != mutex
40005e6c: 80 a0 40 19 cmp %g1, %i1
40005e70: 02 80 00 13 be 40005ebc <_POSIX_Condition_variables_Wait_support+0xa4>
40005e74: 84 10 00 06 mov %g6, %g2
40005e78: 80 a0 60 00 cmp %g1, 0
40005e7c: 22 80 00 11 be,a 40005ec0 <_POSIX_Condition_variables_Wait_support+0xa8>
<== ALWAYS TAKEN
40005e80: fa 00 a0 20 ld [ %g2 + 0x20 ], %i5
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40005e84: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005e88: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005e8c: 01 00 00 00 nop
<== NOT EXECUTED
) {
_POSIX_Condition_variables_Release( the_cond, &queue_context );
return EINVAL;
40005e90: 81 c7 e0 08 ret
<== NOT EXECUTED
40005e94: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
40005e98: 03 10 00 17 sethi %hi(0x40005c00), %g1
<== NOT EXECUTED
40005e9c: 82 10 61 f8 or %g1, 0x1f8, %g1 ! 40005df8 <_POSIX_Condition_variables_Enqueue_with_timeout_monotonic>
<== NOT EXECUTED
40005ea0: c2 27 bf e4 st %g1, [ %fp + -28 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005ea4: 91 d0 20 09 ta 9
<== NOT EXECUTED
40005ea8: c2 27 bf dc st %g1, [ %fp + -36 ]
<== NOT EXECUTED
the_cond->mutex != POSIX_CONDITION_VARIABLES_NO_MUTEX
40005eac: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
&& the_cond->mutex != mutex
40005eb0: 80 a0 40 19 cmp %g1, %i1
<== NOT EXECUTED
40005eb4: 12 bf ff f1 bne 40005e78 <_POSIX_Condition_variables_Wait_support+0x60>
<== NOT EXECUTED
40005eb8: 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;
40005ebc: fa 00 a0 20 ld [ %g2 + 0x20 ], %i5
}
the_cond->mutex = mutex;
40005ec0: f2 26 20 18 st %i1, [ %i0 + 0x18 ]
queue_context->thread_state = thread_state;
40005ec4: 82 10 20 20 mov 0x20, %g1
_Thread_queue_Context_set_thread_state(
&queue_context,
STATES_WAITING_FOR_CONDITION_VARIABLE
);
_Thread_queue_Enqueue(
40005ec8: 90 06 20 0c add %i0, 0xc, %o0
40005ecc: 96 07 bf dc add %fp, -36, %o3
40005ed0: c2 27 bf e0 st %g1, [ %fp + -32 ]
40005ed4: 94 10 00 1d mov %i5, %o2
40005ed8: 13 10 00 42 sethi %hi(0x40010800), %o1
40005edc: 40 00 14 5a call 4000b044 <_Thread_queue_Enqueue>
40005ee0: 92 12 61 0c or %o1, 0x10c, %o1 ! 4001090c <_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 );
40005ee4: f0 07 60 4c ld [ %i5 + 0x4c ], %i0
40005ee8: 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 ) {
40005eec: 80 a6 20 04 cmp %i0, 4
40005ef0: 02 80 00 18 be 40005f50 <_POSIX_Condition_variables_Wait_support+0x138>
<== NEVER TAKEN
40005ef4: 80 a6 20 01 cmp %i0, 1
/*
* When we get here the dispatch disable level is 0.
*/
if ( error != EPERM ) {
40005ef8: 02 80 00 14 be 40005f48 <_POSIX_Condition_variables_Wait_support+0x130>
<== NEVER TAKEN
40005efc: 01 00 00 00 nop
int mutex_error;
mutex_error = pthread_mutex_lock( mutex );
40005f00: 40 00 00 f0 call 400062c0 <pthread_mutex_lock>
40005f04: 90 10 00 19 mov %i1, %o0
if ( mutex_error != 0 ) {
40005f08: 80 a2 20 00 cmp %o0, 0
40005f0c: 12 80 00 09 bne 40005f30 <_POSIX_Condition_variables_Wait_support+0x118>
<== NEVER TAKEN
40005f10: 01 00 00 00 nop
error = EINVAL;
}
}
return error;
}
40005f14: 81 c7 e0 08 ret
40005f18: 81 e8 00 00 restore
POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
40005f1c: 7f ff ff 85 call 40005d30 <_POSIX_Condition_variables_Auto_initialization>
<== NOT EXECUTED
40005f20: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40005f24: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005f28: 12 bf ff c7 bne 40005e44 <_POSIX_Condition_variables_Wait_support+0x2c>
<== NOT EXECUTED
40005f2c: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
}
40005f30: 81 c7 e0 08 ret
<== NOT EXECUTED
40005f34: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
queue_context->enqueue_callout = enqueue_callout;
40005f38: 03 10 00 17 sethi %hi(0x40005c00), %g1
40005f3c: 82 10 61 cc or %g1, 0x1cc, %g1 ! 40005dcc <_POSIX_Condition_variables_Enqueue_no_timeout>
40005f40: 10 bf ff c8 b 40005e60 <_POSIX_Condition_variables_Wait_support+0x48>
40005f44: c2 27 bf e4 st %g1, [ %fp + -28 ]
40005f48: 81 c7 e0 08 ret
<== NOT EXECUTED
40005f4c: 81 e8 00 00 restore
<== NOT EXECUTED
error = 0;
40005f50: 10 bf ff ec b 40005f00 <_POSIX_Condition_variables_Wait_support+0xe8>
<== NOT EXECUTED
40005f54: b0 10 20 00 clr %i0
<== NOT EXECUTED
40011a78 <_POSIX_Get_by_name_error_table>:
40011a78: 00 00 00 16 00 00 00 5b 00 00 00 02 .......[....
40005e88 <_POSIX_Keys_Key_value_allocate>:
uint32_t max = Configuration.maximum_key_value_pairs;
40005e88: 03 10 00 3d sethi %hi(0x4000f400), %g1
40005e8c: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 ! 4000f4b0 <Configuration+0x10>
_Objects_Maximum_per_allocation( max ) : 0;
40005e90: 80 a0 60 00 cmp %g1, 0
40005e94: 16 80 00 05 bge 40005ea8 <_POSIX_Keys_Key_value_allocate+0x20>
<== ALWAYS TAKEN
40005e98: 94 10 20 00 clr %o2
40005e9c: 15 00 00 3f sethi %hi(0xfc00), %o2
<== NOT EXECUTED
40005ea0: 94 12 a3 ff or %o2, 0x3ff, %o2 ! ffff <_Configuration_Interrupt_stack_size+0xefff>
<== NOT EXECUTED
40005ea4: 94 08 40 0a and %g1, %o2, %o2
<== NOT EXECUTED
return (POSIX_Keys_Key_value_pair *) _Freechain_Get(
40005ea8: 13 10 00 2c sethi %hi(0x4000b000), %o1
40005eac: 11 10 00 49 sethi %hi(0x40012400), %o0
40005eb0: 96 10 20 24 mov 0x24, %o3
40005eb4: 92 12 61 cc or %o1, 0x1cc, %o1
40005eb8: 90 12 23 7c or %o0, 0x37c, %o0
40005ebc: 82 13 c0 00 mov %o7, %g1
40005ec0: 40 00 01 4e call 400063f8 <_Freechain_Get>
40005ec4: 9e 10 40 00 mov %g1, %o7
40006198 <_POSIX_Message_queue_Delete>:
void _POSIX_Message_queue_Delete(
POSIX_Message_queue_Control *the_mq,
Thread_queue_Context *queue_context
)
{
40006198: 9d e3 bf a0 save %sp, -96, %sp
if ( !the_mq->linked && the_mq->open_count == 0 ) {
4000619c: c2 0e 20 4c ldub [ %i0 + 0x4c ], %g1
400061a0: 80 a0 60 00 cmp %g1, 0
400061a4: 12 80 00 06 bne 400061bc <_POSIX_Message_queue_Delete+0x24>
400061a8: 01 00 00 00 nop
400061ac: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
400061b0: 80 a0 60 00 cmp %g1, 0
400061b4: 02 80 00 07 be 400061d0 <_POSIX_Message_queue_Delete+0x38>
400061b8: 92 10 00 19 mov %i1, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400061bc: c2 06 40 00 ld [ %i1 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400061c0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400061c4: 01 00 00 00 nop
_CORE_message_queue_Close( &the_mq->Message_queue, queue_context );
_POSIX_Message_queue_Free( the_mq );
} else {
_CORE_message_queue_Release( &the_mq->Message_queue, queue_context );
}
}
400061c8: 81 c7 e0 08 ret
400061cc: 81 e8 00 00 restore
_CORE_message_queue_Close( &the_mq->Message_queue, queue_context );
400061d0: 90 06 20 10 add %i0, 0x10, %o0
400061d4: 40 00 02 4f call 40006b10 <_CORE_message_queue_Close>
400061d8: b2 10 00 18 mov %i0, %i1
_Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object );
400061dc: 31 10 00 52 sethi %hi(0x40014800), %i0
400061e0: 40 00 0a 1f call 40008a5c <_Objects_Free>
400061e4: 91 ee 21 d0 restore %i0, 0x1d0, %o0
4000653c <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
const struct timespec *abstime,
Thread_queue_Enqueue_callout enqueue_callout
)
{
4000653c: 9d e3 bf 70 save %sp, -144, %sp
return (POSIX_Message_queue_Control *) _Objects_Get(
40006540: 15 10 00 52 sethi %hi(0x40014800), %o2
40006544: 92 07 bf dc add %fp, -36, %o1
40006548: 94 12 a1 d0 or %o2, 0x1d0, %o2
4000654c: 40 00 09 70 call 40008b0c <_Objects_Get>
40006550: 90 10 00 18 mov %i0, %o0
Thread_Control *executing;
Status_Control status;
the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
if ( the_mq == NULL ) {
40006554: 80 a2 20 00 cmp %o0, 0
40006558: 02 80 00 2c be 40006608 <_POSIX_Message_queue_Receive_support+0xcc>
<== NEVER TAKEN
4000655c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EBADF );
}
if ( ( the_mq->oflag & O_ACCMODE ) == O_WRONLY ) {
40006560: d8 02 20 68 ld [ %o0 + 0x68 ], %o4
40006564: 82 0b 20 03 and %o4, 3, %g1
40006568: 80 a0 60 01 cmp %g1, 1
4000656c: 02 80 00 24 be 400065fc <_POSIX_Message_queue_Receive_support+0xc0>
<== NEVER TAKEN
40006570: 01 00 00 00 nop
_ISR_lock_ISR_enable( &queue_context.Lock_context.Lock_context );
rtems_set_errno_and_return_minus_one( EBADF );
}
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
40006574: c2 02 20 28 ld [ %o0 + 0x28 ], %g1
40006578: 80 a0 40 1a cmp %g1, %i2
4000657c: 18 80 00 29 bgu 40006620 <_POSIX_Message_queue_Receive_support+0xe4>
<== NEVER TAKEN
40006580: 82 10 3f ff mov -1, %g1
_Thread_queue_Context_set_enqueue_callout(
Thread_queue_Context *queue_context,
Thread_queue_Enqueue_callout enqueue_callout
)
{
queue_context->enqueue_callout = enqueue_callout;
40006584: fa 27 bf e4 st %i5, [ %fp + -28 ]
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
40006588: c2 27 bf d8 st %g1, [ %fp + -40 ]
queue_context->Timeout.arg = arg;
4000658c: f8 27 bf e8 st %i4, [ %fp + -24 ]
_CORE_message_queue_Acquire_critical(
&the_mq->Message_queue,
&queue_context
);
if ( the_mq->open_count == 0 ) {
40006590: c2 02 20 50 ld [ %o0 + 0x50 ], %g1
40006594: 80 a0 60 00 cmp %g1, 0
40006598: 02 80 00 19 be 400065fc <_POSIX_Message_queue_Receive_support+0xc0>
<== NEVER TAKEN
4000659c: 84 02 20 10 add %o0, 0x10, %g2
}
/*
* Now perform the actual message receive
*/
executing = _Thread_Executing;
400065a0: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
status = _CORE_message_queue_Seize(
400065a4: 99 33 20 0e srl %o4, 0xe, %o4
400065a8: 9a 07 bf dc add %fp, -36, %o5
400065ac: 98 1b 20 01 xor %o4, 1, %o4
400065b0: 96 07 bf d8 add %fp, -40, %o3
400065b4: 98 0b 20 01 and %o4, 1, %o4
400065b8: 94 10 00 19 mov %i1, %o2
400065bc: 92 10 00 1d mov %i5, %o1
400065c0: 40 00 01 8e call 40006bf8 <_CORE_message_queue_Seize>
400065c4: 90 10 00 02 mov %g2, %o0
&length_out,
( the_mq->oflag & O_NONBLOCK ) == 0,
&queue_context
);
if ( status != STATUS_SUCCESSFUL ) {
400065c8: 80 92 00 09 orcc %o0, %o1, %g0
400065cc: 12 80 00 1e bne 40006644 <_POSIX_Message_queue_Receive_support+0x108>
<== NEVER TAKEN
400065d0: 80 a6 e0 00 cmp %i3, 0
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
}
if ( msg_prio != NULL ) {
400065d4: 22 80 00 08 be,a 400065f4 <_POSIX_Message_queue_Receive_support+0xb8>
<== NEVER TAKEN
400065d8: f0 07 bf d8 ld [ %fp + -40 ], %i0
<== NOT EXECUTED
return (unsigned int) ((priority >= 0) ? priority : -priority);
400065dc: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
400065e0: 85 38 60 1f sra %g1, 0x1f, %g2
400065e4: 82 18 80 01 xor %g2, %g1, %g1
400065e8: 82 20 40 02 sub %g1, %g2, %g1
*msg_prio = _POSIX_Message_queue_Priority_from_core(
400065ec: c2 26 c0 00 st %g1, [ %i3 ]
executing->Wait.count
);
}
return length_out;
400065f0: f0 07 bf d8 ld [ %fp + -40 ], %i0
}
400065f4: 81 c7 e0 08 ret
400065f8: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400065fc: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006600: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006604: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
40006608: 40 00 25 7a call 4000fbf0 <__errno>
<== NOT EXECUTED
4000660c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40006610: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40006614: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006618: 81 c7 e0 08 ret
<== NOT EXECUTED
4000661c: 81 e8 00 00 restore
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006620: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006624: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006628: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EMSGSIZE );
4000662c: 40 00 25 71 call 4000fbf0 <__errno>
<== NOT EXECUTED
40006630: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40006634: 82 10 20 7a mov 0x7a, %g1
<== NOT EXECUTED
40006638: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000663c: 81 c7 e0 08 ret
<== NOT EXECUTED
40006640: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
40006644: 40 00 25 6b call 4000fbf0 <__errno>
<== NOT EXECUTED
40006648: d2 27 bf d4 st %o1, [ %fp + -44 ]
<== NOT EXECUTED
}
RTEMS_INLINE_ROUTINE int _POSIX_Get_error( Status_Control status )
{
return STATUS_GET_POSIX( status );
4000664c: d2 07 bf d4 ld [ %fp + -44 ], %o1
<== NOT EXECUTED
40006650: 93 3a 60 08 sra %o1, 8, %o1
<== NOT EXECUTED
40006654: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
40006658: 81 c7 e0 08 ret
<== NOT EXECUTED
4000665c: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
40006678 <_POSIX_Message_queue_Send_support>:
size_t msg_len,
unsigned int msg_prio,
const struct timespec *abstime,
Thread_queue_Enqueue_callout enqueue_callout
)
{
40006678: 9d e3 bf 68 save %sp, -152, %sp
/*
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX ) {
4000667c: 80 a6 e0 20 cmp %i3, 0x20
40006680: 18 80 00 34 bgu 40006750 <_POSIX_Message_queue_Send_support+0xd8>
<== NEVER TAKEN
40006684: 92 07 bf dc add %fp, -36, %o1
return (POSIX_Message_queue_Control *) _Objects_Get(
40006688: 15 10 00 52 sethi %hi(0x40014800), %o2
4000668c: 90 10 00 18 mov %i0, %o0
40006690: 40 00 09 1f call 40008b0c <_Objects_Get>
40006694: 94 12 a1 d0 or %o2, 0x1d0, %o2
rtems_set_errno_and_return_minus_one( EINVAL );
}
the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
if ( the_mq == NULL ) {
40006698: 80 a2 20 00 cmp %o0, 0
4000669c: 02 80 00 27 be 40006738 <_POSIX_Message_queue_Send_support+0xc0>
<== NEVER TAKEN
400066a0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EBADF );
}
if ( ( the_mq->oflag & O_ACCMODE ) == O_RDONLY ) {
400066a4: da 02 20 68 ld [ %o0 + 0x68 ], %o5
400066a8: 80 8b 60 03 btst 3, %o5
400066ac: 02 80 00 20 be 4000672c <_POSIX_Message_queue_Send_support+0xb4>
<== NEVER TAKEN
400066b0: 01 00 00 00 nop
queue_context->enqueue_callout = enqueue_callout;
400066b4: fa 27 bf e4 st %i5, [ %fp + -28 ]
queue_context->Timeout.arg = arg;
400066b8: f8 27 bf e8 st %i4, [ %fp + -24 ]
_CORE_message_queue_Acquire_critical(
&the_mq->Message_queue,
&queue_context
);
if ( the_mq->open_count == 0 ) {
400066bc: c2 02 20 50 ld [ %o0 + 0x50 ], %g1
400066c0: 80 a0 60 00 cmp %g1, 0
400066c4: 02 80 00 1a be 4000672c <_POSIX_Message_queue_Send_support+0xb4>
<== NEVER TAKEN
400066c8: 84 02 20 10 add %o0, 0x10, %g2
/*
* Now perform the actual message receive
*/
executing = _Thread_Executing;
status = _CORE_message_queue_Submit(
400066cc: 82 07 bf dc add %fp, -36, %g1
400066d0: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
400066d4: 9b 33 60 0e srl %o5, 0xe, %o5
400066d8: d2 01 a0 20 ld [ %g6 + 0x20 ], %o1
400066dc: 9a 1b 60 01 xor %o5, 1, %o5
400066e0: 98 20 00 1b neg %i3, %o4
400066e4: 9a 0b 60 01 and %o5, 1, %o5
400066e8: 96 10 00 1a mov %i2, %o3
400066ec: 94 10 00 19 mov %i1, %o2
400066f0: 90 10 00 02 mov %g2, %o0
400066f4: 40 00 01 8d call 40006d28 <_CORE_message_queue_Submit>
400066f8: b0 10 20 00 clr %i0
RTEMS_INLINE_ROUTINE int _POSIX_Zero_or_minus_one_plus_errno(
Status_Control status
)
{
if ( status == STATUS_SUCCESSFUL ) {
400066fc: 80 92 00 09 orcc %o0, %o1, %g0
40006700: 12 80 00 04 bne 40006710 <_POSIX_Message_queue_Send_support+0x98>
<== NEVER TAKEN
40006704: 01 00 00 00 nop
_POSIX_Message_queue_Priority_to_core( msg_prio ),
( the_mq->oflag & O_NONBLOCK ) == 0,
&queue_context
);
return _POSIX_Zero_or_minus_one_plus_errno( status );
}
40006708: 81 c7 e0 08 ret
4000670c: 81 e8 00 00 restore
return 0;
}
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
40006710: 40 00 25 38 call 4000fbf0 <__errno>
<== NOT EXECUTED
40006714: d2 27 bf d4 st %o1, [ %fp + -44 ]
<== NOT EXECUTED
return STATUS_GET_POSIX( status );
40006718: d2 07 bf d4 ld [ %fp + -44 ], %o1
<== NOT EXECUTED
4000671c: 93 3a 60 08 sra %o1, 8, %o1
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
40006720: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
40006724: 81 c7 e0 08 ret
<== NOT EXECUTED
40006728: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000672c: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006730: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006734: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
40006738: 40 00 25 2e call 4000fbf0 <__errno>
<== NOT EXECUTED
4000673c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40006740: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40006744: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006748: 81 c7 e0 08 ret
<== NOT EXECUTED
4000674c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
40006750: 40 00 25 28 call 4000fbf0 <__errno>
<== NOT EXECUTED
40006754: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006758: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4000675c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006760: 81 c7 e0 08 ret
<== NOT EXECUTED
40006764: 81 e8 00 00 restore
<== NOT EXECUTED
40006570 <_POSIX_Mutex_Auto_initialization>:
#include <rtems/posix/posixapi.h>
#include <string.h>
bool _POSIX_Mutex_Auto_initialization( POSIX_Mutex_Control *the_mutex )
{
40006570: 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;
40006574: f2 06 20 04 ld [ %i0 + 4 ], %i1
<== NOT EXECUTED
zero |= (unsigned long) the_mutex->Priority_ceiling.priority;
40006578: de 06 20 30 ld [ %i0 + 0x30 ], %o7
<== NOT EXECUTED
4000657c: da 06 20 34 ld [ %i0 + 0x34 ], %o5
<== NOT EXECUTED
zero |= (unsigned long) the_mutex->scheduler;
40006580: c4 06 00 00 ld [ %i0 ], %g2
<== NOT EXECUTED
40006584: d4 06 20 08 ld [ %i0 + 8 ], %o2
<== NOT EXECUTED
40006588: d6 06 20 18 ld [ %i0 + 0x18 ], %o3
<== NOT EXECUTED
4000658c: f4 06 20 0c ld [ %i0 + 0xc ], %i2
<== NOT EXECUTED
40006590: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
<== NOT EXECUTED
40006594: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
<== NOT EXECUTED
40006598: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
<== NOT EXECUTED
4000659c: c8 06 20 24 ld [ %i0 + 0x24 ], %g4
<== NOT EXECUTED
400065a0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
<== NOT EXECUTED
400065a4: d8 06 20 2c ld [ %i0 + 0x2c ], %o4
<== NOT EXECUTED
400065a8: c6 06 20 38 ld [ %i0 + 0x38 ], %g3
<== NOT EXECUTED
400065ac: 84 10 80 19 or %g2, %i1, %g2
<== NOT EXECUTED
400065b0: 84 10 80 0a or %g2, %o2, %g2
<== NOT EXECUTED
400065b4: 84 10 80 0b or %g2, %o3, %g2
<== NOT EXECUTED
400065b8: 84 16 80 02 or %i2, %g2, %g2
<== NOT EXECUTED
400065bc: 84 16 c0 02 or %i3, %g2, %g2
<== NOT EXECUTED
400065c0: 84 17 00 02 or %i4, %g2, %g2
<== NOT EXECUTED
400065c4: 84 17 40 02 or %i5, %g2, %g2
<== NOT EXECUTED
400065c8: 84 11 00 02 or %g4, %g2, %g2
<== NOT EXECUTED
400065cc: 82 10 40 02 or %g1, %g2, %g1
<== NOT EXECUTED
400065d0: 82 10 40 0c or %g1, %o4, %g1
<== NOT EXECUTED
400065d4: 82 10 40 0d or %g1, %o5, %g1
<== NOT EXECUTED
400065d8: 82 10 c0 01 or %g3, %g1, %g1
<== NOT EXECUTED
if ( zero != 0 ) {
400065dc: 80 90 40 0f orcc %g1, %o7, %g0
<== NOT EXECUTED
400065e0: 12 80 00 08 bne 40006600 <_POSIX_Mutex_Auto_initialization+0x90>
<== NOT EXECUTED
400065e4: b2 10 20 00 clr %i1
<== NOT EXECUTED
return false;
}
flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
400065e8: 03 25 87 04 sethi %hi(0x961c1000), %g1
<== NOT EXECUTED
400065ec: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 <RAM_END+0x55dc13b8>
<== NOT EXECUTED
400065f0: 82 1e 00 01 xor %i0, %g1, %g1
<== NOT EXECUTED
flags &= ~POSIX_MUTEX_FLAGS_MASK;
400065f4: 82 08 7f f8 and %g1, -8, %g1
<== NOT EXECUTED
the_mutex->flags = flags;
400065f8: c2 26 00 00 st %g1, [ %i0 ]
<== NOT EXECUTED
return true;
400065fc: b2 10 20 01 mov 1, %i1
<== NOT EXECUTED
}
40006600: b0 0e 60 01 and %i1, 1, %i0
<== NOT EXECUTED
40006604: 81 c7 e0 08 ret
<== NOT EXECUTED
40006608: 81 e8 00 00 restore
<== NOT EXECUTED
40006338 <_POSIX_Mutex_Lock_support>:
int _POSIX_Mutex_Lock_support(
pthread_mutex_t *mutex,
const struct timespec *abstime,
Thread_queue_Enqueue_callout enqueue_callout
)
{
40006338: 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 );
4000633c: 80 a6 20 00 cmp %i0, 0
40006340: 02 80 00 3f be 4000643c <_POSIX_Mutex_Lock_support+0x104>
<== NEVER TAKEN
40006344: 05 25 87 04 sethi %hi(0x961c1000), %g2
40006348: fa 06 00 00 ld [ %i0 ], %i5
4000634c: 82 1e 00 1d xor %i0, %i5, %g1
40006350: 84 10 a3 b8 or %g2, 0x3b8, %g2
40006354: 82 18 40 02 xor %g1, %g2, %g1
40006358: 80 88 7f f8 btst -8, %g1
4000635c: 12 80 00 33 bne 40006428 <_POSIX_Mutex_Lock_support+0xf0>
<== NEVER TAKEN
40006360: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006364: 91 d0 20 09 ta 9
<== NOT EXECUTED
40006368: 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 ) ) {
4000636c: 82 8f 60 03 andcc %i5, 3, %g1
queue_context->enqueue_callout = enqueue_callout;
40006370: f4 27 bf e4 st %i2, [ %fp + -28 ]
queue_context->Timeout.arg = arg;
40006374: f2 27 bf e8 st %i1, [ %fp + -24 ]
40006378: 02 80 00 34 be 40006448 <_POSIX_Mutex_Lock_support+0x110>
<== ALWAYS TAKEN
4000637c: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
40006380: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
40006384: 12 80 00 10 bne 400063c4 <_POSIX_Mutex_Lock_support+0x8c>
<== NOT EXECUTED
40006388: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
<== NOT EXECUTED
{
Thread_Control *owner;
owner = _POSIX_Mutex_Get_owner( the_mutex );
if ( owner == NULL ) {
4000638c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40006390: 02 80 00 43 be 4000649c <_POSIX_Mutex_Lock_support+0x164>
<== NOT EXECUTED
40006394: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
executing,
queue_context
);
}
if ( owner == executing ) {
40006398: 02 80 00 18 be 400063f8 <_POSIX_Mutex_Lock_support+0xc0>
<== NOT EXECUTED
4000639c: 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(
400063a0: 98 07 bf dc add %fp, -36, %o4
<== NOT EXECUTED
400063a4: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
400063a8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400063ac: 13 10 00 42 sethi %hi(0x40010800), %o1
<== NOT EXECUTED
400063b0: 7f ff ff ca call 400062d8 <_POSIX_Mutex_Seize_slow>
<== NOT EXECUTED
400063b4: 92 12 60 f8 or %o1, 0xf8, %o1 ! 400108f8 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
400063b8: 93 3a 60 08 sra %o1, 8, %o1
<== NOT EXECUTED
);
break;
}
return _POSIX_Get_error( status );
}
400063bc: 81 c7 e0 08 ret
<== NOT EXECUTED
400063c0: 91 e8 00 09 restore %g0, %o1, %o0
<== NOT EXECUTED
if ( owner == NULL ) {
400063c4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400063c8: 02 80 00 2e be 40006480 <_POSIX_Mutex_Lock_support+0x148>
<== NOT EXECUTED
400063cc: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
if ( owner == executing ) {
400063d0: 02 80 00 0a be 400063f8 <_POSIX_Mutex_Lock_support+0xc0>
<== NOT EXECUTED
400063d4: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
return _POSIX_Mutex_Seize_slow(
400063d8: 98 07 bf dc add %fp, -36, %o4
<== NOT EXECUTED
400063dc: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
400063e0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400063e4: 13 10 00 42 sethi %hi(0x40010800), %o1
<== NOT EXECUTED
400063e8: 7f ff ff bc call 400062d8 <_POSIX_Mutex_Seize_slow>
<== NOT EXECUTED
400063ec: 92 12 60 e4 or %o1, 0xe4, %o1 ! 400108e4 <_Thread_queue_Operations_priority_inherit>
<== NOT EXECUTED
return _POSIX_Get_error( status );
400063f0: 10 80 00 0c b 40006420 <_POSIX_Mutex_Lock_support+0xe8>
<== NOT EXECUTED
400063f4: 93 3a 60 08 sra %o1, 8, %o1
<== NOT EXECUTED
if ( _POSIX_Mutex_Is_recursive( flags ) ) {
400063f8: 80 8f 60 04 btst 4, %i5
400063fc: 02 80 00 06 be 40006414 <_POSIX_Mutex_Lock_support+0xdc>
<== ALWAYS TAKEN
40006400: 92 10 20 2d mov 0x2d, %o1
++the_mutex->Recursive.nest_level;
40006404: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
40006408: 82 00 60 01 inc %g1
<== NOT EXECUTED
4000640c: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
<== NOT EXECUTED
40006410: 92 10 20 00 clr %o1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006414: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006418: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000641c: 01 00 00 00 nop
}
40006420: 81 c7 e0 08 ret
40006424: 91 e8 00 09 restore %g0, %o1, %o0
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40006428: 40 00 00 52 call 40006570 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
4000642c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40006430: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40006434: 12 bf ff cc bne 40006364 <_POSIX_Mutex_Lock_support+0x2c>
<== NOT EXECUTED
40006438: 01 00 00 00 nop
<== NOT EXECUTED
4000643c: 92 10 20 16 mov 0x16, %o1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
}
40006440: 81 c7 e0 08 ret
<== NOT EXECUTED
40006444: 91 e8 00 09 restore %g0, %o1, %o0
<== NOT EXECUTED
40006448: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
if ( owner == NULL ) {
4000644c: 80 a0 60 00 cmp %g1, 0
40006450: 02 80 00 0c be 40006480 <_POSIX_Mutex_Lock_support+0x148>
40006454: 80 a2 00 01 cmp %o0, %g1
if ( owner == executing ) {
40006458: 02 bf ff e8 be 400063f8 <_POSIX_Mutex_Lock_support+0xc0>
4000645c: 94 10 00 08 mov %o0, %o2
return _POSIX_Mutex_Seize_slow(
40006460: 98 07 bf dc add %fp, -36, %o4
40006464: 96 10 00 19 mov %i1, %o3
40006468: 90 10 00 18 mov %i0, %o0
4000646c: 13 10 00 42 sethi %hi(0x40010800), %o1
40006470: 7f ff ff 9a call 400062d8 <_POSIX_Mutex_Seize_slow>
40006474: 92 12 61 0c or %o1, 0x10c, %o1 ! 4001090c <_Thread_queue_Operations_FIFO>
40006478: 10 bf ff ea b 40006420 <_POSIX_Mutex_Lock_support+0xe8>
4000647c: 93 3a 60 08 sra %o1, 8, %o1
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40006480: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006484: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006488: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000648c: 01 00 00 00 nop
40006490: 92 10 20 00 clr %o1 ! 0 <PROM_START>
40006494: 81 c7 e0 08 ret
40006498: 91 e8 00 09 restore %g0, %o1, %o0
if (
4000649c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
<== NOT EXECUTED
queue_context->Priority.update_count = 0;
400064a0: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
400064a4: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
<== NOT EXECUTED
400064a8: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
<== NOT EXECUTED
400064ac: 80 a0 c0 02 cmp %g3, %g2
<== NOT EXECUTED
400064b0: 18 80 00 09 bgu 400064d4 <_POSIX_Mutex_Lock_support+0x19c>
<== NOT EXECUTED
400064b4: 01 00 00 00 nop
<== NOT EXECUTED
400064b8: 32 80 00 0c bne,a 400064e8 <_POSIX_Mutex_Lock_support+0x1b0>
<== NOT EXECUTED
400064bc: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
<== NOT EXECUTED
400064c0: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
<== NOT EXECUTED
400064c4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
400064c8: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
400064cc: 28 80 00 07 bleu,a 400064e8 <_POSIX_Mutex_Lock_support+0x1b0>
<== NOT EXECUTED
400064d0: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400064d4: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400064d8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400064dc: 01 00 00 00 nop
<== NOT EXECUTED
400064e0: 10 bf ff d8 b 40006440 <_POSIX_Mutex_Lock_support+0x108>
<== NOT EXECUTED
400064e4: 92 10 20 16 mov 0x16, %o1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
_Thread_Priority_add(
400064e8: 92 06 20 20 add %i0, 0x20, %o1
<== NOT EXECUTED
400064ec: 40 00 10 94 call 4000a73c <_Thread_Priority_add>
<== NOT EXECUTED
400064f0: 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;
400064f4: 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;
400064f8: 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 );
400064fc: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40006500: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006504: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006508: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000650c: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( queue_context );
40006510: 40 00 10 9c call 4000a780 <_Thread_Priority_update>
<== NOT EXECUTED
40006514: 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;
40006518: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000651c: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
40006520: 02 80 00 05 be 40006534 <_POSIX_Mutex_Lock_support+0x1fc>
<== NOT EXECUTED
40006524: 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;
40006528: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000652c: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
40006530: 30 bf ff bc b,a 40006420 <_POSIX_Mutex_Lock_support+0xe8>
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006534: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
40006538: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
<== NOT EXECUTED
4000653c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40006540: 32 80 00 07 bne,a 4000655c <_POSIX_Mutex_Lock_support+0x224>
<== NOT EXECUTED
40006544: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
40006548: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000654c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006550: 01 00 00 00 nop
<== NOT EXECUTED
40006554: 10 bf ff b3 b 40006420 <_POSIX_Mutex_Lock_support+0xe8>
<== NOT EXECUTED
40006558: 92 10 20 00 clr %o1 ! 0 <PROM_START>
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
4000655c: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
40006560: 40 00 10 e4 call 4000a8f0 <_Thread_Do_dispatch>
<== NOT EXECUTED
40006564: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40006568: 10 bf ff f9 b 4000654c <_POSIX_Mutex_Lock_support+0x214>
<== NOT EXECUTED
4000656c: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
400062d8 <_POSIX_Mutex_Seize_slow>:
const Thread_queue_Operations *operations,
Thread_Control *executing,
const struct timespec *abstime,
Thread_queue_Context *queue_context
)
{
400062d8: 9d e3 bf a0 save %sp, -96, %sp
if ( (uintptr_t) abstime != POSIX_MUTEX_ABSTIME_TRY_LOCK ) {
400062dc: 80 a6 e0 01 cmp %i3, 1
400062e0: 02 80 00 0f be 4000631c <_POSIX_Mutex_Seize_slow+0x44>
<== NEVER TAKEN
400062e4: 82 10 20 01 mov 1, %g1
queue_context->thread_state = thread_state;
400062e8: c2 27 20 04 st %g1, [ %i4 + 4 ]
queue_context->deadlock_callout = deadlock_callout;
400062ec: 03 10 00 2c sethi %hi(0x4000b000), %g1
400062f0: 82 10 60 24 or %g1, 0x24, %g1 ! 4000b024 <_Thread_queue_Deadlock_status>
400062f4: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
);
_Thread_queue_Context_set_deadlock_callout(
queue_context,
_Thread_queue_Deadlock_status
);
_Thread_queue_Enqueue(
400062f8: 92 10 00 19 mov %i1, %o1
400062fc: 90 06 20 0c add %i0, 0xc, %o0
40006300: 96 10 00 1c mov %i4, %o3
40006304: 94 10 00 1a mov %i2, %o2
40006308: 40 00 13 4f call 4000b044 <_Thread_queue_Enqueue>
4000630c: b0 10 20 00 clr %i0
RTEMS_INLINE_ROUTINE Status_Control _Thread_Wait_get_status(
const Thread_Control *the_thread
)
{
return (Status_Control) the_thread->Wait.return_code;
40006310: f2 06 a0 4c ld [ %i2 + 0x4c ], %i1
return _Thread_Wait_get_status( executing );
} else {
_POSIX_Mutex_Release( the_mutex, queue_context );
return STATUS_UNAVAILABLE;
}
}
40006314: 81 c7 e0 08 ret
40006318: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000631c: c2 07 00 00 ld [ %i4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006320: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006324: 01 00 00 00 nop
<== NOT EXECUTED
40006328: 33 00 00 04 sethi %hi(0x1000), %i1
<== NOT EXECUTED
4000632c: b2 16 60 0d or %i1, 0xd, %i1 ! 100d <_Configuration_Interrupt_stack_size+0xd>
<== NOT EXECUTED
40006330: 81 c7 e0 08 ret
<== NOT EXECUTED
40006334: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
4000db10 <_POSIX_Priority_To_core>:
Priority_Control _POSIX_Priority_To_core(
const Scheduler_Control *scheduler,
int posix_priority,
bool *valid
)
{
4000db10: 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;
4000db14: f8 1e 20 40 ldd [ %i0 + 0x40 ], %i4
core_posix_priority = (Priority_Control) posix_priority;
4000db18: 83 3e 60 1f sra %i1, 0x1f, %g1
4000db1c: 86 10 00 19 mov %i1, %g3
4000db20: 84 10 00 01 mov %g1, %g2
*valid = ( posix_priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY
&& core_posix_priority < scheduler->maximum_priority );
4000db24: 80 a7 00 01 cmp %i4, %g1
4000db28: 18 80 00 05 bgu 4000db3c <_POSIX_Priority_To_core+0x2c>
<== NEVER TAKEN
4000db2c: 88 10 20 01 mov 1, %g4
4000db30: 02 80 00 11 be 4000db74 <_POSIX_Priority_To_core+0x64>
<== ALWAYS TAKEN
4000db34: 80 a7 40 19 cmp %i5, %i1
4000db38: 88 10 20 00 clr %g4
<== NOT EXECUTED
4000db3c: 82 20 40 19 sub %g1, %i1, %g1
<== NOT EXECUTED
4000db40: 83 30 60 1f srl %g1, 0x1f, %g1
4000db44: 82 08 40 04 and %g1, %g4, %g1
*valid = ( posix_priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY
4000db48: c2 2e 80 00 stb %g1, [ %i2 ]
core_priority = scheduler->maximum_priority - core_posix_priority;
4000db4c: b6 a7 40 03 subcc %i5, %g3, %i3
return ( *scheduler->Operations.map_priority )( scheduler, priority );
4000db50: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4000db54: b4 67 00 02 subx %i4, %g2, %i2
4000db58: 94 10 00 1b mov %i3, %o2
4000db5c: 92 10 00 1a mov %i2, %o1
4000db60: 9f c0 40 00 call %g1
4000db64: 90 10 00 18 mov %i0, %o0
return _Scheduler_Map_priority( scheduler, core_priority );
}
4000db68: b0 10 00 08 mov %o0, %i0
4000db6c: 81 c7 e0 08 ret
4000db70: 93 e8 00 09 restore %g0, %o1, %o1
&& core_posix_priority < scheduler->maximum_priority );
4000db74: 38 bf ff f3 bgu,a 4000db40 <_POSIX_Priority_To_core+0x30>
<== ALWAYS TAKEN
4000db78: 82 20 40 19 sub %g1, %i1, %g1
4000db7c: 10 bf ff f0 b 4000db3c <_POSIX_Priority_To_core+0x2c>
<== NOT EXECUTED
4000db80: 88 10 20 00 clr %g4
<== NOT EXECUTED
400062f0 <_POSIX_RWLock_Auto_initialization>:
#include <rtems/posix/posixapi.h>
#include <string.h>
bool _POSIX_RWLock_Auto_initialization( POSIX_RWLock_Control *the_rwlock )
{
400062f0: 9d e3 bf 80 save %sp, -128, %sp
<== NOT EXECUTED
POSIX_RWLock_Control zero;
memset( &zero, 0, sizeof( zero ) );
if ( memcmp( the_rwlock, &zero, sizeof( *the_rwlock ) ) != 0 ) {
400062f4: 94 10 20 20 mov 0x20, %o2
<== NOT EXECUTED
memset( &zero, 0, sizeof( zero ) );
400062f8: c0 27 bf e0 clr [ %fp + -32 ]
<== NOT EXECUTED
if ( memcmp( the_rwlock, &zero, sizeof( *the_rwlock ) ) != 0 ) {
400062fc: 92 07 bf e0 add %fp, -32, %o1
<== NOT EXECUTED
memset( &zero, 0, sizeof( zero ) );
40006300: c0 27 bf e4 clr [ %fp + -28 ]
<== NOT EXECUTED
if ( memcmp( the_rwlock, &zero, sizeof( *the_rwlock ) ) != 0 ) {
40006304: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
memset( &zero, 0, sizeof( zero ) );
40006308: c0 27 bf e8 clr [ %fp + -24 ]
<== NOT EXECUTED
4000630c: c0 27 bf ec clr [ %fp + -20 ]
<== NOT EXECUTED
40006310: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
40006314: c0 27 bf f4 clr [ %fp + -12 ]
<== NOT EXECUTED
40006318: c0 27 bf f8 clr [ %fp + -8 ]
<== NOT EXECUTED
if ( memcmp( the_rwlock, &zero, sizeof( *the_rwlock ) ) != 0 ) {
4000631c: 40 00 21 83 call 4000e928 <memcmp>
<== NOT EXECUTED
40006320: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
40006324: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40006328: 12 80 00 07 bne 40006344 <_POSIX_RWLock_Auto_initialization+0x54>
<== NOT EXECUTED
4000632c: 82 10 20 00 clr %g1
<== NOT EXECUTED
return false;
}
the_rwlock->flags = (uintptr_t) the_rwlock ^ POSIX_RWLOCK_MAGIC;
40006330: 03 25 88 76 sethi %hi(0x9621d800), %g1
<== NOT EXECUTED
40006334: 82 10 62 bd or %g1, 0x2bd, %g1 ! 9621dabd <RAM_END+0x55e1dabd>
<== NOT EXECUTED
40006338: 82 1e 00 01 xor %i0, %g1, %g1
<== NOT EXECUTED
4000633c: c2 26 00 00 st %g1, [ %i0 ]
<== NOT EXECUTED
return true;
40006340: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
}
40006344: b0 08 60 01 and %g1, 1, %i0
<== NOT EXECUTED
40006348: 81 c7 e0 08 ret
<== NOT EXECUTED
4000634c: 81 e8 00 00 restore
<== NOT EXECUTED
4000dbd4 <_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
)
{
4000dbd4: 9d e3 bf a0 save %sp, -96, %sp
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
4000dbd8: c0 26 80 00 clr [ %i2 ]
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
4000dbdc: 80 a6 20 00 cmp %i0, 0
4000dbe0: 02 80 00 29 be 4000dc84 <_POSIX_Thread_Translate_sched_param+0xb0>
<== NEVER TAKEN
4000dbe4: c0 26 c0 00 clr [ %i3 ]
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
4000dbe8: 80 a6 20 01 cmp %i0, 1
4000dbec: 02 80 00 2a be 4000dc94 <_POSIX_Thread_Translate_sched_param+0xc0>
4000dbf0: 80 a6 20 02 cmp %i0, 2
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
4000dbf4: 02 80 00 2d be 4000dca8 <_POSIX_Thread_Translate_sched_param+0xd4>
<== ALWAYS TAKEN
4000dbf8: 80 a6 20 04 cmp %i0, 4
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
4000dbfc: 12 80 00 29 bne 4000dca0 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
4000dc00: 01 00 00 00 nop
<== NOT EXECUTED
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
4000dc04: c4 06 60 08 ld [ %i1 + 8 ], %g2
<== NOT EXECUTED
4000dc08: c2 06 60 0c ld [ %i1 + 0xc ], %g1
<== NOT EXECUTED
4000dc0c: 80 90 80 01 orcc %g2, %g1, %g0
<== NOT EXECUTED
4000dc10: 32 80 00 07 bne,a 4000dc2c <_POSIX_Thread_Translate_sched_param+0x58>
<== NOT EXECUTED
4000dc14: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
<== NOT EXECUTED
4000dc18: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
<== NOT EXECUTED
4000dc1c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000dc20: 02 80 00 20 be 4000dca0 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
4000dc24: 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) &&
4000dc28: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
<== NOT EXECUTED
4000dc2c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
<== NOT EXECUTED
4000dc30: 80 90 80 01 orcc %g2, %g1, %g0
<== NOT EXECUTED
4000dc34: 12 80 00 06 bne 4000dc4c <_POSIX_Thread_Translate_sched_param+0x78>
<== NOT EXECUTED
4000dc38: 01 00 00 00 nop
<== NOT EXECUTED
4000dc3c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
<== NOT EXECUTED
4000dc40: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000dc44: 02 80 00 17 be 4000dca0 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
4000dc48: 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 ) <
4000dc4c: 7f ff ff 1c call 4000d8bc <_Timespec_To_ticks>
<== NOT EXECUTED
4000dc50: 90 06 60 08 add %i1, 8, %o0
<== NOT EXECUTED
4000dc54: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
4000dc58: 7f ff ff 19 call 4000d8bc <_Timespec_To_ticks>
<== NOT EXECUTED
4000dc5c: 90 06 60 18 add %i1, 0x18, %o0
<== NOT EXECUTED
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
4000dc60: 80 a7 40 08 cmp %i5, %o0
<== NOT EXECUTED
4000dc64: 0a 80 00 0f bcs 4000dca0 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
4000dc68: 82 10 20 03 mov 3, %g1
<== NOT EXECUTED
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
4000dc6c: c2 26 80 00 st %g1, [ %i2 ]
<== NOT EXECUTED
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
4000dc70: 03 10 00 31 sethi %hi(0x4000c400), %g1
<== NOT EXECUTED
4000dc74: 82 10 62 94 or %g1, 0x294, %g1 ! 4000c694 <_POSIX_Threads_Sporadic_budget_callout>
<== NOT EXECUTED
4000dc78: c2 26 c0 00 st %g1, [ %i3 ]
<== NOT EXECUTED
return 0;
}
return EINVAL;
}
4000dc7c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dc80: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
4000dc84: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
4000dc88: c2 26 80 00 st %g1, [ %i2 ]
<== NOT EXECUTED
return 0;
4000dc8c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dc90: 81 e8 00 00 restore
<== NOT EXECUTED
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
4000dc94: c0 26 80 00 clr [ %i2 ]
return 0;
4000dc98: 81 c7 e0 08 ret
4000dc9c: 91 e8 20 00 restore %g0, 0, %o0
return EINVAL;
4000dca0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dca4: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
4000dca8: f0 26 80 00 st %i0, [ %i2 ]
return 0;
4000dcac: 81 c7 e0 08 ret
4000dcb0: 91 e8 20 00 restore %g0, 0, %o0
4000dbac <_POSIX_Thread_Translate_to_sched_policy>:
#include <rtems/posix/pthreadimpl.h>
int _POSIX_Thread_Translate_to_sched_policy(
Thread_CPU_budget_algorithms budget_algorithm
)
{
4000dbac: 82 02 3f ff add %o0, -1, %g1
4000dbb0: 80 a0 60 02 cmp %g1, 2
4000dbb4: 18 80 00 06 bgu 4000dbcc <_POSIX_Thread_Translate_to_sched_policy+0x20>
<== ALWAYS TAKEN
4000dbb8: 90 10 20 01 mov 1, %o0
4000dbbc: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
4000dbc0: 05 10 00 3e sethi %hi(0x4000f800), %g2
<== NOT EXECUTED
4000dbc4: 84 10 a3 30 or %g2, 0x330, %g2 ! 4000fb30 <CSWTCH.1>
<== NOT EXECUTED
4000dbc8: 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;
}
}
4000dbcc: 81 c3 e0 08 retl
4000dbd0: 01 00 00 00 nop
4000fb40 <_POSIX_Threads_Default_attributes>:
4000fb40: 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 ................
4000fb50: 00 00 00 01 00 00 00 01 00 00 00 02 00 00 00 00 ................
...
4000fb8c: 00 00 00 01 00 00 00 01 00 00 00 04 40 00 fb 9c ............@...
4000fb9c: ff ff ff ff ....
40005e34 <_POSIX_Threads_Initialize_user_threads_body>:
#include <rtems/posix/pthreadimpl.h>
#include <rtems/posix/priorityimpl.h>
#include <rtems/posix/config.h>
void _POSIX_Threads_Initialize_user_threads_body(void)
{
40005e34: 9d e3 bf 38 save %sp, -200, %sp
uint32_t maximum;
posix_initialization_threads_table *user_threads;
pthread_t thread_id;
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
40005e38: 03 10 00 43 sethi %hi(0x40010c00), %g1
40005e3c: 82 10 61 84 or %g1, 0x184, %g1 ! 40010d84 <Configuration_POSIX_API>
40005e40: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
maximum = Configuration_POSIX_API.number_of_initialization_threads;
if ( !user_threads )
40005e44: 80 a7 60 00 cmp %i5, 0
40005e48: 02 80 00 1f be 40005ec4 <_POSIX_Threads_Initialize_user_threads_body+0x90>
<== NEVER TAKEN
40005e4c: 01 00 00 00 nop
maximum = Configuration_POSIX_API.number_of_initialization_threads;
40005e50: f4 00 60 18 ld [ %g1 + 0x18 ], %i2
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
40005e54: 80 a6 a0 00 cmp %i2, 0
40005e58: 02 80 00 1b be 40005ec4 <_POSIX_Threads_Initialize_user_threads_body+0x90>
<== NEVER TAKEN
40005e5c: b8 10 20 00 clr %i4
);
if ( eno != 0 ) {
_Internal_error( INTERNAL_ERROR_POSIX_INIT_THREAD_CREATE_FAILED );
}
if ( _Thread_Global_constructor == 0 ) {
40005e60: 37 10 00 4a sethi %hi(0x40012800), %i3
eno = pthread_attr_init( &attr );
40005e64: 40 00 18 7e call 4000c05c <pthread_attr_init>
40005e68: 90 07 bf a0 add %fp, -96, %o0
eno = pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
40005e6c: 92 10 20 02 mov 2, %o1
40005e70: 40 00 18 8a call 4000c098 <pthread_attr_setinheritsched>
40005e74: 90 07 bf a0 add %fp, -96, %o0
eno = pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
40005e78: d2 07 60 04 ld [ %i5 + 4 ], %o1
40005e7c: 40 00 18 96 call 4000c0d4 <pthread_attr_setstacksize>
40005e80: 90 07 bf a0 add %fp, -96, %o0
eno = pthread_create(
40005e84: d4 07 40 00 ld [ %i5 ], %o2
40005e88: 96 10 20 00 clr %o3
40005e8c: 92 07 bf a0 add %fp, -96, %o1
40005e90: 40 00 18 9d call 4000c104 <pthread_create>
40005e94: 90 07 bf 9c add %fp, -100, %o0
if ( eno != 0 ) {
40005e98: 80 a2 20 00 cmp %o0, 0
40005e9c: 12 80 00 0c bne 40005ecc <_POSIX_Threads_Initialize_user_threads_body+0x98>
<== NEVER TAKEN
40005ea0: c2 06 e1 50 ld [ %i3 + 0x150 ], %g1
if ( _Thread_Global_constructor == 0 ) {
40005ea4: 80 a0 60 00 cmp %g1, 0
40005ea8: 12 80 00 04 bne 40005eb8 <_POSIX_Threads_Initialize_user_threads_body+0x84>
<== NEVER TAKEN
40005eac: b8 07 20 01 inc %i4
_Thread_Global_constructor = thread_id;
40005eb0: c2 07 bf 9c ld [ %fp + -100 ], %g1
40005eb4: c2 26 e1 50 st %g1, [ %i3 + 0x150 ]
for ( index=0 ; index < maximum ; index++ ) {
40005eb8: 80 a6 80 1c cmp %i2, %i4
40005ebc: 12 bf ff ea bne 40005e64 <_POSIX_Threads_Initialize_user_threads_body+0x30>
<== NEVER TAKEN
40005ec0: ba 07 60 08 add %i5, 8, %i5
}
}
}
40005ec4: 81 c7 e0 08 ret
40005ec8: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_POSIX_INIT_THREAD_CREATE_FAILED );
40005ecc: 40 00 02 70 call 4000688c <_Internal_error>
<== NOT EXECUTED
40005ed0: 90 10 20 21 mov 0x21, %o0
<== NOT EXECUTED
40005ed4: 01 00 00 00 nop
<== NOT EXECUTED
4000c694 <_POSIX_Threads_Sporadic_budget_callout>:
{
4000c694: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
4000c698: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000c69c: d2 06 21 5c ld [ %i0 + 0x15c ], %o1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000c6a0: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000c6a4: c2 27 bf dc st %g1, [ %fp + -36 ]
<== NOT EXECUTED
the_thread->cpu_time_budget = UINT32_MAX;
4000c6a8: 82 10 3f ff mov -1, %g1
<== NOT EXECUTED
4000c6ac: c2 26 20 8c st %g1, [ %i0 + 0x8c ]
<== NOT EXECUTED
if ( !_Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
4000c6b0: c2 02 60 34 ld [ %o1 + 0x34 ], %g1
<== NOT EXECUTED
4000c6b4: 80 a0 7f ff cmp %g1, -1
<== NOT EXECUTED
4000c6b8: 02 80 00 09 be 4000c6dc <_POSIX_Threads_Sporadic_budget_callout+0x48>
<== NOT EXECUTED
4000c6bc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000c6c0: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c6c4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c6c8: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( &queue_context );
4000c6cc: 40 00 03 33 call 4000d398 <_Thread_Priority_update>
<== NOT EXECUTED
4000c6d0: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
}
4000c6d4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c6d8: 81 e8 00 00 restore
<== NOT EXECUTED
_Thread_Priority_add(
4000c6dc: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
4000c6e0: 40 00 03 24 call 4000d370 <_Thread_Priority_add>
<== NOT EXECUTED
4000c6e4: 92 02 60 28 add %o1, 0x28, %o1
<== NOT EXECUTED
_Thread_Priority_remove(
4000c6e8: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
4000c6ec: 92 06 20 20 add %i0, 0x20, %o1
<== NOT EXECUTED
4000c6f0: 40 00 03 25 call 4000d384 <_Thread_Priority_remove>
<== NOT EXECUTED
4000c6f4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000c6f8: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c6fc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c700: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( &queue_context );
4000c704: 40 00 03 25 call 4000d398 <_Thread_Priority_update>
<== NOT EXECUTED
4000c708: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
}
4000c70c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c710: 81 e8 00 00 restore
<== NOT EXECUTED
4000c5e0 <_POSIX_Threads_Sporadic_timer>:
{
4000c5e0: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
queue_context->Priority.update_count = 0;
4000c5e4: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
api = RTEMS_CONTAINER_OF( watchdog, POSIX_API_Control, Sporadic.Timer );
4000c5e8: ba 06 3f f8 add %i0, -8, %i5
<== NOT EXECUTED
the_thread = api->Sporadic.thread;
4000c5ec: f8 06 3f f8 ld [ %i0 + -8 ], %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000c5f0: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
4000c5f4: c2 27 bf dc st %g1, [ %fp + -36 ]
<== NOT EXECUTED
if ( _Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
4000c5f8: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
<== NOT EXECUTED
4000c5fc: 80 a0 7f ff cmp %g1, -1
<== NOT EXECUTED
4000c600: 02 80 00 0b be 4000c62c <_POSIX_Threads_Sporadic_timer+0x4c>
<== NOT EXECUTED
4000c604: 92 07 20 20 add %i4, 0x20, %o1
<== NOT EXECUTED
_Thread_Priority_add(
4000c608: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000c60c: 40 00 03 59 call 4000d370 <_Thread_Priority_add>
<== NOT EXECUTED
4000c610: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
_Thread_Priority_remove(
4000c614: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
4000c618: 92 06 20 20 add %i0, 0x20, %o1
<== NOT EXECUTED
4000c61c: 40 00 03 5a call 4000d384 <_Thread_Priority_remove>
<== NOT EXECUTED
4000c620: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000c624: 82 10 3f ff mov -1, %g1
<== NOT EXECUTED
4000c628: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
<== NOT EXECUTED
_Watchdog_Per_CPU_remove_ticks( &api->Sporadic.Timer );
4000c62c: b6 07 60 08 add %i5, 8, %i3
<== NOT EXECUTED
4000c630: 11 10 00 4a sethi %hi(0x40012800), %o0
<== NOT EXECUTED
4000c634: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4000c638: 7f ff f9 30 call 4000aaf8 <_Watchdog_Remove>
<== NOT EXECUTED
4000c63c: 90 12 21 38 or %o0, 0x138, %o0
<== NOT EXECUTED
_Timespec_To_ticks( &api->Sporadic.sched_ss_init_budget );
4000c640: 40 00 04 9f call 4000d8bc <_Timespec_To_ticks>
<== NOT EXECUTED
4000c644: 90 07 60 50 add %i5, 0x50, %o0
<== NOT EXECUTED
the_thread->cpu_time_budget =
4000c648: d0 27 20 8c st %o0, [ %i4 + 0x8c ]
<== NOT EXECUTED
_Watchdog_Per_CPU_insert_ticks(
4000c64c: b8 10 00 06 mov %g6, %i4
<== NOT EXECUTED
4000c650: 40 00 04 9b call 4000d8bc <_Timespec_To_ticks>
<== NOT EXECUTED
4000c654: 90 07 60 40 add %i5, 0x40, %o0
<== NOT EXECUTED
expire = ticks + cpu->Watchdog.ticks;
4000c658: d4 1f 20 30 ldd [ %i4 + 0x30 ], %o2
<== NOT EXECUTED
_Watchdog_Insert(header, the_watchdog, expire);
4000c65c: 86 82 c0 08 addcc %o3, %o0, %g3
<== NOT EXECUTED
4000c660: 84 42 a0 00 addx %o2, 0, %g2
<== NOT EXECUTED
4000c664: 96 10 00 03 mov %g3, %o3
<== NOT EXECUTED
4000c668: 94 10 00 02 mov %g2, %o2
<== NOT EXECUTED
4000c66c: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4000c670: 7f ff f8 fa call 4000aa58 <_Watchdog_Insert>
<== NOT EXECUTED
4000c674: 90 07 20 38 add %i4, 0x38, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000c678: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c67c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c680: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( &queue_context );
4000c684: 40 00 03 45 call 4000d398 <_Thread_Priority_update>
<== NOT EXECUTED
4000c688: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
}
4000c68c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c690: 81 e8 00 00 restore
<== NOT EXECUTED
4000f29c <_POSIX_signals_Abnormal_termination_handler>:
sigset_t _POSIX_signals_Pending;
void _POSIX_signals_Abnormal_termination_handler(
int signo RTEMS_UNUSED )
{
4000f29c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
exit( 1 );
4000f2a0: 40 00 02 59 call 4000fc04 <exit>
<== NOT EXECUTED
4000f2a4: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
4000f2a8: 01 00 00 00 nop
<== NOT EXECUTED
4000fb6c <_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 ) {
4000fb6c: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000fb70: 05 10 00 53 sethi %hi(0x40014c00), %g2
<== NOT EXECUTED
4000fb74: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000fb78: 84 10 a3 90 or %g2, 0x390, %g2
<== NOT EXECUTED
4000fb7c: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
4000fb80: c4 00 80 01 ld [ %g2 + %g1 ], %g2
<== NOT EXECUTED
4000fb84: 90 02 3f ff add %o0, -1, %o0
<== NOT EXECUTED
4000fb88: 80 a0 a0 02 cmp %g2, 2
<== NOT EXECUTED
4000fb8c: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
4000fb90: 02 80 00 07 be 4000fbac <_POSIX_signals_Clear_process_signals+0x40>
<== NOT EXECUTED
4000fb94: 91 28 80 08 sll %g2, %o0, %o0
<== NOT EXECUTED
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
4000fb98: 03 10 00 54 sethi %hi(0x40015000), %g1
<== NOT EXECUTED
4000fb9c: c4 00 61 1c ld [ %g1 + 0x11c ], %g2 ! 4001511c <_POSIX_signals_Pending>
<== NOT EXECUTED
4000fba0: 90 28 80 08 andn %g2, %o0, %o0
<== NOT EXECUTED
}
}
4000fba4: 81 c3 e0 08 retl
<== NOT EXECUTED
4000fba8: d0 20 61 1c st %o0, [ %g1 + 0x11c ]
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000fbac: 05 10 00 54 sethi %hi(0x40015000), %g2
<== NOT EXECUTED
4000fbb0: 84 10 a1 20 or %g2, 0x120, %g2 ! 40015120 <_POSIX_signals_Siginfo>
<== NOT EXECUTED
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
4000fbb4: c6 00 80 01 ld [ %g2 + %g1 ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
4000fbb8: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
4000fbbc: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000fbc0: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
4000fbc4: 02 bf ff f6 be 4000fb9c <_POSIX_signals_Clear_process_signals+0x30>
<== NOT EXECUTED
4000fbc8: 03 10 00 54 sethi %hi(0x40015000), %g1
<== NOT EXECUTED
}
4000fbcc: 81 c3 e0 08 retl
<== NOT EXECUTED
4000fbd0: 01 00 00 00 nop
<== NOT EXECUTED
4000fa18 <_POSIX_signals_Clear_signals>:
siginfo_t *info,
bool is_global,
bool check_blocked,
bool do_signals_acquire_release
)
{
4000fa18: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
4000fa1c: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
4000fa20: 86 06 7f ff add %i1, -1, %g3
<== NOT EXECUTED
*/
if ( check_blocked )
signals_unblocked = api->signals_unblocked;
else
signals_unblocked = SIGNAL_ALL_MASK;
4000fa24: 88 10 3f ff mov -1, %g4
<== NOT EXECUTED
if ( check_blocked )
4000fa28: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
4000fa2c: 02 80 00 03 be 4000fa38 <_POSIX_signals_Clear_signals+0x20>
<== NOT EXECUTED
4000fa30: 85 28 80 03 sll %g2, %g3, %g2
<== NOT EXECUTED
signals_unblocked = api->signals_unblocked;
4000fa34: 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 ) {
4000fa38: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4000fa3c: 02 80 00 04 be 4000fa4c <_POSIX_signals_Clear_signals+0x34>
<== NOT EXECUTED
4000fa40: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000fa44: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Thread_queue_Context_initialize( &queue_context );
_POSIX_signals_Acquire( &queue_context );
}
if ( is_global ) {
4000fa48: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
4000fa4c: 22 80 00 10 be,a 4000fa8c <_POSIX_signals_Clear_signals+0x74>
<== NOT EXECUTED
4000fa50: f8 06 20 6c ld [ %i0 + 0x6c ], %i4
<== NOT EXECUTED
if ( mask & (_POSIX_signals_Pending & signals_unblocked) ) {
4000fa54: 07 10 00 54 sethi %hi(0x40015000), %g3
<== NOT EXECUTED
4000fa58: c6 00 e1 1c ld [ %g3 + 0x11c ], %g3 ! 4001511c <_POSIX_signals_Pending>
<== NOT EXECUTED
4000fa5c: 84 08 80 03 and %g2, %g3, %g2
<== NOT EXECUTED
4000fa60: 80 88 80 04 btst %g2, %g4
<== NOT EXECUTED
4000fa64: 12 80 00 12 bne 4000faac <_POSIX_signals_Clear_signals+0x94>
<== NOT EXECUTED
4000fa68: 86 10 20 00 clr %g3
<== NOT EXECUTED
api->signals_pending &= ~mask;
do_callout = true;
}
}
if ( do_signals_acquire_release ) {
4000fa6c: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4000fa70: 22 80 00 05 be,a 4000fa84 <_POSIX_signals_Clear_signals+0x6c>
<== NOT EXECUTED
4000fa74: b0 08 e0 01 and %g3, 1, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000fa78: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000fa7c: 01 00 00 00 nop
<== NOT EXECUTED
_POSIX_signals_Release( &queue_context );
}
return do_callout;
}
4000fa80: b0 08 e0 01 and %g3, 1, %i0
<== NOT EXECUTED
4000fa84: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fa88: 81 e8 00 00 restore
<== NOT EXECUTED
if ( mask & (api->signals_pending & signals_unblocked) ) {
4000fa8c: b6 0f 00 02 and %i4, %g2, %i3
<== NOT EXECUTED
4000fa90: 80 8e c0 04 btst %i3, %g4
<== NOT EXECUTED
4000fa94: 02 bf ff f6 be 4000fa6c <_POSIX_signals_Clear_signals+0x54>
<== NOT EXECUTED
4000fa98: 86 10 20 00 clr %g3
<== NOT EXECUTED
api->signals_pending &= ~mask;
4000fa9c: 84 2f 00 02 andn %i4, %g2, %g2
<== NOT EXECUTED
do_callout = true;
4000faa0: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
api->signals_pending &= ~mask;
4000faa4: 10 bf ff f2 b 4000fa6c <_POSIX_signals_Clear_signals+0x54>
<== NOT EXECUTED
4000faa8: c4 26 20 6c st %g2, [ %i0 + 0x6c ]
<== NOT EXECUTED
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
4000faac: 85 2e 60 01 sll %i1, 1, %g2
<== NOT EXECUTED
4000fab0: 07 10 00 53 sethi %hi(0x40014c00), %g3
<== NOT EXECUTED
4000fab4: 84 00 80 19 add %g2, %i1, %g2
<== NOT EXECUTED
4000fab8: 86 10 e3 90 or %g3, 0x390, %g3
<== NOT EXECUTED
4000fabc: 85 28 a0 02 sll %g2, 2, %g2
<== NOT EXECUTED
4000fac0: c6 00 c0 02 ld [ %g3 + %g2 ], %g3
<== NOT EXECUTED
4000fac4: 80 a0 e0 02 cmp %g3, 2
<== NOT EXECUTED
4000fac8: 22 80 00 08 be,a 4000fae8 <_POSIX_signals_Clear_signals+0xd0>
<== NOT EXECUTED
4000facc: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
4000fad0: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
_POSIX_signals_Clear_process_signals( signo );
4000fad4: 40 00 00 26 call 4000fb6c <_POSIX_signals_Clear_process_signals>
<== NOT EXECUTED
4000fad8: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
do_callout = true;
4000fadc: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
4000fae0: 10 bf ff e3 b 4000fa6c <_POSIX_signals_Clear_signals+0x54>
<== NOT EXECUTED
4000fae4: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
_Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] );
4000fae8: 07 10 00 54 sethi %hi(0x40015000), %g3
<== NOT EXECUTED
4000faec: 86 10 e1 20 or %g3, 0x120, %g3 ! 40015120 <_POSIX_signals_Siginfo>
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000faf0: f8 00 80 03 ld [ %g2 + %g3 ], %i4
<== NOT EXECUTED
return &the_chain->Tail.Node;
4000faf4: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
4000faf8: 88 01 00 03 add %g4, %g3, %g4
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
4000fafc: 80 a7 00 04 cmp %i4, %g4
<== NOT EXECUTED
4000fb00: 02 80 00 17 be 4000fb5c <_POSIX_signals_Clear_signals+0x144>
<== NOT EXECUTED
4000fb04: b6 00 80 03 add %g2, %g3, %i3
<== NOT EXECUTED
new_first = old_first->next;
4000fb08: c8 07 00 00 ld [ %i4 ], %g4
<== NOT EXECUTED
head->next = new_first;
4000fb0c: c8 20 80 03 st %g4, [ %g2 + %g3 ]
<== NOT EXECUTED
_POSIX_signals_Clear_process_signals( signo );
4000fb10: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
4000fb14: 40 00 00 16 call 4000fb6c <_POSIX_signals_Clear_process_signals>
<== NOT EXECUTED
4000fb18: f6 21 20 04 st %i3, [ %g4 + 4 ]
<== NOT EXECUTED
*info = psiginfo->Info;
4000fb1c: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
4000fb20: c4 26 80 00 st %g2, [ %i2 ]
<== NOT EXECUTED
4000fb24: c4 07 20 0c ld [ %i4 + 0xc ], %g2
<== NOT EXECUTED
4000fb28: c4 26 a0 04 st %g2, [ %i2 + 4 ]
<== NOT EXECUTED
old_last = tail->previous;
4000fb2c: 05 10 00 54 sethi %hi(0x40015000), %g2
<== NOT EXECUTED
4000fb30: c6 07 20 10 ld [ %i4 + 0x10 ], %g3
<== NOT EXECUTED
4000fb34: c6 26 a0 08 st %g3, [ %i2 + 8 ]
<== NOT EXECUTED
4000fb38: 84 10 a1 10 or %g2, 0x110, %g2
<== NOT EXECUTED
4000fb3c: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
the_node->next = tail;
4000fb40: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
4000fb44: c8 27 00 00 st %g4, [ %i4 ]
<== NOT EXECUTED
tail->previous = the_node;
4000fb48: f8 20 a0 08 st %i4, [ %g2 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
4000fb4c: f8 20 c0 00 st %i4, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
4000fb50: c6 27 20 04 st %g3, [ %i4 + 4 ]
<== NOT EXECUTED
4000fb54: 10 bf ff df b 4000fad0 <_POSIX_signals_Clear_signals+0xb8>
<== NOT EXECUTED
4000fb58: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
_POSIX_signals_Clear_process_signals( signo );
4000fb5c: 40 00 00 04 call 4000fb6c <_POSIX_signals_Clear_process_signals>
<== NOT EXECUTED
4000fb60: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
4000fb64: 10 bf ff db b 4000fad0 <_POSIX_signals_Clear_signals+0xb8>
<== NOT EXECUTED
4000fb68: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
40011e68 <_POSIX_signals_Default_vectors>:
40011e68: 00 00 00 00 ff ff ff ff 00 00 00 01 00 00 00 00 ................
40011e78: ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff ....@...........
40011e88: 40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c @...........@...
40011e98: 00 00 00 00 ff ff ff ff 40 00 f2 9c 00 00 00 00 ........@.......
40011ea8: ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff ....@...........
40011eb8: 40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c @...........@...
40011ec8: 00 00 00 00 ff ff ff ff 40 00 f2 9c 00 00 00 00 ........@.......
40011ed8: ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff ....@...........
40011ee8: 40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c @...........@...
40011ef8: 00 00 00 00 ff ff ff ff 40 00 f2 9c 00 00 00 00 ........@.......
40011f08: ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff ....@...........
40011f18: 40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c @...........@...
40011f28: 00 00 00 00 ff ff ff ff 40 00 f2 9c 00 00 00 00 ........@.......
40011f38: ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff ....@...........
40011f48: 40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c @...........@...
40011f58: 00 00 00 00 ff ff ff ff 40 00 f2 9c 00 00 00 00 ........@.......
40011f68: ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff ....@...........
40011f78: 40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c @...........@...
40011f88: 00 00 00 00 ff ff ff ff 40 00 f2 9c 00 00 00 00 ........@.......
40011f98: ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff ....@...........
40011fa8: 40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c @...........@...
40011fb8: 00 00 00 00 ff ff ff ff 40 00 f2 9c 00 00 00 00 ........@.......
40011fc8: ff ff ff ff 40 00 f2 9c 00 00 00 00 ff ff ff ff ....@...........
40011fd8: 40 00 f2 9c 00 00 00 00 ff ff ff ff 40 00 f2 9c @...........@...
4000ee6c <_POSIX_signals_Send>:
int _POSIX_signals_Send(
pid_t pid,
int sig,
const union sigval *value
)
{
4000ee6c: 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() )
4000ee70: 7f ff f9 05 call 4000d284 <getpid>
<== NOT EXECUTED
4000ee74: 01 00 00 00 nop
<== NOT EXECUTED
4000ee78: 80 a2 00 18 cmp %o0, %i0
<== NOT EXECUTED
4000ee7c: 12 80 00 e7 bne 4000f218 <_POSIX_signals_Send+0x3ac>
<== NOT EXECUTED
4000ee80: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
4000ee84: 02 80 00 df be 4000f200 <_POSIX_signals_Send+0x394>
<== NOT EXECUTED
4000ee88: b8 06 7f ff add %i1, -1, %i4
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
4000ee8c: 80 a7 20 1f cmp %i4, 0x1f
<== NOT EXECUTED
4000ee90: 18 80 00 dc bgu 4000f200 <_POSIX_signals_Send+0x394>
<== NOT EXECUTED
4000ee94: 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 )
4000ee98: 37 10 00 53 sethi %hi(0x40014c00), %i3
<== NOT EXECUTED
4000ee9c: ba 07 40 19 add %i5, %i1, %i5
<== NOT EXECUTED
4000eea0: b6 16 e3 90 or %i3, 0x390, %i3
<== NOT EXECUTED
4000eea4: 83 2f 60 02 sll %i5, 2, %g1
<== NOT EXECUTED
4000eea8: 82 06 c0 01 add %i3, %g1, %g1
<== NOT EXECUTED
4000eeac: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
4000eeb0: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000eeb4: 02 80 00 56 be 4000f00c <_POSIX_signals_Send+0x1a0>
<== NOT EXECUTED
4000eeb8: 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 ) )
4000eebc: 82 06 7f fc add %i1, -4, %g1
<== NOT EXECUTED
4000eec0: 80 88 7f fb btst -5, %g1
<== NOT EXECUTED
4000eec4: 02 80 00 46 be 4000efdc <_POSIX_signals_Send+0x170>
<== NOT EXECUTED
4000eec8: 80 a6 60 0b cmp %i1, 0xb
<== NOT EXECUTED
4000eecc: 02 80 00 44 be 4000efdc <_POSIX_signals_Send+0x170>
<== NOT EXECUTED
4000eed0: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
4000eed4: f2 27 bf f4 st %i1, [ %fp + -12 ]
<== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
4000eed8: b9 28 40 1c sll %g1, %i4, %i4
<== NOT EXECUTED
siginfo->si_code = SI_USER;
if ( !value ) {
4000eedc: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4000eee0: 02 80 00 99 be 4000f144 <_POSIX_signals_Send+0x2d8>
<== NOT EXECUTED
4000eee4: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
4000eee8: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
4000eeec: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000eef0: b4 10 00 06 mov %g6, %i2
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000eef4: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
return cpu->executing;
4000eef8: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000eefc: 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 ) ) {
4000ef00: c4 02 21 5c ld [ %o0 + 0x15c ], %g2
<== NOT EXECUTED
4000ef04: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
4000ef08: c2 00 a0 68 ld [ %g2 + 0x68 ], %g1
<== NOT EXECUTED
4000ef0c: 80 8f 00 01 btst %i4, %g1
<== NOT EXECUTED
4000ef10: 12 80 00 1a bne 4000ef78 <_POSIX_signals_Send+0x10c>
<== NOT EXECUTED
4000ef14: 03 10 00 4d sethi %hi(0x40013400), %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;
4000ef18: c4 00 60 dc ld [ %g1 + 0xdc ], %g2 ! 400134dc <_POSIX_signals_Wait_queue>
<== NOT EXECUTED
if ( heads != NULL ) {
4000ef1c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000ef20: 02 80 00 3d be 4000f014 <_POSIX_signals_Send+0x1a8>
<== NOT EXECUTED
4000ef24: 17 10 00 46 sethi %hi(0x40011800), %o3
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000ef28: c2 00 80 00 ld [ %g2 ], %g1
<== NOT EXECUTED
return &the_chain->Tail.Node;
4000ef2c: 84 00 a0 04 add %g2, 4, %g2
<== NOT EXECUTED
Chain_Control *the_chain = &heads->Heads.Fifo;
for ( the_node = _Chain_First( the_chain );
4000ef30: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4000ef34: 32 80 00 0d bne,a 4000ef68 <_POSIX_signals_Send+0xfc>
<== NOT EXECUTED
4000ef38: d0 00 7f f8 ld [ %g1 + -8 ], %o0
<== NOT EXECUTED
4000ef3c: 10 80 00 37 b 4000f018 <_POSIX_signals_Send+0x1ac>
<== NOT EXECUTED
4000ef40: 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)
4000ef44: c6 01 20 68 ld [ %g4 + 0x68 ], %g3
<== NOT EXECUTED
4000ef48: 80 8f 00 03 btst %i4, %g3
<== NOT EXECUTED
4000ef4c: 12 80 00 0c bne 4000ef7c <_POSIX_signals_Send+0x110>
<== NOT EXECUTED
4000ef50: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
the_node = the_node->next ) {
4000ef54: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
4000ef58: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4000ef5c: 02 80 00 2e be 4000f014 <_POSIX_signals_Send+0x1a8>
<== NOT EXECUTED
4000ef60: 17 10 00 46 sethi %hi(0x40011800), %o3
<== NOT EXECUTED
4000ef64: d0 00 7f f8 ld [ %g1 + -8 ], %o0
<== NOT EXECUTED
if (the_thread->Wait.option & mask)
4000ef68: c6 02 20 48 ld [ %o0 + 0x48 ], %g3
<== NOT EXECUTED
4000ef6c: 80 8f 00 03 btst %i4, %g3
<== NOT EXECUTED
4000ef70: 02 bf ff f5 be 4000ef44 <_POSIX_signals_Send+0xd8>
<== NOT EXECUTED
4000ef74: 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 ) ) {
4000ef78: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
4000ef7c: 40 00 01 60 call 4000f4fc <_POSIX_signals_Unblock_thread>
<== NOT EXECUTED
4000ef80: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000ef84: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000ef88: 12 80 00 1b bne 4000eff4 <_POSIX_signals_Send+0x188>
<== NOT EXECUTED
4000ef8c: 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 );
4000ef90: 40 00 00 f0 call 4000f350 <_POSIX_signals_Set_process_signals>
<== NOT EXECUTED
4000ef94: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000ef98: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000ef9c: 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 ) {
4000efa0: bb 2f 60 02 sll %i5, 2, %i5
<== NOT EXECUTED
4000efa4: c4 06 c0 1d ld [ %i3 + %i5 ], %g2
<== NOT EXECUTED
4000efa8: 80 a0 a0 02 cmp %g2, 2
<== NOT EXECUTED
4000efac: 02 80 00 6c be 4000f15c <_POSIX_signals_Send+0x2f0>
<== NOT EXECUTED
4000efb0: 09 10 00 54 sethi %hi(0x40015000), %g4
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000efb4: 82 10 00 03 mov %g3, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000efb8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000efbc: 01 00 00 00 nop
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000efc0: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000efc4: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000efc8: 02 80 00 7f be 4000f1c4 <_POSIX_signals_Send+0x358>
<== NOT EXECUTED
4000efcc: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000efd0: 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;
}
4000efd4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000efd8: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
return pthread_kill( pthread_self(), sig );
4000efdc: 7f ff fb 6c call 4000dd8c <pthread_self>
<== NOT EXECUTED
4000efe0: 01 00 00 00 nop
<== NOT EXECUTED
4000efe4: 40 00 02 2a call 4000f88c <pthread_kill>
<== NOT EXECUTED
4000efe8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000efec: 81 c7 e0 08 ret
<== NOT EXECUTED
4000eff0: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000eff4: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000eff8: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000effc: 02 80 00 72 be 4000f1c4 <_POSIX_signals_Send+0x358>
<== NOT EXECUTED
4000f000: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
return 0;
4000f004: b0 10 20 00 clr %i0
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000f008: c2 26 a0 18 st %g1, [ %i2 + 0x18 ]
<== NOT EXECUTED
4000f00c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f010: 81 e8 00 00 restore
<== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
4000f014: 9e 10 3f ff mov -1, %o7
<== NOT EXECUTED
4000f018: 94 10 3f ff mov -1, %o2
<== NOT EXECUTED
4000f01c: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000f020: 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);
4000f024: 13 04 00 00 sethi %hi(0x10000000), %o1
<== NOT EXECUTED
4000f028: 96 12 e2 84 or %o3, 0x284, %o3
<== NOT EXECUTED
if ( !_Objects_Information_table[ the_api ] )
4000f02c: 83 2b 20 02 sll %o4, 2, %g1
<== NOT EXECUTED
4000f030: c2 02 c0 01 ld [ %o3 + %g1 ], %g1
<== NOT EXECUTED
4000f034: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000f038: 02 80 00 39 be 4000f11c <_POSIX_signals_Send+0x2b0>
<== NOT EXECUTED
4000f03c: 80 a3 20 03 cmp %o4, 3
<== NOT EXECUTED
the_info = _Objects_Information_table[ the_api ][ 1 ];
4000f040: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
if ( !the_info )
4000f044: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000f048: 02 80 00 35 be 4000f11c <_POSIX_signals_Send+0x2b0>
<== NOT EXECUTED
4000f04c: 80 a3 20 03 cmp %o4, 3
<== NOT EXECUTED
maximum = the_info->maximum;
4000f050: f0 10 60 10 lduh [ %g1 + 0x10 ], %i0
<== NOT EXECUTED
for ( index = 1 ; index <= maximum ; index++ ) {
4000f054: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4000f058: 02 80 00 30 be 4000f118 <_POSIX_signals_Send+0x2ac>
<== NOT EXECUTED
4000f05c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
4000f060: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
4000f064: b1 2e 20 02 sll %i0, 2, %i0
<== NOT EXECUTED
4000f068: b0 06 00 01 add %i0, %g1, %i0
<== NOT EXECUTED
the_thread = (Thread_Control *) object_table[ index ];
4000f06c: c4 00 40 00 ld [ %g1 ], %g2
<== NOT EXECUTED
if ( !the_thread )
4000f070: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000f074: 22 80 00 26 be,a 4000f10c <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
4000f078: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
4000f07c: c6 00 a0 38 ld [ %g2 + 0x38 ], %g3
<== NOT EXECUTED
4000f080: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
<== NOT EXECUTED
if ( _Thread_Get_priority( the_thread ) > interested_priority )
4000f084: 80 a1 00 0f cmp %g4, %o7
<== NOT EXECUTED
4000f088: 18 80 00 20 bgu 4000f108 <_POSIX_signals_Send+0x29c>
<== NOT EXECUTED
4000f08c: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
<== NOT EXECUTED
4000f090: 02 80 00 29 be 4000f134 <_POSIX_signals_Send+0x2c8>
<== NOT EXECUTED
4000f094: 80 a0 c0 0a cmp %g3, %o2
<== NOT EXECUTED
if ( !_POSIX_signals_Is_interested( api, mask ) )
4000f098: da 00 a1 5c ld [ %g2 + 0x15c ], %o5
<== NOT EXECUTED
4000f09c: da 03 60 68 ld [ %o5 + 0x68 ], %o5
<== NOT EXECUTED
4000f0a0: 80 8f 00 0d btst %i4, %o5
<== NOT EXECUTED
4000f0a4: 02 80 00 19 be 4000f108 <_POSIX_signals_Send+0x29c>
<== NOT EXECUTED
4000f0a8: 80 a3 c0 04 cmp %o7, %g4
<== NOT EXECUTED
if ( _Thread_Get_priority( the_thread ) < interested_priority ) {
4000f0ac: 38 80 00 15 bgu,a 4000f100 <_POSIX_signals_Send+0x294>
<== NOT EXECUTED
4000f0b0: 9e 10 00 04 mov %g4, %o7
<== NOT EXECUTED
4000f0b4: 02 80 00 26 be 4000f14c <_POSIX_signals_Send+0x2e0>
<== NOT EXECUTED
4000f0b8: 80 a2 80 03 cmp %o2, %g3
<== NOT EXECUTED
if ( interested && !_States_Is_ready( interested->current_state ) ) {
4000f0bc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000f0c0: 22 80 00 13 be,a 4000f10c <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
4000f0c4: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
4000f0c8: da 02 20 1c ld [ %o0 + 0x1c ], %o5
<== NOT EXECUTED
4000f0cc: 80 a3 60 00 cmp %o5, 0
<== NOT EXECUTED
4000f0d0: 22 80 00 0f be,a 4000f10c <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
4000f0d4: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
if ( _States_Is_ready( the_thread->current_state ) ) {
4000f0d8: e0 00 a0 1c ld [ %g2 + 0x1c ], %l0
<== NOT EXECUTED
4000f0dc: 80 a4 20 00 cmp %l0, 0
<== NOT EXECUTED
4000f0e0: 02 80 00 07 be 4000f0fc <_POSIX_signals_Send+0x290>
<== NOT EXECUTED
4000f0e4: 80 8b 40 09 btst %o5, %o1
<== NOT EXECUTED
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
4000f0e8: 32 80 00 09 bne,a 4000f10c <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
4000f0ec: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
4000f0f0: 80 8c 00 09 btst %l0, %o1
<== NOT EXECUTED
4000f0f4: 22 80 00 06 be,a 4000f10c <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
4000f0f8: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
4000f0fc: 9e 10 00 04 mov %g4, %o7
<== NOT EXECUTED
4000f100: 94 10 00 03 mov %g3, %o2
<== NOT EXECUTED
4000f104: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
4000f108: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
for ( index = 1 ; index <= maximum ; index++ ) {
4000f10c: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
4000f110: 32 bf ff d8 bne,a 4000f070 <_POSIX_signals_Send+0x204>
<== NOT EXECUTED
4000f114: c4 00 40 00 ld [ %g1 ], %g2
<== NOT EXECUTED
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
4000f118: 80 a3 20 03 cmp %o4, 3
<== NOT EXECUTED
4000f11c: 12 bf ff c4 bne 4000f02c <_POSIX_signals_Send+0x1c0>
<== NOT EXECUTED
4000f120: 98 10 20 03 mov 3, %o4
<== NOT EXECUTED
if ( interested ) {
4000f124: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000f128: 12 bf ff 95 bne 4000ef7c <_POSIX_signals_Send+0x110>
<== NOT EXECUTED
4000f12c: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
4000f130: 30 bf ff 98 b,a 4000ef90 <_POSIX_signals_Send+0x124>
<== NOT EXECUTED
if ( _Thread_Get_priority( the_thread ) > interested_priority )
4000f134: 28 bf ff da bleu,a 4000f09c <_POSIX_signals_Send+0x230>
<== NOT EXECUTED
4000f138: da 00 a1 5c ld [ %g2 + 0x15c ], %o5
<== NOT EXECUTED
4000f13c: 10 bf ff f4 b 4000f10c <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
4000f140: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
4000f144: 10 bf ff 6b b 4000eef0 <_POSIX_signals_Send+0x84>
<== NOT EXECUTED
4000f148: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
if ( _Thread_Get_priority( the_thread ) < interested_priority ) {
4000f14c: 08 bf ff dd bleu 4000f0c0 <_POSIX_signals_Send+0x254>
<== NOT EXECUTED
4000f150: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000f154: 10 bf ff eb b 4000f100 <_POSIX_signals_Send+0x294>
<== NOT EXECUTED
4000f158: 9e 10 00 04 mov %g4, %o7
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000f15c: c4 01 21 10 ld [ %g4 + 0x110 ], %g2
<== NOT EXECUTED
4000f160: b8 11 21 10 or %g4, 0x110, %i4
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
4000f164: b6 07 20 04 add %i4, 4, %i3
<== NOT EXECUTED
4000f168: 80 a0 80 1b cmp %g2, %i3
<== NOT EXECUTED
4000f16c: 02 80 00 31 be 4000f230 <_POSIX_signals_Send+0x3c4>
<== NOT EXECUTED
4000f170: 01 00 00 00 nop
<== NOT EXECUTED
new_first = old_first->next;
4000f174: c2 00 80 00 ld [ %g2 ], %g1
<== NOT EXECUTED
new_first->previous = head;
4000f178: f8 20 60 04 st %i4, [ %g1 + 4 ]
<== NOT EXECUTED
psiginfo->Info = *siginfo;
4000f17c: f6 07 bf fc ld [ %fp + -4 ], %i3
<== NOT EXECUTED
4000f180: f2 07 bf f8 ld [ %fp + -8 ], %i1
<== NOT EXECUTED
head->next = new_first;
4000f184: c2 21 21 10 st %g1, [ %g4 + 0x110 ]
<== NOT EXECUTED
_Chain_Append_unprotected(
4000f188: 03 10 00 54 sethi %hi(0x40015000), %g1
<== NOT EXECUTED
psiginfo->Info = *siginfo;
4000f18c: c8 07 bf f4 ld [ %fp + -12 ], %g4
<== NOT EXECUTED
4000f190: c8 20 a0 08 st %g4, [ %g2 + 8 ]
<== NOT EXECUTED
_Chain_Append_unprotected(
4000f194: 82 10 61 20 or %g1, 0x120, %g1
<== NOT EXECUTED
psiginfo->Info = *siginfo;
4000f198: f2 20 a0 0c st %i1, [ %g2 + 0xc ]
<== NOT EXECUTED
_Chain_Append_unprotected(
4000f19c: b8 07 40 01 add %i5, %g1, %i4
<== NOT EXECUTED
return &the_chain->Tail.Node;
4000f1a0: ba 07 60 04 add %i5, 4, %i5
<== NOT EXECUTED
old_last = tail->previous;
4000f1a4: c8 07 20 08 ld [ %i4 + 8 ], %g4
<== NOT EXECUTED
return &the_chain->Tail.Node;
4000f1a8: ba 07 40 01 add %i5, %g1, %i5
<== NOT EXECUTED
psiginfo->Info = *siginfo;
4000f1ac: f6 20 a0 10 st %i3, [ %g2 + 0x10 ]
<== NOT EXECUTED
the_node->next = tail;
4000f1b0: fa 20 80 00 st %i5, [ %g2 ]
<== NOT EXECUTED
tail->previous = the_node;
4000f1b4: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
4000f1b8: c4 21 00 00 st %g2, [ %g4 ]
<== NOT EXECUTED
the_node->previous = old_last;
4000f1bc: 10 bf ff 7e b 4000efb4 <_POSIX_signals_Send+0x148>
<== NOT EXECUTED
4000f1c0: c8 20 a0 04 st %g4, [ %g2 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000f1c4: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000f1c8: c4 0e a0 1c ldub [ %i2 + 0x1c ], %g2
<== NOT EXECUTED
4000f1cc: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000f1d0: 12 80 00 07 bne 4000f1ec <_POSIX_signals_Send+0x380>
<== NOT EXECUTED
4000f1d4: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4000f1d8: c0 26 a0 18 clr [ %i2 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f1dc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f1e0: 01 00 00 00 nop
<== NOT EXECUTED
return 0;
4000f1e4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f1e8: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
4000f1ec: c2 27 bf ec st %g1, [ %fp + -20 ]
<== NOT EXECUTED
4000f1f0: 7f ff fd f3 call 4000e9bc <_Thread_Do_dispatch>
<== NOT EXECUTED
4000f1f4: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
4000f1f8: 10 bf ff f9 b 4000f1dc <_POSIX_signals_Send+0x370>
<== NOT EXECUTED
4000f1fc: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
4000f200: 40 00 02 7c call 4000fbf0 <__errno>
<== NOT EXECUTED
4000f204: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000f208: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4000f20c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000f210: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f214: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ESRCH );
4000f218: 40 00 02 76 call 4000fbf0 <__errno>
<== NOT EXECUTED
4000f21c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000f220: 82 10 20 03 mov 3, %g1
<== NOT EXECUTED
4000f224: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000f228: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f22c: 81 e8 00 00 restore
<== NOT EXECUTED
4000f230: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f234: 01 00 00 00 nop
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000f238: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000f23c: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000f240: 02 80 00 09 be 4000f264 <_POSIX_signals_Send+0x3f8>
<== NOT EXECUTED
4000f244: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000f248: c2 26 a0 18 st %g1, [ %i2 + 0x18 ]
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EAGAIN );
4000f24c: 40 00 02 69 call 4000fbf0 <__errno>
<== NOT EXECUTED
4000f250: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000f254: 82 10 20 0b mov 0xb, %g1
<== NOT EXECUTED
4000f258: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000f25c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f260: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000f264: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000f268: c4 0e a0 1c ldub [ %i2 + 0x1c ], %g2
<== NOT EXECUTED
4000f26c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000f270: 12 80 00 06 bne 4000f288 <_POSIX_signals_Send+0x41c>
<== NOT EXECUTED
4000f274: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4000f278: c0 26 a0 18 clr [ %i2 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f27c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f280: 01 00 00 00 nop
<== NOT EXECUTED
4000f284: 30 bf ff f2 b,a 4000f24c <_POSIX_signals_Send+0x3e0>
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
4000f288: c2 27 bf ec st %g1, [ %fp + -20 ]
<== NOT EXECUTED
4000f28c: 7f ff fd cc call 4000e9bc <_Thread_Do_dispatch>
<== NOT EXECUTED
4000f290: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
4000f294: 10 bf ff fa b 4000f27c <_POSIX_signals_Send+0x410>
<== NOT EXECUTED
4000f298: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
4000f350 <_POSIX_signals_Set_process_signals>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000f350: 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;
4000f354: 07 10 00 54 sethi %hi(0x40015000), %g3
<== NOT EXECUTED
4000f358: c4 00 e1 1c ld [ %g3 + 0x11c ], %g2 ! 4001511c <_POSIX_signals_Pending>
<== NOT EXECUTED
4000f35c: 90 10 80 08 or %g2, %o0, %o0
<== NOT EXECUTED
4000f360: d0 20 e1 1c st %o0, [ %g3 + 0x11c ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f364: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f368: 01 00 00 00 nop
<== NOT EXECUTED
_POSIX_signals_Release( &queue_context );
}
4000f36c: 81 c3 e0 08 retl
<== NOT EXECUTED
4000f370: 01 00 00 00 nop
<== NOT EXECUTED
4000f4fc <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
4000f4fc: 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 ];
4000f500: 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 ) ) {
4000f504: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
<== NOT EXECUTED
4000f508: 05 04 00 01 sethi %hi(0x10000400), %g2
<== NOT EXECUTED
4000f50c: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
4000f510: 82 06 7f ff add %i1, -1, %g1
<== NOT EXECUTED
4000f514: b8 08 c0 02 and %g3, %g2, %i4
<== NOT EXECUTED
4000f518: 83 29 00 01 sll %g4, %g1, %g1
<== NOT EXECUTED
4000f51c: 80 a7 00 02 cmp %i4, %g2
<== NOT EXECUTED
4000f520: 02 80 00 19 be 4000f584 <_POSIX_signals_Unblock_thread+0x88>
<== NOT EXECUTED
4000f524: b6 07 60 70 add %i5, 0x70, %i3
<== NOT EXECUTED
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( api->signals_unblocked & mask ) {
4000f528: c4 07 60 68 ld [ %i5 + 0x68 ], %g2
<== NOT EXECUTED
4000f52c: 80 88 40 02 btst %g1, %g2
<== NOT EXECUTED
4000f530: 02 80 00 05 be 4000f544 <_POSIX_signals_Unblock_thread+0x48>
<== NOT EXECUTED
4000f534: 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 ) ) {
4000f538: 80 88 c0 01 btst %g3, %g1
<== NOT EXECUTED
4000f53c: 12 80 00 4b bne 4000f668 <_POSIX_signals_Unblock_thread+0x16c>
<== NOT EXECUTED
4000f540: 82 10 24 0d mov 0x40d, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000f544: 91 d0 20 09 ta 9
<== NOT EXECUTED
action->handler = handler;
4000f548: 05 10 00 3d sethi %hi(0x4000f400), %g2
<== NOT EXECUTED
4000f54c: 84 10 a0 10 or %g2, 0x10, %g2 ! 4000f410 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
4000f550: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
cpu_self->dispatch_necessary = true;
4000f554: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
4000f558: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
<== NOT EXECUTED
if ( _Chain_Is_node_off_chain( the_node ) ) {
4000f55c: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
4000f560: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000f564: 22 80 00 1a be,a 4000f5cc <_POSIX_signals_Unblock_thread+0xd0>
<== NOT EXECUTED
4000f568: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f56c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f570: 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 );
4000f574: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
}
4000f578: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
4000f57c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f580: 81 e8 00 00 restore
<== NOT EXECUTED
if ( (the_thread->Wait.option & mask) || (api->signals_unblocked & mask) ) {
4000f584: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
<== NOT EXECUTED
4000f588: 80 88 40 02 btst %g1, %g2
<== NOT EXECUTED
4000f58c: 32 80 00 16 bne,a 4000f5e4 <_POSIX_signals_Unblock_thread+0xe8>
<== NOT EXECUTED
4000f590: 82 10 24 0d mov 0x40d, %g1
<== NOT EXECUTED
4000f594: c4 07 60 68 ld [ %i5 + 0x68 ], %g2
<== NOT EXECUTED
4000f598: 80 88 40 02 btst %g1, %g2
<== NOT EXECUTED
4000f59c: 12 80 00 12 bne 4000f5e4 <_POSIX_signals_Unblock_thread+0xe8>
<== NOT EXECUTED
4000f5a0: 82 10 24 0d mov 0x40d, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000f5a4: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000f5a8: 05 10 00 3d sethi %hi(0x4000f400), %g2
<== NOT EXECUTED
4000f5ac: 84 10 a0 10 or %g2, 0x10, %g2 ! 4000f410 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
4000f5b0: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
4000f5b4: c8 29 a0 1c stb %g4, [ %g6 + 0x1c ]
<== NOT EXECUTED
4000f5b8: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
4000f5bc: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000f5c0: 12 bf ff eb bne 4000f56c <_POSIX_signals_Unblock_thread+0x70>
<== NOT EXECUTED
4000f5c4: 01 00 00 00 nop
<== NOT EXECUTED
old_last = tail->previous;
4000f5c8: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
return &the_chain->Tail.Node;
4000f5cc: 86 06 20 e4 add %i0, 0xe4, %g3
<== NOT EXECUTED
the_node->next = tail;
4000f5d0: c6 27 60 70 st %g3, [ %i5 + 0x70 ]
<== NOT EXECUTED
tail->previous = the_node;
4000f5d4: f6 26 20 e8 st %i3, [ %i0 + 0xe8 ]
<== NOT EXECUTED
old_last->next = the_node;
4000f5d8: f6 20 80 00 st %i3, [ %g2 ]
<== NOT EXECUTED
the_node->previous = old_last;
4000f5dc: 10 bf ff e4 b 4000f56c <_POSIX_signals_Unblock_thread+0x70>
<== NOT EXECUTED
4000f5e0: c4 27 60 74 st %g2, [ %i5 + 0x74 ]
<== NOT EXECUTED
the_thread->Wait.return_code = STATUS_INTERRUPTED;
4000f5e4: c2 26 20 4c st %g1, [ %i0 + 0x4c ]
<== NOT EXECUTED
if ( !info ) {
4000f5e8: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4000f5ec: 02 80 00 2e be 4000f6a4 <_POSIX_signals_Unblock_thread+0x1a8>
<== NOT EXECUTED
4000f5f0: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
<== NOT EXECUTED
*the_info = *info;
4000f5f4: c4 06 80 00 ld [ %i2 ], %g2
<== NOT EXECUTED
4000f5f8: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
4000f5fc: c4 06 a0 04 ld [ %i2 + 4 ], %g2
<== NOT EXECUTED
4000f600: c4 20 60 04 st %g2, [ %g1 + 4 ]
<== NOT EXECUTED
4000f604: c4 06 a0 08 ld [ %i2 + 8 ], %g2
<== NOT EXECUTED
4000f608: c4 20 60 08 st %g2, [ %g1 + 8 ]
<== NOT EXECUTED
_Thread_queue_Extract_with_proxy( the_thread );
4000f60c: 7f ff fd 46 call 4000eb24 <_Thread_queue_Extract_with_proxy>
<== NOT EXECUTED
4000f610: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000f614: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000f618: 05 10 00 3d sethi %hi(0x4000f400), %g2
<== NOT EXECUTED
4000f61c: 84 10 a0 10 or %g2, 0x10, %g2 ! 4000f410 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
4000f620: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
4000f624: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
4000f628: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
<== NOT EXECUTED
if ( _Chain_Is_node_off_chain( the_node ) ) {
4000f62c: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
4000f630: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000f634: 12 80 00 07 bne 4000f650 <_POSIX_signals_Unblock_thread+0x154>
<== NOT EXECUTED
4000f638: 86 06 20 e4 add %i0, 0xe4, %g3
<== NOT EXECUTED
old_last = tail->previous;
4000f63c: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
the_node->next = tail;
4000f640: c6 27 60 70 st %g3, [ %i5 + 0x70 ]
<== NOT EXECUTED
tail->previous = the_node;
4000f644: f6 26 20 e8 st %i3, [ %i0 + 0xe8 ]
<== NOT EXECUTED
old_last->next = the_node;
4000f648: f6 20 80 00 st %i3, [ %g2 ]
<== NOT EXECUTED
the_node->previous = old_last;
4000f64c: c4 27 60 74 st %g2, [ %i5 + 0x74 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f650: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f654: 01 00 00 00 nop
<== NOT EXECUTED
return _POSIX_signals_Unblock_thread_done( the_thread, api, true );
4000f658: b0 10 20 01 mov 1, %i0 ! 1 <_TLS_Alignment>
<== NOT EXECUTED
}
4000f65c: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
4000f660: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f664: 81 e8 00 00 restore
<== NOT EXECUTED
the_thread->Wait.return_code = STATUS_INTERRUPTED;
4000f668: c2 26 20 4c st %g1, [ %i0 + 0x4c ]
<== NOT EXECUTED
_Thread_queue_Extract_with_proxy( the_thread );
4000f66c: 7f ff fd 2e call 4000eb24 <_Thread_queue_Extract_with_proxy>
<== NOT EXECUTED
4000f670: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000f674: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000f678: 05 10 00 3d sethi %hi(0x4000f400), %g2
<== NOT EXECUTED
4000f67c: 84 10 a0 10 or %g2, 0x10, %g2 ! 4000f410 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
4000f680: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
4000f684: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
4000f688: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
<== NOT EXECUTED
if ( _Chain_Is_node_off_chain( the_node ) ) {
4000f68c: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
4000f690: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000f694: 12 bf ff b6 bne 4000f56c <_POSIX_signals_Unblock_thread+0x70>
<== NOT EXECUTED
4000f698: 01 00 00 00 nop
<== NOT EXECUTED
old_last = tail->previous;
4000f69c: 10 bf ff cc b 4000f5cc <_POSIX_signals_Unblock_thread+0xd0>
<== NOT EXECUTED
4000f6a0: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
the_info->si_code = SI_USER;
4000f6a4: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
the_info->si_signo = signo;
4000f6a8: f2 20 40 00 st %i1, [ %g1 ]
<== NOT EXECUTED
the_info->si_code = SI_USER;
4000f6ac: c4 20 60 04 st %g2, [ %g1 + 4 ]
<== NOT EXECUTED
4000f6b0: 10 bf ff d7 b 4000f60c <_POSIX_signals_Unblock_thread+0x110>
<== NOT EXECUTED
4000f6b4: c0 20 60 08 clr [ %g1 + 8 ]
<== NOT EXECUTED
40005c38 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
40005c38: 9d e3 bf a0 save %sp, -96, %sp
if ( !tp )
40005c3c: 80 a6 60 00 cmp %i1, 0
40005c40: 02 80 00 1f be 40005cbc <clock_gettime+0x84>
<== NEVER TAKEN
40005c44: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
40005c48: 02 80 00 18 be 40005ca8 <clock_gettime+0x70>
<== ALWAYS TAKEN
40005c4c: 82 06 3f fe add %i0, -2, %g1
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
40005c50: 80 88 7f fd btst -3, %g1
<== NOT EXECUTED
40005c54: 02 80 00 0a be 40005c7c <clock_gettime+0x44>
<== NOT EXECUTED
40005c58: 80 a6 20 03 cmp %i0, 3
<== NOT EXECUTED
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
40005c5c: 02 80 00 0d be 40005c90 <clock_gettime+0x58>
<== NOT EXECUTED
40005c60: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
40005c64: 40 00 22 5f call 4000e5e0 <__errno>
<== NOT EXECUTED
40005c68: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40005c6c: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40005c70: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return 0;
}
40005c74: 81 c7 e0 08 ret
<== NOT EXECUTED
40005c78: 81 e8 00 00 restore
<== NOT EXECUTED
_Timecounter_Nanouptime( tp );
40005c7c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40005c80: 40 00 09 2a call 40008128 <_Timecounter_Nanouptime>
<== NOT EXECUTED
40005c84: b0 10 20 00 clr %i0
<== NOT EXECUTED
return 0;
40005c88: 81 c7 e0 08 ret
<== NOT EXECUTED
40005c8c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
40005c90: 40 00 22 54 call 4000e5e0 <__errno>
<== NOT EXECUTED
40005c94: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005c98: 82 10 20 58 mov 0x58, %g1
<== NOT EXECUTED
40005c9c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005ca0: 81 c7 e0 08 ret
<== NOT EXECUTED
40005ca4: 81 e8 00 00 restore
<== NOT EXECUTED
_Timecounter_Nanotime( tod );
40005ca8: 90 10 00 19 mov %i1, %o0
40005cac: 40 00 09 5a call 40008214 <_Timecounter_Nanotime>
40005cb0: b0 10 20 00 clr %i0
return 0;
40005cb4: 81 c7 e0 08 ret
40005cb8: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EINVAL );
40005cbc: 40 00 22 49 call 4000e5e0 <__errno>
<== NOT EXECUTED
40005cc0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005cc4: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40005cc8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005ccc: 81 c7 e0 08 ret
<== NOT EXECUTED
40005cd0: 81 e8 00 00 restore
<== NOT EXECUTED
40005e80 <clock_nanosleep>:
if ( clock_id != CLOCK_REALTIME && clock_id != CLOCK_MONOTONIC ) {
40005e80: 80 a2 20 01 cmp %o0, 1
40005e84: 02 80 00 04 be 40005e94 <clock_nanosleep+0x14>
<== ALWAYS TAKEN
40005e88: 80 a2 20 04 cmp %o0, 4
40005e8c: 12 80 00 05 bne 40005ea0 <clock_nanosleep+0x20>
<== NOT EXECUTED
40005e90: 01 00 00 00 nop
<== NOT EXECUTED
40005e94: 82 13 c0 00 mov %o7, %g1
40005e98: 7f ff ff 8c call 40005cc8 <clock_nanosleep.part.6>
40005e9c: 9e 10 40 00 mov %g1, %o7
}
}
return eno;
}
40005ea0: 81 c3 e0 08 retl
<== NOT EXECUTED
40005ea4: 90 10 20 86 mov 0x86, %o0
<== NOT EXECUTED
4000d6c4 <kill>:
int kill(
pid_t pid,
int sig
)
{
return _POSIX_signals_Send( pid, sig, NULL );
4000d6c4: 94 10 20 00 clr %o2
<== NOT EXECUTED
4000d6c8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000d6cc: 40 00 05 e8 call 4000ee6c <_POSIX_signals_Send>
<== NOT EXECUTED
4000d6d0: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40006110 <mq_close>:
*/
int mq_close(
mqd_t mqdes
)
{
40006110: 9d e3 bf 78 save %sp, -136, %sp
_RTEMS_Lock_allocator();
40006114: 40 00 02 46 call 40006a2c <_RTEMS_Lock_allocator>
40006118: 01 00 00 00 nop
Objects_Id id,
Thread_queue_Context *queue_context
)
{
_Thread_queue_Context_initialize( queue_context );
return (POSIX_Message_queue_Control *) _Objects_Get(
4000611c: 92 07 bf dc add %fp, -36, %o1
40006120: 15 10 00 52 sethi %hi(0x40014800), %o2
40006124: 90 10 00 18 mov %i0, %o0
40006128: 40 00 0a 79 call 40008b0c <_Objects_Get>
4000612c: 94 12 a1 d0 or %o2, 0x1d0, %o2
Thread_queue_Context queue_context;
_Objects_Allocator_lock();
the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
if ( the_mq == NULL ) {
40006130: 84 92 20 00 orcc %o0, 0, %g2
40006134: 02 80 00 11 be 40006178 <mq_close+0x68>
<== NEVER TAKEN
40006138: 01 00 00 00 nop
_CORE_message_queue_Acquire_critical(
&the_mq->Message_queue,
&queue_context
);
if ( the_mq->open_count == 0 ) {
4000613c: c2 00 a0 50 ld [ %g2 + 0x50 ], %g1
40006140: 80 a0 60 00 cmp %g1, 0
40006144: 02 80 00 0a be 4000616c <mq_close+0x5c>
<== NEVER TAKEN
40006148: 82 00 7f ff add %g1, -1, %g1
_CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
_Objects_Allocator_unlock();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq->open_count -= 1;
4000614c: c2 20 a0 50 st %g1, [ %g2 + 0x50 ]
_POSIX_Message_queue_Delete( the_mq, &queue_context );
40006150: 92 07 bf dc add %fp, -36, %o1
40006154: 40 00 00 11 call 40006198 <_POSIX_Message_queue_Delete>
40006158: b0 10 20 00 clr %i0
_RTEMS_Unlock_allocator();
4000615c: 40 00 02 39 call 40006a40 <_RTEMS_Unlock_allocator>
40006160: 01 00 00 00 nop
_Objects_Allocator_unlock();
return 0;
}
40006164: 81 c7 e0 08 ret
40006168: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000616c: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006170: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006174: 01 00 00 00 nop
<== NOT EXECUTED
40006178: 40 00 02 32 call 40006a40 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000617c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
40006180: 40 00 26 9c call 4000fbf0 <__errno>
<== NOT EXECUTED
40006184: 01 00 00 00 nop
<== NOT EXECUTED
40006188: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
<== NOT EXECUTED
4000618c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006190: 81 c7 e0 08 ret
<== NOT EXECUTED
40006194: 81 e8 00 00 restore
<== NOT EXECUTED
40006210 <mq_notify>:
int mq_notify(
mqd_t mqdes,
const struct sigevent *notification
)
{
40006210: 9d e3 bf 78 save %sp, -136, %sp
return (POSIX_Message_queue_Control *) _Objects_Get(
40006214: 15 10 00 52 sethi %hi(0x40014800), %o2
40006218: 92 07 bf dc add %fp, -36, %o1
4000621c: 94 12 a1 d0 or %o2, 0x1d0, %o2
40006220: 40 00 0a 3b call 40008b0c <_Objects_Get>
40006224: 90 10 00 18 mov %i0, %o0
POSIX_Message_queue_Control *the_mq;
Thread_queue_Context queue_context;
the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
if ( the_mq == NULL ) {
40006228: 80 a2 20 00 cmp %o0, 0
4000622c: 02 80 00 2f be 400062e8 <mq_notify+0xd8>
<== NEVER TAKEN
40006230: 01 00 00 00 nop
_CORE_message_queue_Acquire_critical(
&the_mq->Message_queue,
&queue_context
);
if ( the_mq->open_count == 0 ) {
40006234: c2 02 20 50 ld [ %o0 + 0x50 ], %g1
40006238: 80 a0 60 00 cmp %g1, 0
4000623c: 02 80 00 28 be 400062dc <mq_notify+0xcc>
<== NEVER TAKEN
40006240: 80 a6 60 00 cmp %i1, 0
_CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
rtems_set_errno_and_return_minus_one( EBADF );
}
if ( notification != NULL ) {
40006244: 22 80 00 18 be,a 400062a4 <mq_notify+0x94>
<== NEVER TAKEN
40006248: c0 22 20 3c clr [ %o0 + 0x3c ]
<== NOT EXECUTED
if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) {
4000624c: c2 02 20 3c ld [ %o0 + 0x3c ], %g1
40006250: 80 a0 60 00 cmp %g1, 0
40006254: 12 80 00 19 bne 400062b8 <mq_notify+0xa8>
<== NEVER TAKEN
40006258: 01 00 00 00 nop
<== NOT EXECUTED
_CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
rtems_set_errno_and_return_minus_one( EBUSY );
}
the_mq->notification = *notification;
4000625c: c2 06 40 00 ld [ %i1 ], %g1
<== NOT EXECUTED
40006260: c2 22 20 54 st %g1, [ %o0 + 0x54 ]
<== NOT EXECUTED
40006264: c2 06 60 04 ld [ %i1 + 4 ], %g1
<== NOT EXECUTED
40006268: c2 22 20 58 st %g1, [ %o0 + 0x58 ]
<== NOT EXECUTED
4000626c: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
40006270: c2 22 20 5c st %g1, [ %o0 + 0x5c ]
<== NOT EXECUTED
40006274: c2 06 60 0c ld [ %i1 + 0xc ], %g1
<== NOT EXECUTED
40006278: c2 22 20 60 st %g1, [ %o0 + 0x60 ]
<== NOT EXECUTED
4000627c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
<== NOT EXECUTED
40006280: c2 22 20 64 st %g1, [ %o0 + 0x64 ]
<== NOT EXECUTED
40006284: 03 10 00 18 sethi %hi(0x40006000), %g1
<== NOT EXECUTED
40006288: 82 10 61 e8 or %g1, 0x1e8, %g1 ! 400061e8 <_POSIX_Message_queue_Notify_handler>
<== NOT EXECUTED
4000628c: c2 22 20 3c st %g1, [ %o0 + 0x3c ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006290: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006294: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006298: 01 00 00 00 nop
_CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL );
}
_CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
return 0;
}
4000629c: 81 c7 e0 08 ret
400062a0: 91 e8 20 00 restore %g0, 0, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400062a4: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400062a8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400062ac: 01 00 00 00 nop
<== NOT EXECUTED
400062b0: 81 c7 e0 08 ret
<== NOT EXECUTED
400062b4: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400062b8: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400062bc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400062c0: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
400062c4: 40 00 26 4b call 4000fbf0 <__errno>
<== NOT EXECUTED
400062c8: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
400062cc: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
400062d0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400062d4: 81 c7 e0 08 ret
<== NOT EXECUTED
400062d8: 81 e8 00 00 restore
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400062dc: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400062e0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400062e4: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
400062e8: 40 00 26 42 call 4000fbf0 <__errno>
<== NOT EXECUTED
400062ec: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
400062f0: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
400062f4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400062f8: 81 c7 e0 08 ret
<== NOT EXECUTED
400062fc: 81 e8 00 00 restore
<== NOT EXECUTED
40006338 <mq_open>:
int oflag,
...
/* mode_t mode, */
/* struct mq_attr attr */
)
{
40006338: 9d e3 bf 90 save %sp, -112, %sp
_POSIX_Get_by_name_error( error ),
MQ_OPEN_FAILED
);
}
va_start( ap, oflag );
4000633c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
const char *name,
size_t *name_length_p,
Objects_Get_by_name_error *error
)
{
return (POSIX_Message_queue_Control *) _Objects_Get_by_name(
40006340: 37 10 00 52 sethi %hi(0x40014800), %i3
40006344: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40006348: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
_RTEMS_Lock_allocator();
4000634c: 40 00 01 b8 call 40006a2c <_RTEMS_Lock_allocator>
40006350: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
40006354: 96 07 bf f8 add %fp, -8, %o3
40006358: 94 07 bf f4 add %fp, -12, %o2
4000635c: 92 10 00 18 mov %i0, %o1
40006360: 40 00 0a 50 call 40008ca0 <_Objects_Get_by_name>
40006364: 90 16 e1 d0 or %i3, 0x1d0, %o0
if ( the_mq == NULL ) {
40006368: 80 a2 20 00 cmp %o0, 0
4000636c: 02 80 00 0e be 400063a4 <mq_open+0x6c>
40006370: c2 07 bf f8 ld [ %fp + -8 ], %g1
/*
* Check for existence with creation.
*/
if ( ( oflag & ( O_CREAT | O_EXCL ) ) == ( O_CREAT | O_EXCL ) ) {
40006374: b2 0e 6a 00 and %i1, 0xa00, %i1
40006378: 80 a6 6a 00 cmp %i1, 0xa00
4000637c: 02 80 00 44 be 4000648c <mq_open+0x154>
<== NEVER TAKEN
40006380: 01 00 00 00 nop
_Objects_Allocator_unlock();
rtems_set_errno_and_return_value( EEXIST, MQ_OPEN_FAILED );
}
the_mq->open_count += 1;
40006384: c2 02 20 50 ld [ %o0 + 0x50 ], %g1
40006388: 82 00 60 01 inc %g1
4000638c: c2 22 20 50 st %g1, [ %o0 + 0x50 ]
status = the_mq->Object.id;
40006390: f0 02 20 08 ld [ %o0 + 8 ], %i0
_RTEMS_Unlock_allocator();
40006394: 40 00 01 ab call 40006a40 <_RTEMS_Unlock_allocator>
40006398: 01 00 00 00 nop
}
_Objects_Allocator_unlock();
return status;
}
4000639c: 81 c7 e0 08 ret
400063a0: 81 e8 00 00 restore
if ( error != OBJECTS_GET_BY_NAME_NO_OBJECT || ( oflag & O_CREAT ) == 0 ) {
400063a4: 80 a0 60 02 cmp %g1, 2
400063a8: 12 80 00 2e bne 40006460 <mq_open+0x128>
<== NEVER TAKEN
400063ac: 80 8e 62 00 btst 0x200, %i1
400063b0: 02 80 00 2c be 40006460 <mq_open+0x128>
<== NEVER TAKEN
400063b4: 82 07 a0 4c add %fp, 0x4c, %g1
va_start( ap, oflag );
400063b8: c2 27 bf fc st %g1, [ %fp + -4 ]
attr = va_arg( ap, const struct mq_attr * );
400063bc: f8 07 a0 50 ld [ %fp + 0x50 ], %i4
if ( attr == NULL ) {
400063c0: 80 a7 20 00 cmp %i4, 0
400063c4: 22 80 00 48 be,a 400064e4 <mq_open+0x1ac>
<== NEVER TAKEN
400063c8: 39 10 00 46 sethi %hi(0x40011800), %i4
<== NOT EXECUTED
if ( attr->mq_maxmsg <= 0 ){
400063cc: c2 07 20 04 ld [ %i4 + 4 ], %g1 ! 40011804 <IMFS_device_handlers+0x20>
400063d0: 80 a0 60 00 cmp %g1, 0
400063d4: 04 80 00 36 ble 400064ac <mq_open+0x174>
<== NEVER TAKEN
400063d8: f4 07 bf f4 ld [ %fp + -12 ], %i2
if ( attr->mq_msgsize <= 0 ){
400063dc: c2 07 20 08 ld [ %i4 + 8 ], %g1
400063e0: 80 a0 60 00 cmp %g1, 0
400063e4: 04 80 00 32 ble 400064ac <mq_open+0x174>
<== NEVER TAKEN
400063e8: 01 00 00 00 nop
return (POSIX_Message_queue_Control *)
400063ec: 40 00 08 9c call 4000865c <_Objects_Allocate_unprotected>
400063f0: 90 16 e1 d0 or %i3, 0x1d0, %o0
if ( !the_mq ) {
400063f4: ba 92 20 00 orcc %o0, 0, %i5
400063f8: 02 80 00 3e be 400064f0 <mq_open+0x1b8>
<== NEVER TAKEN
400063fc: 92 10 00 1a mov %i2, %o1
name = _Workspace_String_duplicate( name_arg, name_len );
40006400: 40 00 17 fa call 4000c3e8 <_Workspace_String_duplicate>
40006404: 90 10 00 18 mov %i0, %o0
if ( !name ) {
40006408: b4 92 20 00 orcc %o0, 0, %i2
4000640c: 02 80 00 3e be 40006504 <mq_open+0x1cc>
<== NEVER TAKEN
40006410: 82 10 20 01 mov 1, %g1
the_mq->open_count = 1;
40006414: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
!_CORE_message_queue_Initialize(
40006418: 92 10 20 00 clr %o1
the_mq->linked = true;
4000641c: c2 2f 60 4c stb %g1, [ %i5 + 0x4c ]
!_CORE_message_queue_Initialize(
40006420: 90 07 60 10 add %i5, 0x10, %o0
the_mq->oflag = oflag;
40006424: f2 27 60 68 st %i1, [ %i5 + 0x68 ]
!_CORE_message_queue_Initialize(
40006428: d6 07 20 08 ld [ %i4 + 8 ], %o3
4000642c: 40 00 01 c3 call 40006b38 <_CORE_message_queue_Initialize>
40006430: d4 07 20 04 ld [ %i4 + 4 ], %o2
if (
40006434: 80 a2 20 00 cmp %o0, 0
40006438: 02 80 00 22 be 400064c0 <mq_open+0x188>
<== NEVER TAKEN
4000643c: 92 10 00 1d mov %i5, %o1
information->local_table[ index ] = the_object;
40006440: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
the_object->name.name_p = name;
40006444: f4 27 60 0c st %i2, [ %i5 + 0xc ]
information->local_table[ index ] = the_object;
40006448: b6 16 e1 d0 or %i3, 0x1d0, %i3
4000644c: c4 06 e0 1c ld [ %i3 + 0x1c ], %g2
40006450: f0 07 60 08 ld [ %i5 + 8 ], %i0
40006454: 83 28 60 02 sll %g1, 2, %g1
40006458: 10 bf ff cf b 40006394 <mq_open+0x5c>
4000645c: fa 20 80 01 st %i5, [ %g2 + %g1 ]
_RTEMS_Unlock_allocator();
40006460: 40 00 01 78 call 40006a40 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40006464: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_set_errno_and_return_value(
40006468: 40 00 25 e2 call 4000fbf0 <__errno>
<== NOT EXECUTED
4000646c: fa 07 bf f8 ld [ %fp + -8 ], %i5
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE int _POSIX_Get_by_name_error(
Objects_Get_by_name_error error
)
{
_Assert( (size_t) error < RTEMS_ARRAY_SIZE( _POSIX_Get_by_name_error_table ) );
return _POSIX_Get_by_name_error_table[ error ];
40006470: bb 2f 60 02 sll %i5, 2, %i5
<== NOT EXECUTED
40006474: 03 10 00 46 sethi %hi(0x40011800), %g1
<== NOT EXECUTED
40006478: 82 10 62 78 or %g1, 0x278, %g1 ! 40011a78 <_POSIX_Get_by_name_error_table>
<== NOT EXECUTED
4000647c: c2 00 40 1d ld [ %g1 + %i5 ], %g1
<== NOT EXECUTED
40006480: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006484: 81 c7 e0 08 ret
<== NOT EXECUTED
40006488: 81 e8 00 00 restore
<== NOT EXECUTED
4000648c: 40 00 01 6d call 40006a40 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40006490: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_set_errno_and_return_value( EEXIST, MQ_OPEN_FAILED );
40006494: 40 00 25 d7 call 4000fbf0 <__errno>
<== NOT EXECUTED
40006498: 01 00 00 00 nop
<== NOT EXECUTED
4000649c: 82 10 20 11 mov 0x11, %g1 ! 11 <_TLS_Alignment+0x10>
<== NOT EXECUTED
400064a0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400064a4: 81 c7 e0 08 ret
<== NOT EXECUTED
400064a8: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_value( EINVAL, MQ_OPEN_FAILED );
400064ac: 40 00 25 d1 call 4000fbf0 <__errno>
<== NOT EXECUTED
400064b0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400064b4: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400064b8: 10 bf ff b7 b 40006394 <mq_open+0x5c>
<== NOT EXECUTED
400064bc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
_Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object );
400064c0: 40 00 09 67 call 40008a5c <_Objects_Free>
<== NOT EXECUTED
400064c4: 90 16 e1 d0 or %i3, 0x1d0, %o0
<== NOT EXECUTED
_Workspace_Free( name );
400064c8: 40 00 17 b3 call 4000c394 <_Workspace_Free>
<== NOT EXECUTED
400064cc: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
rtems_set_errno_and_return_value( ENOSPC, MQ_OPEN_FAILED );
400064d0: 40 00 25 c8 call 4000fbf0 <__errno>
<== NOT EXECUTED
400064d4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400064d8: 82 10 20 1c mov 0x1c, %g1
<== NOT EXECUTED
400064dc: 10 bf ff ae b 40006394 <mq_open+0x5c>
<== NOT EXECUTED
400064e0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
status = _POSIX_Message_queue_Create( name, name_len, oflag, attr );
400064e4: f4 07 bf f4 ld [ %fp + -12 ], %i2
<== NOT EXECUTED
attr = &_POSIX_Message_queue_Default_attributes;
400064e8: 10 bf ff c1 b 400063ec <mq_open+0xb4>
<== NOT EXECUTED
400064ec: b8 17 22 68 or %i4, 0x268, %i4
<== NOT EXECUTED
rtems_set_errno_and_return_value( ENFILE, MQ_OPEN_FAILED );
400064f0: 40 00 25 c0 call 4000fbf0 <__errno>
<== NOT EXECUTED
400064f4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400064f8: 82 10 20 17 mov 0x17, %g1
<== NOT EXECUTED
400064fc: 10 bf ff a6 b 40006394 <mq_open+0x5c>
<== NOT EXECUTED
40006500: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006504: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40006508: 40 00 09 55 call 40008a5c <_Objects_Free>
<== NOT EXECUTED
4000650c: 90 16 e1 d0 or %i3, 0x1d0, %o0
<== NOT EXECUTED
rtems_set_errno_and_return_value( ENOMEM, MQ_OPEN_FAILED );
40006510: 40 00 25 b8 call 4000fbf0 <__errno>
<== NOT EXECUTED
40006514: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006518: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
4000651c: 10 bf ff 9e b 40006394 <mq_open+0x5c>
<== NOT EXECUTED
40006520: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006790 <mq_unlink>:
*/
int mq_unlink(
const char *name
)
{
40006790: 9d e3 bf 78 save %sp, -136, %sp
_RTEMS_Lock_allocator();
40006794: 40 00 00 a6 call 40006a2c <_RTEMS_Lock_allocator>
40006798: 39 10 00 52 sethi %hi(0x40014800), %i4
return (POSIX_Message_queue_Control *) _Objects_Get_by_name(
4000679c: 96 07 bf d8 add %fp, -40, %o3
400067a0: 94 10 20 00 clr %o2
400067a4: 92 10 00 18 mov %i0, %o1
400067a8: 40 00 09 3e call 40008ca0 <_Objects_Get_by_name>
400067ac: 90 17 21 d0 or %i4, 0x1d0, %o0
Thread_queue_Context queue_context;
_Objects_Allocator_lock();
the_mq = _POSIX_Message_queue_Get_by_name( name, NULL, &error );
if ( the_mq == NULL ) {
400067b0: ba 92 20 00 orcc %o0, 0, %i5
400067b4: 02 80 00 0f be 400067f0 <mq_unlink+0x60>
<== NEVER TAKEN
400067b8: 92 10 00 1d mov %i5, %o1
_Objects_Namespace_remove(
400067bc: 40 00 09 2f call 40008c78 <_Objects_Namespace_remove>
400067c0: 90 17 21 d0 or %i4, 0x1d0, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400067c4: 91 d0 20 09 ta 9
<== NOT EXECUTED
Thread_queue_Control *the_thread_queue,
Thread_queue_Context *queue_context
)
{
(void) the_thread_queue;
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
400067c8: c2 27 bf dc st %g1, [ %fp + -36 ]
_POSIX_Message_queue_Namespace_remove( the_mq );
_CORE_message_queue_Acquire( &the_mq->Message_queue, &queue_context );
the_mq->linked = false;
400067cc: c0 2f 60 4c clrb [ %i5 + 0x4c ]
_POSIX_Message_queue_Delete( the_mq, &queue_context );
400067d0: 92 07 bf dc add %fp, -36, %o1
400067d4: 90 10 00 1d mov %i5, %o0
400067d8: 7f ff fe 70 call 40006198 <_POSIX_Message_queue_Delete>
400067dc: b0 10 20 00 clr %i0
_RTEMS_Unlock_allocator();
400067e0: 40 00 00 98 call 40006a40 <_RTEMS_Unlock_allocator>
400067e4: 01 00 00 00 nop
_Objects_Allocator_unlock();
return 0;
}
400067e8: 81 c7 e0 08 ret
400067ec: 81 e8 00 00 restore
400067f0: 40 00 00 94 call 40006a40 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
400067f4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( _POSIX_Get_by_name_error( error ) );
400067f8: 40 00 24 fe call 4000fbf0 <__errno>
<== NOT EXECUTED
400067fc: fa 07 bf d8 ld [ %fp + -40 ], %i5
<== NOT EXECUTED
return _POSIX_Get_by_name_error_table[ error ];
40006800: bb 2f 60 02 sll %i5, 2, %i5
<== NOT EXECUTED
40006804: 03 10 00 46 sethi %hi(0x40011800), %g1
<== NOT EXECUTED
40006808: 82 10 62 78 or %g1, 0x278, %g1 ! 40011a78 <_POSIX_Get_by_name_error_table>
<== NOT EXECUTED
4000680c: c2 00 40 1d ld [ %g1 + %i5 ], %g1
<== NOT EXECUTED
40006810: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006814: 81 c7 e0 08 ret
<== NOT EXECUTED
40006818: 81 e8 00 00 restore
<== NOT EXECUTED
40005e78 <nanosleep>:
{
40005e78: 9d e3 bf a0 save %sp, -96, %sp
40005e7c: 92 10 20 00 clr %o1
40005e80: 94 10 00 18 mov %i0, %o2
40005e84: 96 10 00 19 mov %i1, %o3
40005e88: 7f ff ff 8e call 40005cc0 <clock_nanosleep.part.6>
40005e8c: 90 10 20 01 mov 1, %o0
if ( eno != 0 ) {
40005e90: b0 92 20 00 orcc %o0, 0, %i0
40005e94: 12 80 00 04 bne 40005ea4 <nanosleep+0x2c>
<== NEVER TAKEN
40005e98: 01 00 00 00 nop
}
40005e9c: 81 c7 e0 08 ret
40005ea0: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( eno );
40005ea4: 40 00 21 2b call 4000e350 <__errno>
<== NOT EXECUTED
40005ea8: 01 00 00 00 nop
<== NOT EXECUTED
40005eac: f0 22 00 00 st %i0, [ %o0 ]
<== NOT EXECUTED
}
40005eb0: 81 c7 e0 08 ret
<== NOT EXECUTED
40005eb4: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
4000c05c <pthread_attr_init>:
* 16.1.1 Thread Creation Attributes, P1003.1c/Draft 10, p, 140
*/
int pthread_attr_init(
pthread_attr_t *attr
)
{
4000c05c: 9d e3 bf a0 save %sp, -96, %sp
if ( !attr )
4000c060: 82 96 20 00 orcc %i0, 0, %g1
4000c064: 02 80 00 0b be 4000c090 <pthread_attr_init+0x34>
<== NEVER TAKEN
4000c068: 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;
4000c06c: 90 10 00 01 mov %g1, %o0
4000c070: 13 10 00 3e sethi %hi(0x4000f800), %o1
return EINVAL;
_POSIX_Threads_Initialize_attributes( attr );
return 0;
4000c074: b0 10 20 00 clr %i0
4000c078: 40 00 07 64 call 4000de08 <memcpy>
4000c07c: 92 12 63 40 or %o1, 0x340, %o1
_Assert(
dst_attr->affinitysetsize == sizeof(dst_attr->affinitysetpreallocated)
);
dst_attr->affinityset = &dst_attr->affinitysetpreallocated;
4000c080: 84 02 20 5c add %o0, 0x5c, %g2
4000c084: c4 22 20 58 st %g2, [ %o0 + 0x58 ]
4000c088: 81 c7 e0 08 ret
4000c08c: 81 e8 00 00 restore
}
4000c090: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c094: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
4000c098 <pthread_attr_setinheritsched>:
int pthread_attr_setinheritsched(
pthread_attr_t *attr,
int inheritsched
)
{
if ( !attr || !attr->is_initialized )
4000c098: 82 92 20 00 orcc %o0, 0, %g1
4000c09c: 02 80 00 0c be 4000c0cc <pthread_attr_setinheritsched+0x34>
<== NEVER TAKEN
4000c0a0: 90 10 20 16 mov 0x16, %o0
4000c0a4: c4 00 40 00 ld [ %g1 ], %g2
4000c0a8: 80 a0 a0 00 cmp %g2, 0
4000c0ac: 02 80 00 08 be 4000c0cc <pthread_attr_setinheritsched+0x34>
<== NEVER TAKEN
4000c0b0: 84 02 7f ff add %o1, -1, %g2
return EINVAL;
switch ( inheritsched ) {
4000c0b4: 80 a0 a0 01 cmp %g2, 1
4000c0b8: 18 80 00 05 bgu 4000c0cc <pthread_attr_setinheritsched+0x34>
<== NEVER TAKEN
4000c0bc: 90 10 20 86 mov 0x86, %o0
case PTHREAD_INHERIT_SCHED:
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
4000c0c0: d2 20 60 10 st %o1, [ %g1 + 0x10 ]
return 0;
4000c0c4: 81 c3 e0 08 retl
4000c0c8: 90 10 20 00 clr %o0
default:
return ENOTSUP;
}
}
4000c0cc: 81 c3 e0 08 retl
<== NOT EXECUTED
4000c0d0: 01 00 00 00 nop
<== NOT EXECUTED
40006a10 <pthread_attr_setschedparam>:
int pthread_attr_setschedparam(
pthread_attr_t *attr,
const struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
40006a10: 82 92 20 00 orcc %o0, 0, %g1
40006a14: 02 80 00 16 be 40006a6c <pthread_attr_setschedparam+0x5c>
<== NEVER TAKEN
40006a18: 01 00 00 00 nop
40006a1c: c4 00 40 00 ld [ %g1 ], %g2
40006a20: 80 a0 a0 00 cmp %g2, 0
40006a24: 02 80 00 12 be 40006a6c <pthread_attr_setschedparam+0x5c>
<== NEVER TAKEN
40006a28: 80 a2 60 00 cmp %o1, 0
40006a2c: 02 80 00 10 be 40006a6c <pthread_attr_setschedparam+0x5c>
<== NEVER TAKEN
40006a30: 01 00 00 00 nop
return EINVAL;
attr->schedparam = *param;
40006a34: c4 1a 40 00 ldd [ %o1 ], %g2
40006a38: c4 38 60 18 std %g2, [ %g1 + 0x18 ]
return 0;
40006a3c: 90 10 20 00 clr %o0
attr->schedparam = *param;
40006a40: c4 1a 60 08 ldd [ %o1 + 8 ], %g2
40006a44: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
40006a48: c4 1a 60 10 ldd [ %o1 + 0x10 ], %g2
40006a4c: c4 38 60 28 std %g2, [ %g1 + 0x28 ]
40006a50: c4 1a 60 18 ldd [ %o1 + 0x18 ], %g2
40006a54: c4 38 60 30 std %g2, [ %g1 + 0x30 ]
40006a58: c4 1a 60 20 ldd [ %o1 + 0x20 ], %g2
40006a5c: c4 38 60 38 std %g2, [ %g1 + 0x38 ]
40006a60: c4 1a 60 28 ldd [ %o1 + 0x28 ], %g2
return 0;
40006a64: 81 c3 e0 08 retl
40006a68: c4 38 60 40 std %g2, [ %g1 + 0x40 ]
}
40006a6c: 81 c3 e0 08 retl
<== NOT EXECUTED
40006a70: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
40006a74 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
40006a74: 82 92 20 00 orcc %o0, 0, %g1
40006a78: 02 80 00 10 be 40006ab8 <pthread_attr_setschedpolicy+0x44>
<== NEVER TAKEN
40006a7c: 90 10 20 16 mov 0x16, %o0
40006a80: c4 00 40 00 ld [ %g1 ], %g2
40006a84: 80 a0 a0 00 cmp %g2, 0
40006a88: 02 80 00 0c be 40006ab8 <pthread_attr_setschedpolicy+0x44>
<== NEVER TAKEN
40006a8c: 80 a2 60 04 cmp %o1, 4
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
40006a90: 18 80 00 0a bgu 40006ab8 <pthread_attr_setschedpolicy+0x44>
<== NEVER TAKEN
40006a94: 90 10 20 86 mov 0x86, %o0
40006a98: 84 10 20 01 mov 1, %g2
40006a9c: 85 28 80 09 sll %g2, %o1, %g2
40006aa0: 80 88 a0 17 btst 0x17, %g2
40006aa4: 02 80 00 05 be 40006ab8 <pthread_attr_setschedpolicy+0x44>
<== NEVER TAKEN
40006aa8: 01 00 00 00 nop
attr->schedpolicy = policy;
40006aac: d2 20 60 14 st %o1, [ %g1 + 0x14 ]
return 0;
40006ab0: 81 c3 e0 08 retl
40006ab4: 90 10 20 00 clr %o0
}
}
40006ab8: 81 c3 e0 08 retl
<== NOT EXECUTED
40006abc: 01 00 00 00 nop
<== NOT EXECUTED
4000c0d4 <pthread_attr_setstacksize>:
int pthread_attr_setstacksize(
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
4000c0d4: 82 92 20 00 orcc %o0, 0, %g1
4000c0d8: 02 80 00 09 be 4000c0fc <pthread_attr_setstacksize+0x28>
<== NEVER TAKEN
4000c0dc: 90 10 20 16 mov 0x16, %o0
4000c0e0: c4 00 40 00 ld [ %g1 ], %g2
4000c0e4: 80 a0 a0 00 cmp %g2, 0
4000c0e8: 02 80 00 05 be 4000c0fc <pthread_attr_setstacksize+0x28>
<== NEVER TAKEN
4000c0ec: 01 00 00 00 nop
return EINVAL;
attr->stacksize = stacksize;
4000c0f0: d2 20 60 08 st %o1, [ %g1 + 8 ]
return 0;
4000c0f4: 81 c3 e0 08 retl
4000c0f8: 90 10 20 00 clr %o0
}
4000c0fc: 81 c3 e0 08 retl
<== NOT EXECUTED
4000c100: 01 00 00 00 nop
<== NOT EXECUTED
40005d58 <pthread_barrier_destroy>:
int pthread_barrier_destroy( pthread_barrier_t *_barrier )
{
POSIX_Barrier_Control *barrier;
Thread_queue_Context queue_context;
POSIX_BARRIER_VALIDATE_OBJECT( _barrier );
40005d58: 84 92 20 00 orcc %o0, 0, %g2
40005d5c: 02 80 00 12 be 40005da4 <pthread_barrier_destroy+0x4c>
<== NEVER TAKEN
40005d60: 03 07 3c 0d sethi %hi(0x1cf03400), %g1
40005d64: c6 00 80 00 ld [ %g2 ], %g3
40005d68: 82 10 63 73 or %g1, 0x373, %g1
40005d6c: 82 18 80 01 xor %g2, %g1, %g1
40005d70: 80 a0 40 03 cmp %g1, %g3
40005d74: 12 80 00 0d bne 40005da8 <pthread_barrier_destroy+0x50>
<== NEVER TAKEN
40005d78: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005d7c: 91 d0 20 09 ta 9
<== NOT EXECUTED
barrier = _POSIX_Barrier_Get( _barrier );
_POSIX_Barrier_Queue_acquire( barrier, &queue_context );
if ( barrier->waiting_threads != 0 ) {
40005d80: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
40005d84: 80 a0 e0 00 cmp %g3, 0
40005d88: 12 80 00 0a bne 40005db0 <pthread_barrier_destroy+0x58>
<== NEVER TAKEN
40005d8c: 01 00 00 00 nop
<== NOT EXECUTED
_POSIX_Barrier_Queue_release( barrier, &queue_context );
return EBUSY;
}
barrier->flags = 0;
40005d90: c0 20 80 00 clr [ %g2 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005d94: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005d98: 01 00 00 00 nop
_POSIX_Barrier_Queue_release( barrier, &queue_context );
return 0;
40005d9c: 81 c3 e0 08 retl
40005da0: 90 10 20 00 clr %o0 ! 0 <PROM_START>
POSIX_BARRIER_VALIDATE_OBJECT( _barrier );
40005da4: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
}
40005da8: 81 c3 e0 08 retl
<== NOT EXECUTED
40005dac: 01 00 00 00 nop
<== NOT EXECUTED
40005db0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005db4: 01 00 00 00 nop
<== NOT EXECUTED
return EBUSY;
40005db8: 81 c3 e0 08 retl
<== NOT EXECUTED
40005dbc: 90 10 20 10 mov 0x10, %o0 ! 10 <_TLS_Alignment+0xf>
<== NOT EXECUTED
40005dc0 <pthread_barrier_init>:
*/
if ( barrier == NULL ) {
return EINVAL;
}
if ( count == 0 ) {
40005dc0: 82 92 20 00 orcc %o0, 0, %g1
40005dc4: 02 80 00 19 be 40005e28 <pthread_barrier_init+0x68>
<== NEVER TAKEN
40005dc8: 80 a2 a0 00 cmp %o2, 0
40005dcc: 02 80 00 17 be 40005e28 <pthread_barrier_init+0x68>
<== NEVER TAKEN
40005dd0: 80 a2 60 00 cmp %o1, 0
return EINVAL;
}
if ( attr != NULL ) {
40005dd4: 22 80 00 0b be,a 40005e00 <pthread_barrier_init+0x40>
40005dd8: d4 20 60 18 st %o2, [ %g1 + 0x18 ]
/*
* Now start error checking the attributes that we are going to use
*/
if ( !attr->is_initialized )
40005ddc: c4 02 40 00 ld [ %o1 ], %g2
40005de0: 80 a0 a0 00 cmp %g2, 0
40005de4: 02 80 00 12 be 40005e2c <pthread_barrier_init+0x6c>
<== NEVER TAKEN
40005de8: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !_POSIX_Is_valid_pshared( attr->process_shared ) ) {
40005dec: c4 02 60 04 ld [ %o1 + 4 ], %g2
40005df0: 80 a0 a0 01 cmp %g2, 1
40005df4: 18 80 00 0e bgu 40005e2c <pthread_barrier_init+0x6c>
<== NEVER TAKEN
40005df8: 01 00 00 00 nop
return EINVAL;
}
}
barrier->flags = (uintptr_t) barrier ^ POSIX_BARRIER_MAGIC;
barrier->count = count;
40005dfc: d4 20 60 18 st %o2, [ %g1 + 0x18 ]
barrier->flags = (uintptr_t) barrier ^ POSIX_BARRIER_MAGIC;
40005e00: 05 07 3c 0d sethi %hi(0x1cf03400), %g2
barrier->waiting_threads = 0;
40005e04: c0 20 60 1c clr [ %g1 + 0x1c ]
barrier->flags = (uintptr_t) barrier ^ POSIX_BARRIER_MAGIC;
40005e08: 84 10 a3 73 or %g2, 0x373, %g2
)
{
#if defined(RTEMS_SMP)
_SMP_ticket_lock_Initialize( &queue->Lock );
#endif
queue->heads = NULL;
40005e0c: c0 20 60 0c clr [ %g1 + 0xc ]
40005e10: 84 18 40 02 xor %g1, %g2, %g2
_Thread_queue_Queue_initialize( &barrier->Queue.Queue, NULL );
return 0;
40005e14: 90 10 20 00 clr %o0
barrier->flags = (uintptr_t) barrier ^ POSIX_BARRIER_MAGIC;
40005e18: c4 20 40 00 st %g2, [ %g1 ]
queue->owner = NULL;
40005e1c: c0 20 60 10 clr [ %g1 + 0x10 ]
return 0;
40005e20: 81 c3 e0 08 retl
40005e24: c0 20 60 14 clr [ %g1 + 0x14 ]
return EINVAL;
40005e28: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
}
40005e2c: 81 c3 e0 08 retl
<== NOT EXECUTED
40005e30: 01 00 00 00 nop
<== NOT EXECUTED
40005ea0 <pthread_barrier_wait>:
#include <rtems/posix/barrierimpl.h>
#include <rtems/posix/posixapi.h>
int pthread_barrier_wait( pthread_barrier_t *_barrier )
{
40005ea0: 9d e3 bf 78 save %sp, -136, %sp
POSIX_Barrier_Control *barrier;
Thread_queue_Context queue_context;
Thread_Control *executing;
unsigned int waiting_threads;
POSIX_BARRIER_VALIDATE_OBJECT( _barrier );
40005ea4: 84 96 20 00 orcc %i0, 0, %g2
40005ea8: 02 80 00 1e be 40005f20 <pthread_barrier_wait+0x80>
<== NEVER TAKEN
40005eac: 03 07 3c 0d sethi %hi(0x1cf03400), %g1
40005eb0: c6 00 80 00 ld [ %g2 ], %g3
40005eb4: 82 10 63 73 or %g1, 0x373, %g1
40005eb8: 82 18 80 01 xor %g2, %g1, %g1
40005ebc: 80 a0 40 03 cmp %g1, %g3
40005ec0: 12 80 00 16 bne 40005f18 <pthread_barrier_wait+0x78>
<== NEVER TAKEN
40005ec4: b0 10 20 16 mov 0x16, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005ec8: 91 d0 20 09 ta 9
<== NOT EXECUTED
)
{
#if defined( RTEMS_SMP )
context->Lock_context.isr_level = level;
#else
context->isr_level = level;
40005ecc: c2 27 bf dc st %g1, [ %fp + -36 ]
40005ed0: 90 00 a0 0c add %g2, 0xc, %o0
barrier = _POSIX_Barrier_Get( _barrier );
executing = _POSIX_Barrier_Queue_acquire( barrier, &queue_context );
waiting_threads = barrier->waiting_threads;
40005ed4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1
++waiting_threads;
if ( waiting_threads == barrier->count ) {
40005ed8: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
++waiting_threads;
40005edc: 82 00 60 01 inc %g1
if ( waiting_threads == barrier->count ) {
40005ee0: 80 a0 c0 01 cmp %g3, %g1
40005ee4: 02 80 00 11 be 40005f28 <pthread_barrier_wait+0x88>
40005ee8: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
_Thread_queue_Flush_default_filter,
&queue_context
);
return PTHREAD_BARRIER_SERIAL_THREAD;
} else {
barrier->waiting_threads = waiting_threads;
40005eec: c2 20 a0 1c st %g1, [ %g2 + 0x1c ]
queue_context->thread_state = thread_state;
40005ef0: 82 10 28 00 mov 0x800, %g1
40005ef4: c2 27 bf e0 st %g1, [ %fp + -32 ]
queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;
40005ef8: 03 10 00 28 sethi %hi(0x4000a000), %g1
40005efc: 82 10 63 5c or %g1, 0x35c, %g1 ! 4000a35c <_Thread_queue_Enqueue_do_nothing_extra>
_Thread_queue_Context_set_thread_state(
&queue_context,
STATES_WAITING_FOR_BARRIER
);
_Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context );
_Thread_queue_Enqueue(
40005f00: 96 07 bf dc add %fp, -36, %o3
40005f04: c2 27 bf e4 st %g1, [ %fp + -28 ]
40005f08: 13 10 00 3e sethi %hi(0x4000f800), %o1
&barrier->Queue.Queue,
POSIX_BARRIER_TQ_OPERATIONS,
executing,
&queue_context
);
return 0;
40005f0c: b0 10 20 00 clr %i0
_Thread_queue_Enqueue(
40005f10: 40 00 11 19 call 4000a374 <_Thread_queue_Enqueue>
40005f14: 92 12 62 64 or %o1, 0x264, %o1
return 0;
40005f18: 81 c7 e0 08 ret
40005f1c: 81 e8 00 00 restore
}
}
40005f20: 81 c7 e0 08 ret
<== NOT EXECUTED
40005f24: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
barrier->waiting_threads = 0;
40005f28: c0 20 a0 1c clr [ %g2 + 0x1c ]
_Thread_queue_Flush_critical(
40005f2c: 96 07 bf dc add %fp, -36, %o3
40005f30: 15 10 00 29 sethi %hi(0x4000a400), %o2
40005f34: 13 10 00 3e sethi %hi(0x4000f800), %o1
40005f38: 94 12 a3 10 or %o2, 0x310, %o2
40005f3c: 92 12 62 64 or %o1, 0x264, %o1
40005f40: 40 00 11 f6 call 4000a718 <_Thread_queue_Flush_critical>
40005f44: b0 10 3f ff mov -1, %i0
return PTHREAD_BARRIER_SERIAL_THREAD;
40005f48: 81 c7 e0 08 ret
40005f4c: 81 e8 00 00 restore
40005b18 <pthread_barrierattr_init>:
int pthread_barrierattr_init(
pthread_barrierattr_t *attr
)
{
if ( !attr )
40005b18: 82 92 20 00 orcc %o0, 0, %g1
40005b1c: 02 80 00 06 be 40005b34 <pthread_barrierattr_init+0x1c>
<== NEVER TAKEN
40005b20: 84 10 20 01 mov 1, %g2
return EINVAL;
attr->is_initialized = true;
attr->process_shared = PTHREAD_PROCESS_PRIVATE;
40005b24: c0 20 60 04 clr [ %g1 + 4 ]
return 0;
40005b28: 90 10 20 00 clr %o0
40005b2c: 81 c3 e0 08 retl
40005b30: c4 20 40 00 st %g2, [ %g1 ]
}
40005b34: 81 c3 e0 08 retl
<== NOT EXECUTED
40005b38: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
40005b50 <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 )
{
40005b50: 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 );
40005b54: 80 a6 20 00 cmp %i0, 0
40005b58: 02 80 00 1e be 40005bd0 <pthread_cond_destroy+0x80>
<== NEVER TAKEN
40005b5c: 05 06 37 ec sethi %hi(0x18dfb000), %g2
40005b60: c2 06 00 00 ld [ %i0 ], %g1
40005b64: 82 1e 00 01 xor %i0, %g1, %g1
40005b68: 84 10 a1 fe or %g2, 0x1fe, %g2
40005b6c: 82 18 40 02 xor %g1, %g2, %g1
40005b70: 80 88 7f fe btst -2, %g1
40005b74: 12 80 00 12 bne 40005bbc <pthread_cond_destroy+0x6c>
<== NEVER TAKEN
40005b78: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005b7c: 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 ) ) {
40005b80: c4 06 20 0c ld [ %i0 + 0xc ], %g2
40005b84: 80 a0 a0 00 cmp %g2, 0
40005b88: 02 80 00 06 be 40005ba0 <pthread_cond_destroy+0x50>
<== ALWAYS TAKEN
40005b8c: 01 00 00 00 nop
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005b90: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005b94: 01 00 00 00 nop
<== NOT EXECUTED
_POSIX_Condition_variables_Release( the_cond, &queue_context );
return EBUSY;
40005b98: 81 c7 e0 08 ret
<== NOT EXECUTED
40005b9c: 91 e8 20 10 restore %g0, 0x10, %o0
<== NOT EXECUTED
40005ba0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005ba4: 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;
40005ba8: c2 06 00 00 ld [ %i0 ], %g1
40005bac: 82 38 00 01 xnor %g0, %g1, %g1
40005bb0: c2 26 00 00 st %g1, [ %i0 ]
}
_POSIX_Condition_variables_Release( the_cond, &queue_context );
_POSIX_Condition_variables_Destroy( the_cond );
return 0;
}
40005bb4: 81 c7 e0 08 ret
40005bb8: 91 e8 20 00 restore %g0, 0, %o0
POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
40005bbc: 40 00 00 2e call 40005c74 <_POSIX_Condition_variables_Auto_initialization>
<== NOT EXECUTED
40005bc0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40005bc4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005bc8: 12 bf ff ed bne 40005b7c <pthread_cond_destroy+0x2c>
<== NOT EXECUTED
40005bcc: 01 00 00 00 nop
<== NOT EXECUTED
40005bd0: 81 c7 e0 08 ret
<== NOT EXECUTED
40005bd4: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
40005bd8 <pthread_cond_init>:
{
POSIX_Condition_variables_Control *the_cond;
the_cond = _POSIX_Condition_variables_Get( cond );
if ( the_cond == NULL ) {
40005bd8: 82 92 20 00 orcc %o0, 0, %g1
40005bdc: 02 80 00 1a be 40005c44 <pthread_cond_init+0x6c>
<== NEVER TAKEN
40005be0: 80 a2 60 00 cmp %o1, 0
return EINVAL;
}
if ( attr == NULL ) {
40005be4: 22 80 00 1b be,a 40005c50 <pthread_cond_init+0x78>
<== ALWAYS TAKEN
40005be8: 13 10 00 3e sethi %hi(0x4000f800), %o1
attr = &_POSIX_Condition_variables_Default_attributes;
}
if ( !attr->is_initialized ) {
40005bec: c4 02 40 00 ld [ %o1 ], %g2
40005bf0: 80 a0 a0 00 cmp %g2, 0
40005bf4: 02 80 00 15 be 40005c48 <pthread_cond_init+0x70>
<== NEVER TAKEN
40005bf8: 90 10 20 16 mov 0x16, %o0
return EINVAL;
}
if ( !_POSIX_Is_valid_pshared( attr->process_shared ) ) {
40005bfc: c4 02 60 10 ld [ %o1 + 0x10 ], %g2
40005c00: 80 a0 a0 01 cmp %g2, 1
40005c04: 18 80 00 11 bgu 40005c48 <pthread_cond_init+0x70>
<== NEVER TAKEN
40005c08: 05 06 37 ec sethi %hi(0x18dfb000), %g2
40005c0c: c6 02 60 08 ld [ %o1 + 8 ], %g3
40005c10: c8 02 60 0c ld [ %o1 + 0xc ], %g4
)
{
#if defined(RTEMS_SMP)
_SMP_ticket_lock_Initialize( &queue->Lock );
#endif
queue->heads = NULL;
40005c14: c0 20 60 0c clr [ %g1 + 0xc ]
queue->owner = NULL;
40005c18: c0 20 60 10 clr [ %g1 + 0x10 ]
flags = (uintptr_t) the_cond ^ POSIX_CONDITION_VARIABLES_MAGIC;
40005c1c: 84 10 a1 fe or %g2, 0x1fe, %g2
queue->name = name;
40005c20: c0 20 60 14 clr [ %g1 + 0x14 ]
40005c24: 84 18 40 02 xor %g1, %g2, %g2
the_cond->mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
40005c28: c0 20 60 18 clr [ %g1 + 0x18 ]
if ( the_attr->clock == CLOCK_MONOTONIC ) {
40005c2c: 80 a0 e0 00 cmp %g3, 0
40005c30: 02 80 00 0a be 40005c58 <pthread_cond_init+0x80>
<== ALWAYS TAKEN
40005c34: 84 08 bf fe and %g2, -2, %g2
the_cond->flags = flags;
40005c38: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
return EINVAL;
}
_POSIX_Condition_variables_Initialize( the_cond, attr );
return 0;
40005c3c: 81 c3 e0 08 retl
40005c40: 90 10 20 00 clr %o0
return EINVAL;
40005c44: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
}
40005c48: 81 c3 e0 08 retl
<== NOT EXECUTED
40005c4c: 01 00 00 00 nop
<== NOT EXECUTED
attr = &_POSIX_Condition_variables_Default_attributes;
40005c50: 10 bf ff e7 b 40005bec <pthread_cond_init+0x14>
40005c54: 92 12 63 40 or %o1, 0x340, %o1
if ( the_attr->clock == CLOCK_MONOTONIC ) {
40005c58: 80 a1 20 04 cmp %g4, 4
40005c5c: 32 bf ff f8 bne,a 40005c3c <pthread_cond_init+0x64>
<== ALWAYS TAKEN
40005c60: c4 20 40 00 st %g2, [ %g1 ]
flags |= POSIX_CONDITION_VARIABLES_CLOCK_MONOTONIC;
40005c64: 84 10 a0 01 or %g2, 1, %g2
<== NOT EXECUTED
return 0;
40005c68: 90 10 20 00 clr %o0
<== NOT EXECUTED
40005c6c: 81 c3 e0 08 retl
<== NOT EXECUTED
40005c70: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
40005cfc <pthread_cond_timedwait>:
pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
if ( abstime == NULL ) {
40005cfc: 80 a2 a0 00 cmp %o2, 0
40005d00: 02 80 00 05 be 40005d14 <pthread_cond_timedwait+0x18>
<== NEVER TAKEN
40005d04: 01 00 00 00 nop
return EINVAL; /* not specified */
}
return _POSIX_Condition_variables_Wait_support(
40005d08: 82 13 c0 00 mov %o7, %g1
40005d0c: 40 00 00 22 call 40005d94 <_POSIX_Condition_variables_Wait_support>
40005d10: 9e 10 40 00 mov %g1, %o7
cond,
mutex,
abstime
);
}
40005d14: 81 c3 e0 08 retl
<== NOT EXECUTED
40005d18: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000c104 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
4000c104: 9d e3 bf 20 save %sp, -224, %sp
Thread_Entry_information entry = {
4000c108: 03 10 00 35 sethi %hi(0x4000d400), %g1
4000c10c: 82 10 61 f0 or %g1, 0x1f0, %g1 ! 4000d5f0 <_Thread_Entry_adaptor_pointer>
4000c110: f4 27 bf c8 st %i2, [ %fp + -56 ]
size_t stacksize;
Objects_Name name;
int error;
ISR_lock_Context lock_context;
if ( !start_routine )
4000c114: 80 a6 a0 00 cmp %i2, 0
Thread_Entry_information entry = {
4000c118: c2 27 bf c4 st %g1, [ %fp + -60 ]
int schedpolicy = SCHED_RR;
4000c11c: 82 10 20 02 mov 2, %g1
Thread_Entry_information entry = {
4000c120: f6 27 bf cc st %i3, [ %fp + -52 ]
if ( !start_routine )
4000c124: 02 80 00 b0 be 4000c3e4 <pthread_create+0x2e0>
<== NEVER TAKEN
4000c128: c2 27 bf bc st %g1, [ %fp + -68 ]
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
4000c12c: 80 a6 60 00 cmp %i1, 0
4000c130: 22 80 00 a5 be,a 4000c3c4 <pthread_create+0x2c0>
4000c134: 33 10 00 3e sethi %hi(0x4000f800), %i1
if ( !the_attr->is_initialized )
4000c138: c2 06 40 00 ld [ %i1 ], %g1
4000c13c: 80 a0 60 00 cmp %g1, 0
4000c140: 02 80 00 9e be 4000c3b8 <pthread_create+0x2b4>
<== NEVER TAKEN
4000c144: 03 10 00 43 sethi %hi(0x40010c00), %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 ) {
4000c148: c4 06 60 04 ld [ %i1 + 4 ], %g2
4000c14c: e6 06 60 08 ld [ %i1 + 8 ], %l3
4000c150: 80 a0 a0 00 cmp %g2, 0
4000c154: 02 80 00 9e be 4000c3cc <pthread_create+0x2c8>
<== ALWAYS TAKEN
4000c158: c2 00 61 80 ld [ %g1 + 0x180 ], %g1
if ( !_Stack_Is_enough(the_attr->stacksize) ) {
4000c15c: 80 a0 40 13 cmp %g1, %l3
<== NOT EXECUTED
4000c160: 18 80 00 97 bgu 4000c3bc <pthread_create+0x2b8>
<== NOT EXECUTED
4000c164: 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 ) {
4000c168: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000c16c: 80 a0 60 01 cmp %g1, 1
4000c170: 02 80 00 a1 be 4000c3f4 <pthread_create+0x2f0>
4000c174: e4 01 a0 20 ld [ %g6 + 0x20 ], %l2
4000c178: 80 a0 60 02 cmp %g1, 2
4000c17c: 12 80 00 90 bne 4000c3bc <pthread_create+0x2b8>
<== NEVER TAKEN
4000c180: a0 10 20 16 mov 0x16, %l0
);
_Assert( error == 0 );
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
4000c184: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
schedparam = the_attr->schedparam;
4000c188: d4 1e 60 18 ldd [ %i1 + 0x18 ], %o2
4000c18c: f4 1e 60 20 ldd [ %i1 + 0x20 ], %i2
4000c190: f8 1e 60 28 ldd [ %i1 + 0x28 ], %i4
4000c194: c4 1e 60 30 ldd [ %i1 + 0x30 ], %g2
4000c198: d0 1e 60 38 ldd [ %i1 + 0x38 ], %o0
4000c19c: e0 1e 60 40 ldd [ %i1 + 0x40 ], %l0
schedpolicy = the_attr->schedpolicy;
4000c1a0: c2 27 bf bc st %g1, [ %fp + -68 ]
schedparam = the_attr->schedparam;
4000c1a4: d4 3f bf d0 std %o2, [ %fp + -48 ]
4000c1a8: f4 3f bf d8 std %i2, [ %fp + -40 ]
4000c1ac: f8 3f bf e0 std %i4, [ %fp + -32 ]
4000c1b0: c4 3f bf e8 std %g2, [ %fp + -24 ]
4000c1b4: d0 3f bf f0 std %o0, [ %fp + -16 ]
4000c1b8: 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;
4000c1bc: a0 10 20 86 mov 0x86, %l0
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
4000c1c0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000c1c4: 80 a0 60 00 cmp %g1, 0
4000c1c8: 12 80 00 7d bne 4000c3bc <pthread_create+0x2b8>
<== NEVER TAKEN
4000c1cc: d0 07 bf bc ld [ %fp + -68 ], %o0
error = _POSIX_Thread_Translate_sched_param(
4000c1d0: 96 07 bf b8 add %fp, -72, %o3
4000c1d4: 94 07 bf b4 add %fp, -76, %o2
4000c1d8: 40 00 06 7f call 4000dbd4 <_POSIX_Thread_Translate_sched_param>
4000c1dc: 92 07 bf d0 add %fp, -48, %o1
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( error != 0 ) {
4000c1e0: a0 92 20 00 orcc %o0, 0, %l0
4000c1e4: 32 80 00 82 bne,a 4000c3ec <pthread_create+0x2e8>
<== NEVER TAKEN
4000c1e8: b0 10 00 10 mov %l0, %i0
<== NOT EXECUTED
return error;
}
normal_prio = schedparam.sched_priority;
4000c1ec: 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 );
4000c1f0: 92 10 00 1b mov %i3, %o1
4000c1f4: 94 07 bf b3 add %fp, -77, %o2
4000c1f8: 29 10 00 3c sethi %hi(0x4000f000), %l4
4000c1fc: 40 00 06 45 call 4000db10 <_POSIX_Priority_To_core>
4000c200: 90 15 22 a0 or %l4, 0x2a0, %o0 ! 4000f2a0 <_Scheduler_Table>
if ( !valid ) {
4000c204: c2 0f bf b3 ldub [ %fp + -77 ], %g1
core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );
4000c208: b8 10 00 08 mov %o0, %i4
if ( !valid ) {
4000c20c: 80 a0 60 00 cmp %g1, 0
4000c210: 02 80 00 6a be 4000c3b8 <pthread_create+0x2b4>
<== NEVER TAKEN
4000c214: ba 10 00 09 mov %o1, %i5
return EINVAL;
}
if ( schedpolicy == SCHED_SPORADIC ) {
4000c218: c2 07 bf bc ld [ %fp + -68 ], %g1
4000c21c: 80 a0 60 04 cmp %g1, 4
4000c220: 22 80 00 02 be,a 4000c228 <pthread_create+0x124>
<== NEVER TAKEN
4000c224: 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 );
4000c228: 92 10 00 1b mov %i3, %o1
4000c22c: 94 07 bf b3 add %fp, -77, %o2
4000c230: 40 00 06 38 call 4000db10 <_POSIX_Priority_To_core>
4000c234: 90 15 22 a0 or %l4, 0x2a0, %o0
if ( !valid ) {
4000c238: c2 0f bf b3 ldub [ %fp + -77 ], %g1
core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid );
4000c23c: b4 10 00 08 mov %o0, %i2
if ( !valid ) {
4000c240: 80 a0 60 00 cmp %g1, 0
4000c244: 02 80 00 5d be 4000c3b8 <pthread_create+0x2b4>
<== NEVER TAKEN
4000c248: b6 10 00 09 mov %o1, %i3
return EINVAL;
}
if ( the_attr->affinityset == NULL ) {
4000c24c: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
4000c250: 80 a0 60 00 cmp %g1, 0
4000c254: 22 80 00 5a be,a 4000c3bc <pthread_create+0x2b8>
<== NEVER TAKEN
4000c258: a0 10 20 16 mov 0x16, %l0
<== NOT EXECUTED
_RTEMS_Lock_allocator();
4000c25c: 7f ff e7 7a call 40006044 <_RTEMS_Lock_allocator>
4000c260: 2b 10 00 4a sethi %hi(0x40012800), %l5
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate(void)
{
_Objects_Allocator_lock();
_Thread_Kill_zombies();
4000c264: 7f ff f8 33 call 4000a330 <_Thread_Kill_zombies>
4000c268: 01 00 00 00 nop
return (Thread_Control *)
4000c26c: 7f ff ed 7e call 40007864 <_Objects_Allocate_unprotected>
4000c270: 90 15 62 08 or %l5, 0x208, %o0
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
4000c274: a2 92 20 00 orcc %o0, 0, %l1
4000c278: 02 80 00 66 be 4000c410 <pthread_create+0x30c>
<== NEVER TAKEN
4000c27c: 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(
4000c280: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
4000c284: 9a 10 20 01 mov 1, %o5
4000c288: c2 07 bf b8 ld [ %fp + -72 ], %g1
4000c28c: f8 3f bf a0 std %i4, [ %fp + -96 ]
4000c290: 98 10 00 13 mov %l3, %o4
4000c294: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
4000c298: 94 15 22 a0 or %l4, 0x2a0, %o2
4000c29c: c2 07 bf b4 ld [ %fp + -76 ], %g1
4000c2a0: c2 23 a0 68 st %g1, [ %sp + 0x68 ]
4000c2a4: 82 10 20 01 mov 1, %g1
4000c2a8: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
4000c2ac: 92 10 00 11 mov %l1, %o1
4000c2b0: c2 07 bf a0 ld [ %fp + -96 ], %g1
4000c2b4: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000c2b8: 90 15 62 08 or %l5, 0x208, %o0
4000c2bc: c2 07 bf a4 ld [ %fp + -92 ], %g1
4000c2c0: c0 27 bf ac clr [ %fp + -84 ]
4000c2c4: c0 23 a0 70 clr [ %sp + 0x70 ]
4000c2c8: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
4000c2cc: 7f ff f3 53 call 40009018 <_Thread_Initialize>
4000c2d0: 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 ) {
4000c2d4: 80 a2 20 00 cmp %o0, 0
4000c2d8: 02 80 00 52 be 4000c420 <pthread_create+0x31c>
<== NEVER TAKEN
4000c2dc: 92 10 00 11 mov %l1, %o1
_POSIX_Threads_Free( the_thread );
_Objects_Allocator_unlock();
return EAGAIN;
}
if ( the_attr->detachstate == PTHREAD_CREATE_DETACHED ) {
4000c2e0: c4 06 60 50 ld [ %i1 + 0x50 ], %g2
4000c2e4: 80 a0 a0 00 cmp %g2, 0
4000c2e8: 12 80 00 03 bne 4000c2f4 <pthread_create+0x1f0>
<== ALWAYS TAKEN
4000c2ec: c2 04 61 70 ld [ %l1 + 0x170 ], %g1
the_thread->Life.state |= THREAD_LIFE_DETACHED;
4000c2f0: 82 10 60 10 or %g1, 0x10, %g1
<== NOT EXECUTED
}
the_thread->Life.state |= THREAD_LIFE_CHANGE_DEFERRED;
4000c2f4: 82 10 60 08 or %g1, 8, %g1
<== NOT EXECUTED
4000c2f8: c2 24 61 70 st %g1, [ %l1 + 0x170 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000c2fc: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &lock_context );
4000c300: c2 27 bf c0 st %g1, [ %fp + -64 ]
status = _Scheduler_Set_affinity(
4000c304: d4 06 60 58 ld [ %i1 + 0x58 ], %o2
4000c308: d2 06 60 54 ld [ %i1 + 0x54 ], %o1
4000c30c: 40 00 03 39 call 4000cff0 <_Scheduler_Set_affinity>
4000c310: 90 10 00 11 mov %l1, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000c314: c2 07 bf c0 ld [ %fp + -64 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c318: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c31c: 01 00 00 00 nop
the_thread,
the_attr->affinitysetsize,
the_attr->affinityset
);
_ISR_lock_ISR_enable( &lock_context );
if ( !status ) {
4000c320: 80 a2 20 00 cmp %o0, 0
4000c324: 02 80 00 45 be 4000c438 <pthread_create+0x334>
<== NEVER TAKEN
4000c328: 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;
4000c32c: c2 04 a1 5c ld [ %l2 + 0x15c ], %g1
4000c330: c4 00 60 68 ld [ %g1 + 0x68 ], %g2
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000c334: d0 04 61 5c ld [ %l1 + 0x15c ], %o0
the_thread->was_created_with_inherited_scheduler =
( the_attr->inheritsched == PTHREAD_INHERIT_SCHED );
4000c338: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000c33c: 82 18 60 01 xor %g1, 1, %g1
api->signals_unblocked = executing_api->signals_unblocked;
4000c340: c4 22 20 68 st %g2, [ %o0 + 0x68 ]
( the_attr->inheritsched == PTHREAD_INHERIT_SCHED );
4000c344: 80 a0 00 01 cmp %g0, %g1
4000c348: 82 60 3f ff subx %g0, -1, %g1
4000c34c: c2 2c 60 8b stb %g1, [ %l1 + 0x8b ]
node->priority = priority;
4000c350: 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 =
4000c354: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
api->Sporadic.sched_ss_repl_period =
4000c358: f4 1e 60 20 ldd [ %i1 + 0x20 ], %i2
4000c35c: f8 1e 60 28 ldd [ %i1 + 0x28 ], %i4
api->Sporadic.sched_ss_init_budget =
4000c360: c4 1e 60 30 ldd [ %i1 + 0x30 ], %g2
4000c364: d8 1e 60 38 ldd [ %i1 + 0x38 ], %o4
4000c368: d8 3a 20 58 std %o4, [ %o0 + 0x58 ]
api->Sporadic.sched_ss_max_repl =
4000c36c: c2 22 20 60 st %g1, [ %o0 + 0x60 ]
api->Sporadic.sched_ss_repl_period =
4000c370: f4 3a 20 40 std %i2, [ %o0 + 0x40 ]
4000c374: f8 3a 20 48 std %i4, [ %o0 + 0x48 ]
api->Sporadic.sched_ss_init_budget =
4000c378: c4 3a 20 50 std %g2, [ %o0 + 0x50 ]
the_attr->schedparam.sched_ss_max_repl;
if ( schedpolicy == SCHED_SPORADIC ) {
4000c37c: c2 07 bf bc ld [ %fp + -68 ], %g1
4000c380: 80 a0 60 04 cmp %g1, 4
4000c384: 02 80 00 33 be 4000c450 <pthread_create+0x34c>
<== NEVER TAKEN
4000c388: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000c38c: 91 d0 20 09 ta 9
<== NOT EXECUTED
}
/*
* POSIX threads are allocated and started in one operation.
*/
_ISR_lock_ISR_disable( &lock_context );
4000c390: c2 27 bf c0 st %g1, [ %fp + -64 ]
status = _Thread_Start( the_thread, &entry, &lock_context );
4000c394: 94 07 bf c0 add %fp, -64, %o2
4000c398: 92 07 bf c4 add %fp, -60, %o1
4000c39c: 40 00 05 0e call 4000d7d4 <_Thread_Start>
4000c3a0: 90 10 00 11 mov %l1, %o0
#endif
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
4000c3a4: c2 04 60 08 ld [ %l1 + 8 ], %g1
_RTEMS_Unlock_allocator();
4000c3a8: 7f ff e7 2c call 40006058 <_RTEMS_Unlock_allocator>
4000c3ac: c2 26 00 00 st %g1, [ %i0 ]
_Objects_Allocator_unlock();
return 0;
4000c3b0: 81 c7 e0 08 ret
4000c3b4: 91 e8 00 10 restore %g0, %l0, %o0
return EINVAL;
4000c3b8: a0 10 20 16 mov 0x16, %l0
<== NOT EXECUTED
}
4000c3bc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c3c0: 91 e8 00 10 restore %g0, %l0, %o0
<== NOT EXECUTED
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
4000c3c4: 10 bf ff 5d b 4000c138 <pthread_create+0x34>
4000c3c8: b2 16 63 40 or %i1, 0x340, %i1
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
4000c3cc: 83 28 60 01 sll %g1, 1, %g1
4000c3d0: 80 a4 c0 01 cmp %l3, %g1
4000c3d4: 2a bf ff 65 bcs,a 4000c168 <pthread_create+0x64>
4000c3d8: a6 10 00 01 mov %g1, %l3
switch ( the_attr->inheritsched ) {
4000c3dc: 10 bf ff 64 b 4000c16c <pthread_create+0x68>
4000c3e0: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
return EFAULT;
4000c3e4: a0 10 20 0e mov 0xe, %l0
<== NOT EXECUTED
}
4000c3e8: b0 10 00 10 mov %l0, %i0
<== NOT EXECUTED
4000c3ec: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c3f0: 81 e8 00 00 restore
<== NOT EXECUTED
error = pthread_getschedparam(
4000c3f4: 40 00 00 c8 call 4000c714 <pthread_self>
4000c3f8: a0 10 20 86 mov 0x86, %l0
4000c3fc: 94 07 bf d0 add %fp, -48, %o2
4000c400: 40 00 00 17 call 4000c45c <pthread_getschedparam>
4000c404: 92 07 bf bc add %fp, -68, %o1
break;
4000c408: 10 bf ff 6f b 4000c1c4 <pthread_create+0xc0>
4000c40c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000c410: 7f ff e7 12 call 40006058 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000c414: a0 10 20 0b mov 0xb, %l0
<== NOT EXECUTED
return EAGAIN;
4000c418: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c41c: 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 );
4000c420: 90 15 62 08 or %l5, 0x208, %o0
<== NOT EXECUTED
4000c424: 40 00 02 34 call 4000ccf4 <_Objects_Free>
<== NOT EXECUTED
4000c428: a0 10 20 0b mov 0xb, %l0
<== NOT EXECUTED
4000c42c: 7f ff e7 0b call 40006058 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000c430: b0 10 00 10 mov %l0, %i0
<== NOT EXECUTED
return EAGAIN;
4000c434: 30 bf ff ee b,a 4000c3ec <pthread_create+0x2e8>
<== NOT EXECUTED
4000c438: 90 15 62 08 or %l5, 0x208, %o0
<== NOT EXECUTED
4000c43c: 40 00 02 2e call 4000ccf4 <_Objects_Free>
<== NOT EXECUTED
4000c440: a0 10 20 16 mov 0x16, %l0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
4000c444: 7f ff e7 05 call 40006058 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000c448: b0 10 00 10 mov %l0, %i0
<== NOT EXECUTED
return EINVAL;
4000c44c: 30 bf ff e8 b,a 4000c3ec <pthread_create+0x2e8>
<== NOT EXECUTED
_POSIX_Threads_Sporadic_timer( &api->Sporadic.Timer );
4000c450: 40 00 00 64 call 4000c5e0 <_POSIX_Threads_Sporadic_timer>
<== NOT EXECUTED
4000c454: 90 02 20 08 add %o0, 8, %o0
<== NOT EXECUTED
4000c458: 30 bf ff cd b,a 4000c38c <pthread_create+0x288>
<== NOT EXECUTED
4000dcb4 <pthread_exit>:
#include <pthread.h>
#include <rtems/score/threadimpl.h>
void pthread_exit( void *value_ptr )
{
4000dcb4: 9d e3 bf a0 save %sp, -96, %sp
disable_level = cpu_self->thread_dispatch_disable_level;
4000dcb8: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000dcbc: 82 00 60 01 inc %g1
4000dcc0: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000dcc4: 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 );
4000dcc8: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
4000dccc: 94 10 00 18 mov %i0, %o2
4000dcd0: 7f ff f1 e0 call 4000a450 <_Thread_Exit>
4000dcd4: 92 10 20 04 mov 4, %o1
_Thread_Dispatch_direct( cpu_self );
4000dcd8: 7f ff fe 3b call 4000d5c4 <_Thread_Dispatch_direct>
4000dcdc: 90 10 00 1d mov %i5, %o0
4000dce0: 01 00 00 00 nop
<== NOT EXECUTED
4000c45c <pthread_getschedparam>:
int pthread_getschedparam(
pthread_t thread,
int *policy,
struct sched_param *param
)
{
4000c45c: 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 ) {
4000c460: 80 a6 60 00 cmp %i1, 0
4000c464: 02 80 00 2b be 4000c510 <pthread_getschedparam+0xb4>
<== NEVER TAKEN
4000c468: 80 a6 a0 00 cmp %i2, 0
4000c46c: 02 80 00 29 be 4000c510 <pthread_getschedparam+0xb4>
<== NEVER TAKEN
4000c470: 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 );
4000c474: 92 07 bf dc add %fp, -36, %o1
4000c478: 7f ff f2 ab call 40008f24 <_Thread_Get>
4000c47c: b0 10 20 03 mov 3, %i0
if ( the_thread == NULL ) {
4000c480: 80 a2 20 00 cmp %o0, 0
4000c484: 02 80 00 21 be 4000c508 <pthread_getschedparam+0xac>
<== NEVER TAKEN
4000c488: a2 10 00 08 mov %o0, %l1
4000c48c: 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(
4000c490: d4 06 e0 3c ld [ %i3 + 0x3c ], %o2
4000c494: d2 06 e0 38 ld [ %i3 + 0x38 ], %o1
4000c498: 25 10 00 3c sethi %hi(0x4000f000), %l2
4000c49c: 40 00 05 ba call 4000db84 <_POSIX_Priority_From_core>
4000c4a0: 90 14 a2 a0 or %l2, 0x2a0, %o0 ! 4000f2a0 <_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;
4000c4a4: c4 1e e0 58 ldd [ %i3 + 0x58 ], %g2
<== NOT EXECUTED
4000c4a8: f8 1e e0 50 ldd [ %i3 + 0x50 ], %i4
<== NOT EXECUTED
param->sched_ss_repl_period = api->Sporadic.sched_ss_repl_period;
4000c4ac: d8 1e e0 40 ldd [ %i3 + 0x40 ], %o4
<== NOT EXECUTED
4000c4b0: d4 1e e0 48 ldd [ %i3 + 0x48 ], %o2
<== NOT EXECUTED
param->sched_ss_max_repl = api->Sporadic.sched_ss_max_repl;
4000c4b4: c2 06 e0 60 ld [ %i3 + 0x60 ], %g1
<== NOT EXECUTED
4000c4b8: c2 26 a0 28 st %g1, [ %i2 + 0x28 ]
<== NOT EXECUTED
param->sched_ss_init_budget = api->Sporadic.sched_ss_init_budget;
4000c4bc: f8 3e a0 18 std %i4, [ %i2 + 0x18 ]
<== NOT EXECUTED
4000c4c0: c4 3e a0 20 std %g2, [ %i2 + 0x20 ]
<== NOT EXECUTED
param->sched_ss_repl_period = api->Sporadic.sched_ss_repl_period;
4000c4c4: d8 3e a0 08 std %o4, [ %i2 + 8 ]
<== NOT EXECUTED
4000c4c8: d4 3e a0 10 std %o2, [ %i2 + 0x10 ]
<== NOT EXECUTED
param->sched_ss_low_priority = _POSIX_Priority_From_core(
4000c4cc: 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;
4000c4d0: c4 1c 60 30 ldd [ %l1 + 0x30 ], %g2
<== NOT EXECUTED
budget_algorithm = the_thread->budget_algorithm;
4000c4d4: fa 04 60 90 ld [ %l1 + 0x90 ], %i5
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000c4d8: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c4dc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c4e0: 01 00 00 00 nop
_Thread_Wait_release( the_thread, &queue_context );
param->sched_priority = _POSIX_Priority_From_core( scheduler, priority );
4000c4e4: 92 10 00 02 mov %g2, %o1
4000c4e8: 94 10 00 03 mov %g3, %o2
4000c4ec: 40 00 05 a6 call 4000db84 <_POSIX_Priority_From_core>
4000c4f0: 90 14 a2 a0 or %l2, 0x2a0, %o0
4000c4f4: d0 26 80 00 st %o0, [ %i2 ]
*policy = _POSIX_Thread_Translate_to_sched_policy( budget_algorithm );
return 0;
4000c4f8: b0 10 20 00 clr %i0
*policy = _POSIX_Thread_Translate_to_sched_policy( budget_algorithm );
4000c4fc: 40 00 05 ac call 4000dbac <_POSIX_Thread_Translate_to_sched_policy>
4000c500: 90 10 00 1d mov %i5, %o0
4000c504: d0 26 40 00 st %o0, [ %i1 ]
return 0;
4000c508: 81 c7 e0 08 ret
4000c50c: 81 e8 00 00 restore
return EINVAL;
4000c510: b0 10 20 16 mov 0x16, %i0
<== NOT EXECUTED
}
4000c514: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c518: 81 e8 00 00 restore
<== NOT EXECUTED
40005bac <pthread_getspecific>:
ISR_Level level;
_ISR_Local_disable( level );
#endif
executing = _Thread_Executing;
40005bac: c6 01 a0 20 ld [ %g6 + 0x20 ], %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005bb0: 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 );
40005bb4: 86 00 e1 60 add %g3, 0x160, %g3
RBTree_Node *parent;
link = _RBTree_Root_const_reference( the_rbtree );
parent = NULL;
while ( *link != NULL ) {
40005bb8: c4 00 c0 00 ld [ %g3 ], %g2
40005bbc: 80 a0 a0 00 cmp %g2, 0
40005bc0: 02 80 00 0d be 40005bf4 <pthread_getspecific+0x48>
40005bc4: 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;
40005bc8: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
parent = *link;
if ( ( *equal )( key, parent ) ) {
40005bcc: 80 a2 00 04 cmp %o0, %g4
40005bd0: 22 80 00 0e be,a 40005c08 <pthread_getspecific+0x5c>
<== ALWAYS TAKEN
40005bd4: d0 00 e0 20 ld [ %g3 + 0x20 ], %o0
return ( *map )( parent );
} else if ( ( *less )( key, parent ) ) {
40005bd8: 1a bf ff f8 bcc 40005bb8 <pthread_getspecific+0xc>
<== NOT EXECUTED
40005bdc: 86 00 a0 04 add %g2, 4, %g3
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
40005be0: 86 10 00 02 mov %g2, %g3
<== NOT EXECUTED
while ( *link != NULL ) {
40005be4: c4 00 c0 00 ld [ %g3 ], %g2
<== NOT EXECUTED
40005be8: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40005bec: 12 bf ff f7 bne 40005bc8 <pthread_getspecific+0x1c>
<== NOT EXECUTED
40005bf0: 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;
40005bf4: 90 10 20 00 clr %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005bf8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005bfc: 01 00 00 00 nop
}
_POSIX_Keys_Key_value_release( executing, &lock_context );
return value;
}
40005c00: 81 c3 e0 08 retl
40005c04: 01 00 00 00 nop
40005c08: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005c0c: 01 00 00 00 nop
40005c10: 81 c3 e0 08 retl
40005c14: 01 00 00 00 nop
40005b3c <pthread_key_create>:
*/
int pthread_key_create(
pthread_key_t *key,
void (*destructor)( void * )
)
{
40005b3c: 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 );
40005b40: 3b 10 00 49 sethi %hi(0x40012400), %i5
40005b44: 40 00 07 7e call 4000793c <_Objects_Allocate>
40005b48: 90 17 60 98 or %i5, 0x98, %o0 ! 40012498 <_POSIX_Keys_Information>
POSIX_Keys_Control *the_key;
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
40005b4c: 80 a2 20 00 cmp %o0, 0
40005b50: 02 80 00 13 be 40005b9c <pthread_key_create+0x60>
<== NEVER TAKEN
40005b54: 86 02 20 14 add %o0, 0x14, %g3
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40005b58: c2 12 20 0a lduh [ %o0 + 0xa ], %g1
tail->previous = head;
40005b5c: c6 22 20 1c st %g3, [ %o0 + 0x1c ]
return &the_chain->Tail.Node;
40005b60: 84 02 20 18 add %o0, 0x18, %g2
_Objects_Allocator_unlock();
return EAGAIN;
}
the_key->destructor = destructor;
40005b64: f2 22 20 10 st %i1, [ %o0 + 0x10 ]
40005b68: ba 17 60 98 or %i5, 0x98, %i5
head->next = tail;
40005b6c: c4 22 20 14 st %g2, [ %o0 + 0x14 ]
40005b70: 83 28 60 02 sll %g1, 2, %g1
head->previous = NULL;
40005b74: 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;
40005b78: c0 22 20 0c clr [ %o0 + 0xc ]
information->local_table[ index ] = the_object;
40005b7c: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
40005b80: c4 02 20 08 ld [ %o0 + 8 ], %g2
40005b84: 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;
40005b88: 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();
40005b8c: 40 00 01 33 call 40006058 <_RTEMS_Unlock_allocator>
40005b90: b0 10 20 00 clr %i0
_Objects_Allocator_unlock();
return 0;
}
40005b94: 81 c7 e0 08 ret
40005b98: 81 e8 00 00 restore
40005b9c: 40 00 01 2f call 40006058 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40005ba0: b0 10 20 0b mov 0xb, %i0
<== NOT EXECUTED
return EAGAIN;
40005ba4: 81 c7 e0 08 ret
<== NOT EXECUTED
40005ba8: 81 e8 00 00 restore
<== NOT EXECUTED
40005b70 <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
)
{
40005b70: 9d e3 bf 98 save %sp, -104, %sp
_RTEMS_Lock_allocator();
40005b74: 40 00 01 1e call 40005fec <_RTEMS_Lock_allocator>
40005b78: 33 10 00 49 sethi %hi(0x40012400), %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 *)
40005b7c: 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;
40005b80: b0 10 20 16 mov 0x16, %i0
40005b84: 40 00 08 55 call 40007cd8 <_Objects_Get_no_protection>
40005b88: 92 16 60 00 mov %i1, %o1
if ( the_key != NULL ) {
40005b8c: 80 a2 20 00 cmp %o0, 0
40005b90: 02 80 00 24 be 40005c20 <pthread_key_delete+0xb0>
<== NEVER TAKEN
40005b94: b8 10 00 08 mov %o0, %i4
_Objects_Close( &_POSIX_Keys_Information, &the_key->Object );
40005b98: 92 10 00 08 mov %o0, %o1
40005b9c: 40 00 07 57 call 400078f8 <_Objects_Close>
40005ba0: 90 16 60 00 mov %i1, %o0
return _Chain_Immutable_head( the_chain )->next;
40005ba4: fa 07 20 14 ld [ %i4 + 0x14 ], %i5
return &the_chain->Tail.Node;
40005ba8: b4 07 20 18 add %i4, 0x18, %i2
while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) {
40005bac: 80 a6 80 1d cmp %i2, %i5
40005bb0: 02 80 00 19 be 40005c14 <pthread_key_delete+0xa4>
40005bb4: 92 10 00 1c mov %i4, %o1
40005bb8: 37 10 00 49 sethi %hi(0x40012400), %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 );
40005bbc: b6 16 e0 3c or %i3, 0x3c, %i3 ! 4001243c <_POSIX_Keys_Keypool>
<== NOT EXECUTED
the_thread = key_value_pair->thread;
40005bc0: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005bc4: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
40005bc8: c2 27 bf fc st %g1, [ %fp + -4 ]
_RBTree_Extract(
40005bcc: 92 07 60 08 add %i5, 8, %o1
40005bd0: 40 00 09 0a call 40007ff8 <_RBTree_Extract>
40005bd4: 90 02 21 60 add %o0, 0x160, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40005bd8: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005bdc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005be0: 01 00 00 00 nop
next = the_node->next;
40005be4: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
40005be8: c2 07 60 04 ld [ %i5 + 4 ], %g1
next->previous = previous;
40005bec: c2 20 a0 04 st %g1, [ %g2 + 4 ]
40005bf0: 92 10 00 1d mov %i5, %o1
previous->next = next;
40005bf4: c4 20 40 00 st %g2, [ %g1 ]
40005bf8: 40 00 01 5e call 40006170 <_Freechain_Put>
40005bfc: 90 10 00 1b mov %i3, %o0
return _Chain_Immutable_head( the_chain )->next;
40005c00: fa 07 20 14 ld [ %i4 + 0x14 ], %i5
while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) {
40005c04: 80 a7 40 1a cmp %i5, %i2
40005c08: 32 bf ff ef bne,a 40005bc4 <pthread_key_delete+0x54>
<== NEVER TAKEN
40005c0c: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
<== NOT EXECUTED
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
40005c10: 92 10 00 1c mov %i4, %o1
40005c14: 90 16 60 00 mov %i1, %o0
40005c18: 40 00 08 04 call 40007c28 <_Objects_Free>
40005c1c: b0 10 20 00 clr %i0
_RTEMS_Unlock_allocator();
40005c20: 40 00 00 f8 call 40006000 <_RTEMS_Unlock_allocator>
40005c24: 01 00 00 00 nop
}
_Objects_Allocator_unlock();
return eno;
}
40005c28: 81 c7 e0 08 ret
40005c2c: 81 e8 00 00 restore
4000f88c <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 )
{
4000f88c: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
4000f890: 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 ) ) {
4000f894: 80 a7 60 1f cmp %i5, 0x1f
<== NOT EXECUTED
4000f898: 18 80 00 28 bgu 4000f938 <pthread_kill+0xac>
<== NOT EXECUTED
4000f89c: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
return EINVAL;
}
the_thread = _Thread_Get( thread, &lock_context );
4000f8a0: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
4000f8a4: 7f ff e9 df call 4000a020 <_Thread_Get>
<== NOT EXECUTED
4000f8a8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( the_thread == NULL ) {
4000f8ac: 86 92 20 00 orcc %o0, 0, %g3
<== NOT EXECUTED
4000f8b0: 02 80 00 22 be 4000f938 <pthread_kill+0xac>
<== NOT EXECUTED
4000f8b4: 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 ) {
4000f8b8: 83 2e 60 01 sll %i1, 1, %g1
<== NOT EXECUTED
4000f8bc: 82 00 40 19 add %g1, %i1, %g1
<== NOT EXECUTED
4000f8c0: 85 28 60 02 sll %g1, 2, %g2
<== NOT EXECUTED
4000f8c4: 03 10 00 53 sethi %hi(0x40014c00), %g1
<== NOT EXECUTED
4000f8c8: 82 10 63 90 or %g1, 0x390, %g1 ! 40014f90 <_POSIX_signals_Vectors>
<== NOT EXECUTED
4000f8cc: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000f8d0: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
4000f8d4: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000f8d8: 02 80 00 24 be 4000f968 <pthread_kill+0xdc>
<== NOT EXECUTED
4000f8dc: 01 00 00 00 nop
<== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000f8e0: c8 00 e1 5c ld [ %g3 + 0x15c ], %g4
<== NOT EXECUTED
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
4000f8e4: c4 01 20 6c ld [ %g4 + 0x6c ], %g2
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000f8e8: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
return 1u << (sig - 1);
4000f8ec: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
4000f8f0: bb 28 c0 1d sll %g3, %i5, %i5
<== NOT EXECUTED
4000f8f4: ba 10 80 1d or %g2, %i5, %i5
<== NOT EXECUTED
4000f8f8: fa 21 20 6c st %i5, [ %g4 + 0x6c ]
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000f8fc: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000f900: b8 10 00 06 mov %g6, %i4
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000f904: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f908: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f90c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f910: 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 );
4000f914: 94 10 20 00 clr %o2 ! 0 <PROM_START>
<== NOT EXECUTED
4000f918: 7f ff fe f9 call 4000f4fc <_POSIX_signals_Unblock_thread>
<== NOT EXECUTED
4000f91c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000f920: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000f924: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000f928: 02 80 00 06 be 4000f940 <pthread_kill+0xb4>
<== NOT EXECUTED
4000f92c: 84 00 7f ff add %g1, -1, %g2
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000f930: c4 27 20 18 st %g2, [ %i4 + 0x18 ]
<== NOT EXECUTED
_Thread_Dispatch_enable( cpu_self );
return 0;
4000f934: 82 10 20 00 clr %g1
<== NOT EXECUTED
}
4000f938: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f93c: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000f940: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000f944: c4 0f 20 1c ldub [ %i4 + 0x1c ], %g2
<== NOT EXECUTED
4000f948: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000f94c: 12 80 00 0d bne 4000f980 <pthread_kill+0xf4>
<== NOT EXECUTED
4000f950: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4000f954: c0 27 20 18 clr [ %i4 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f958: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f95c: 01 00 00 00 nop
<== NOT EXECUTED
return 0;
4000f960: 10 bf ff f6 b 4000f938 <pthread_kill+0xac>
<== NOT EXECUTED
4000f964: 82 10 20 00 clr %g1 ! 0 <PROM_START>
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f968: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f96c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f970: 01 00 00 00 nop
<== NOT EXECUTED
return 0;
4000f974: 82 10 20 00 clr %g1 ! 0 <PROM_START>
<== NOT EXECUTED
}
4000f978: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f97c: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
4000f980: c2 27 bf f4 st %g1, [ %fp + -12 ]
<== NOT EXECUTED
4000f984: 7f ff fc 0e call 4000e9bc <_Thread_Do_dispatch>
<== NOT EXECUTED
4000f988: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000f98c: 10 bf ff f3 b 4000f958 <pthread_kill+0xcc>
<== NOT EXECUTED
4000f990: c2 07 bf f4 ld [ %fp + -12 ], %g1
<== NOT EXECUTED
40005d1c <pthread_mutex_destroy>:
*/
int pthread_mutex_destroy(
pthread_mutex_t *mutex
)
{
40005d1c: 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 );
40005d20: 80 a6 20 00 cmp %i0, 0
40005d24: 02 80 00 18 be 40005d84 <pthread_mutex_destroy+0x68>
<== NEVER TAKEN
40005d28: 05 25 87 04 sethi %hi(0x961c1000), %g2
40005d2c: c2 06 00 00 ld [ %i0 ], %g1
40005d30: 82 1e 00 01 xor %i0, %g1, %g1
40005d34: 84 10 a3 b8 or %g2, 0x3b8, %g2
40005d38: 82 18 40 02 xor %g1, %g2, %g1
40005d3c: 80 88 7f f8 btst -8, %g1
40005d40: 12 80 00 0c bne 40005d70 <pthread_mutex_destroy+0x54>
<== NEVER TAKEN
40005d44: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005d48: 91 d0 20 09 ta 9
<== NOT EXECUTED
_POSIX_Mutex_Acquire( the_mutex, &queue_context );
if ( _POSIX_Mutex_Get_owner( the_mutex ) == NULL ) {
40005d4c: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
40005d50: 80 a0 a0 00 cmp %g2, 0
40005d54: 22 80 00 0e be,a 40005d8c <pthread_mutex_destroy+0x70>
<== ALWAYS TAKEN
40005d58: c4 06 00 00 ld [ %i0 ], %g2
the_mutex->flags = ~the_mutex->flags;
eno = 0;
} else {
eno = EBUSY;
40005d5c: b0 10 20 10 mov 0x10, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005d60: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005d64: 01 00 00 00 nop
<== NOT EXECUTED
}
_POSIX_Mutex_Release( the_mutex, &queue_context );
return eno;
}
40005d68: 81 c7 e0 08 ret
<== NOT EXECUTED
40005d6c: 81 e8 00 00 restore
<== NOT EXECUTED
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40005d70: 40 00 00 61 call 40005ef4 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
40005d74: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40005d78: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005d7c: 12 bf ff f3 bne 40005d48 <pthread_mutex_destroy+0x2c>
<== NOT EXECUTED
40005d80: 01 00 00 00 nop
<== NOT EXECUTED
40005d84: 81 c7 e0 08 ret
<== NOT EXECUTED
40005d88: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
the_mutex->flags = ~the_mutex->flags;
40005d8c: 84 38 00 02 xnor %g0, %g2, %g2
<== NOT EXECUTED
40005d90: c4 26 00 00 st %g2, [ %i0 ]
<== NOT EXECUTED
eno = 0;
40005d94: b0 10 20 00 clr %i0
<== NOT EXECUTED
40005d98: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005d9c: 01 00 00 00 nop
}
40005da0: 81 c7 e0 08 ret
40005da4: 81 e8 00 00 restore
40005e6c <pthread_mutex_getprioceiling>:
#else
pthread_mutex_t *mutex,
#endif
int *prioceiling
)
{
40005e6c: 9d e3 bf 98 save %sp, -104, %sp
if ( prioceiling == NULL ) {
return EINVAL;
}
the_mutex = _POSIX_Mutex_Get( RTEMS_DECONST( pthread_mutex_t *, mutex ) );
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40005e70: 80 a6 60 00 cmp %i1, 0
40005e74: 02 80 00 1a be 40005edc <pthread_mutex_getprioceiling+0x70>
<== NEVER TAKEN
40005e78: 80 a6 20 00 cmp %i0, 0
40005e7c: 02 80 00 18 be 40005edc <pthread_mutex_getprioceiling+0x70>
<== NEVER TAKEN
40005e80: 05 25 87 04 sethi %hi(0x961c1000), %g2
40005e84: fa 06 00 00 ld [ %i0 ], %i5
40005e88: 82 1e 00 1d xor %i0, %i5, %g1
40005e8c: 84 10 a3 b8 or %g2, 0x3b8, %g2
40005e90: 82 18 40 02 xor %g1, %g2, %g1
40005e94: 80 88 7f f8 btst -8, %g1
40005e98: 12 80 00 0c bne 40005ec8 <pthread_mutex_getprioceiling+0x5c>
<== NEVER TAKEN
40005e9c: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005ea0: 91 d0 20 09 ta 9
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Mutex_Protocol _POSIX_Mutex_Get_protocol(
unsigned long flags
)
{
return flags & POSIX_MUTEX_PROTOCOL_MASK;
40005ea4: ba 0f 60 03 and %i5, 3, %i5
_POSIX_Mutex_Acquire( the_mutex, &queue_context );
if ( _POSIX_Mutex_Get_protocol( flags ) == POSIX_MUTEX_PRIORITY_CEILING ) {
40005ea8: 80 a7 60 02 cmp %i5, 2
40005eac: 22 80 00 0e be,a 40005ee4 <pthread_mutex_getprioceiling+0x78>
<== NEVER TAKEN
40005eb0: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
<== NOT EXECUTED
*prioceiling = _POSIX_Priority_From_core(
_POSIX_Mutex_Get_scheduler( the_mutex ),
_POSIX_Mutex_Get_priority( the_mutex )
);
} else {
*prioceiling = 0;
40005eb4: c0 26 40 00 clr [ %i1 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005eb8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005ebc: 01 00 00 00 nop
}
_POSIX_Mutex_Release( the_mutex, &queue_context );
return 0;
}
40005ec0: 81 c7 e0 08 ret
40005ec4: 91 e8 20 00 restore %g0, 0, %o0
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40005ec8: 40 00 00 b8 call 400061a8 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
40005ecc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40005ed0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005ed4: 12 bf ff f3 bne 40005ea0 <pthread_mutex_getprioceiling+0x34>
<== NOT EXECUTED
40005ed8: 01 00 00 00 nop
<== NOT EXECUTED
40005edc: 81 c7 e0 08 ret
<== NOT EXECUTED
40005ee0: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
*prioceiling = _POSIX_Priority_From_core(
40005ee4: d4 06 20 34 ld [ %i0 + 0x34 ], %o2
<== NOT EXECUTED
40005ee8: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
40005eec: 11 10 00 3f sethi %hi(0x4000fc00), %o0
<== NOT EXECUTED
40005ef0: 40 00 01 84 call 40006500 <_POSIX_Priority_From_core>
<== NOT EXECUTED
40005ef4: 90 12 21 58 or %o0, 0x158, %o0 ! 4000fd58 <_Scheduler_Table>
<== NOT EXECUTED
40005ef8: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
40005efc: d0 26 40 00 st %o0, [ %i1 ]
<== NOT EXECUTED
40005f00: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005f04: 01 00 00 00 nop
<== NOT EXECUTED
}
40005f08: 81 c7 e0 08 ret
<== NOT EXECUTED
40005f0c: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
40006174 <pthread_mutex_init>:
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr
)
{
40006174: 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;
40006178: 80 a6 60 00 cmp %i1, 0
4000617c: 02 80 00 0f be 400061b8 <pthread_mutex_init+0x44>
<== ALWAYS TAKEN
40006180: ba 10 00 18 mov %i0, %i5
else the_attr = &_POSIX_Mutex_Default_attributes;
/* Check for NULL mutex */
if ( !mutex )
40006184: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
40006188: 02 80 00 44 be 40006298 <pthread_mutex_init+0x124>
<== NOT EXECUTED
4000618c: 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 )
40006190: c2 06 40 00 ld [ %i1 ], %g1
<== NOT EXECUTED
40006194: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40006198: 02 80 00 06 be 400061b0 <pthread_mutex_init+0x3c>
<== NOT EXECUTED
4000619c: b0 10 20 16 mov 0x16, %i0
<== NOT EXECUTED
return EINVAL;
if ( !_POSIX_Is_valid_pshared( the_attr->process_shared ) ) {
400061a0: c2 06 60 04 ld [ %i1 + 4 ], %g1
<== NOT EXECUTED
400061a4: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
400061a8: 28 80 00 16 bleu,a 40006200 <pthread_mutex_init+0x8c>
<== NOT EXECUTED
400061ac: 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;
}
400061b0: 81 c7 e0 08 ret
<== NOT EXECUTED
400061b4: 81 e8 00 00 restore
<== NOT EXECUTED
if ( !mutex )
400061b8: 80 a6 20 00 cmp %i0, 0
400061bc: 02 80 00 37 be 40006298 <pthread_mutex_init+0x124>
<== NEVER TAKEN
400061c0: 03 25 87 04 sethi %hi(0x961c1000), %g1
flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
400061c4: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 <RAM_END+0x55dc13b8>
400061c8: 82 1e 00 01 xor %i0, %g1, %g1
flags &= ~POSIX_MUTEX_FLAGS_MASK;
400061cc: 82 08 7f f8 and %g1, -8, %g1
the_mutex->flags = flags;
400061d0: c2 26 00 00 st %g1, [ %i0 ]
scheduler = NULL;
400061d4: 84 10 20 00 clr %g2
priority = 0;
400061d8: 90 10 20 00 clr %o0
400061dc: 92 10 20 00 clr %o1
queue->heads = NULL;
400061e0: c0 27 60 0c clr [ %i5 + 0xc ]
queue->owner = NULL;
400061e4: c0 27 60 10 clr [ %i5 + 0x10 ]
queue->name = name;
400061e8: c0 27 60 14 clr [ %i5 + 0x14 ]
the_mutex->Recursive.nest_level = 0;
400061ec: c0 27 60 18 clr [ %i5 + 0x18 ]
RTEMS_INLINE_ROUTINE void _Priority_Node_initialize(
Priority_Node *node,
Priority_Control priority
)
{
node->priority = priority;
400061f0: d0 3f 60 30 std %o0, [ %i5 + 0x30 ]
the_mutex->scheduler = scheduler;
400061f4: c4 27 60 38 st %g2, [ %i5 + 0x38 ]
return 0;
400061f8: 81 c7 e0 08 ret
400061fc: 91 e8 20 00 restore %g0, 0, %o0
switch ( the_attr->protocol ) {
40006200: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
40006204: 02 80 00 27 be 400062a0 <pthread_mutex_init+0x12c>
<== NOT EXECUTED
40006208: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
4000620c: 02 80 00 27 be 400062a8 <pthread_mutex_init+0x134>
<== NOT EXECUTED
40006210: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40006214: 12 bf ff e7 bne 400061b0 <pthread_mutex_init+0x3c>
<== NOT EXECUTED
40006218: 84 10 20 00 clr %g2
<== NOT EXECUTED
switch ( the_attr->type ) {
4000621c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
<== NOT EXECUTED
40006220: 80 a0 60 03 cmp %g1, 3
<== NOT EXECUTED
40006224: 18 bf ff e3 bgu 400061b0 <pthread_mutex_init+0x3c>
<== NOT EXECUTED
40006228: b0 10 20 16 mov 0x16, %i0
<== NOT EXECUTED
if ( the_attr->type == PTHREAD_MUTEX_RECURSIVE ) {
4000622c: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
40006230: 03 25 87 04 sethi %hi(0x961c1000), %g1
<== NOT EXECUTED
40006234: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 <RAM_END+0x55dc13b8>
<== NOT EXECUTED
40006238: 82 1f 40 01 xor %i5, %g1, %g1
<== NOT EXECUTED
flags &= ~POSIX_MUTEX_FLAGS_MASK;
4000623c: 82 08 7f f8 and %g1, -8, %g1
<== NOT EXECUTED
if ( the_attr->type == PTHREAD_MUTEX_RECURSIVE ) {
40006240: 12 80 00 03 bne 4000624c <pthread_mutex_init+0xd8>
<== NOT EXECUTED
40006244: 82 10 80 01 or %g2, %g1, %g1
<== NOT EXECUTED
flags |= POSIX_MUTEX_RECURSIVE;
40006248: 82 10 60 04 or %g1, 4, %g1
<== NOT EXECUTED
if ( protocol == POSIX_MUTEX_PRIORITY_CEILING ) {
4000624c: 80 a0 a0 02 cmp %g2, 2
<== NOT EXECUTED
40006250: 12 80 00 18 bne 400062b0 <pthread_mutex_init+0x13c>
<== NOT EXECUTED
40006254: c2 27 40 00 st %g1, [ %i5 ]
<== NOT EXECUTED
prio_ceiling = the_attr->prio_ceiling;
40006258: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
if ( prio_ceiling == INT_MAX ) {
4000625c: 03 1f ff ff sethi %hi(0x7ffffc00), %g1
<== NOT EXECUTED
40006260: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff <RAM_END+0x3fbfffff>
<== NOT EXECUTED
40006264: 80 a2 40 01 cmp %o1, %g1
<== NOT EXECUTED
40006268: 12 80 00 05 bne 4000627c <pthread_mutex_init+0x108>
<== NOT EXECUTED
4000626c: 39 10 00 40 sethi %hi(0x40010000), %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;
40006270: 82 17 23 a0 or %i4, 0x3a0, %g1 ! 400103a0 <_Scheduler_Table>
<== NOT EXECUTED
40006274: d2 00 60 44 ld [ %g1 + 0x44 ], %o1
<== NOT EXECUTED
40006278: 92 02 7f ff add %o1, -1, %o1
<== NOT EXECUTED
priority = _POSIX_Priority_To_core( scheduler, prio_ceiling, &valid );
4000627c: 94 07 bf ff add %fp, -1, %o2
<== NOT EXECUTED
40006280: 40 00 01 75 call 40006854 <_POSIX_Priority_To_core>
<== NOT EXECUTED
40006284: 90 17 23 a0 or %i4, 0x3a0, %o0
<== NOT EXECUTED
if ( !valid ) {
40006288: c2 0f bf ff ldub [ %fp + -1 ], %g1
<== NOT EXECUTED
4000628c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40006290: 12 bf ff d4 bne 400061e0 <pthread_mutex_init+0x6c>
<== NOT EXECUTED
40006294: 84 17 23 a0 or %i4, 0x3a0, %g2
<== NOT EXECUTED
return EINVAL;
40006298: 81 c7 e0 08 ret
<== NOT EXECUTED
4000629c: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
protocol = POSIX_MUTEX_PRIORITY_INHERIT;
400062a0: 10 bf ff df b 4000621c <pthread_mutex_init+0xa8>
<== NOT EXECUTED
400062a4: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
break;
400062a8: 10 bf ff dd b 4000621c <pthread_mutex_init+0xa8>
<== NOT EXECUTED
400062ac: 84 10 20 02 mov 2, %g2
<== NOT EXECUTED
scheduler = NULL;
400062b0: 84 10 20 00 clr %g2
<== NOT EXECUTED
priority = 0;
400062b4: 90 10 20 00 clr %o0
<== NOT EXECUTED
400062b8: 10 bf ff ca b 400061e0 <pthread_mutex_init+0x6c>
<== NOT EXECUTED
400062bc: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000605c <pthread_mutex_setprioceiling>:
int pthread_mutex_setprioceiling(
pthread_mutex_t *mutex,
int prioceiling,
int *old_ceiling
)
{
4000605c: 9d e3 bf 70 save %sp, -144, %sp
POSIX_Mutex_Control *the_mutex;
int error;
int unlock_error;
if ( old_ceiling == NULL ) {
40006060: 80 a6 a0 00 cmp %i2, 0
40006064: 02 80 00 12 be 400060ac <pthread_mutex_setprioceiling+0x50>
<== NEVER TAKEN
40006068: ba 10 20 16 mov 0x16, %i5
/*
* Must acquire the mutex before we can change it's ceiling.
* POSIX says block until we acquire it.
*/
error = pthread_mutex_lock( mutex );
4000606c: 40 00 1b 64 call 4000cdfc <pthread_mutex_lock>
40006070: 90 10 00 18 mov %i0, %o0
if ( error != 0 ) {
40006074: ba 92 20 00 orcc %o0, 0, %i5
40006078: 32 80 00 0d bne,a 400060ac <pthread_mutex_setprioceiling+0x50>
<== NEVER TAKEN
4000607c: ba 10 20 16 mov 0x16, %i5
<== NOT EXECUTED
40006080: c2 06 00 00 ld [ %i0 ], %g1
40006084: 82 08 60 03 and %g1, 3, %g1
return EINVAL;
}
the_mutex = _POSIX_Mutex_Get( mutex );
if (
40006088: 80 a0 60 02 cmp %g1, 2
4000608c: 22 80 00 0a be,a 400060b4 <pthread_mutex_setprioceiling+0x58>
<== NEVER TAKEN
40006090: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
<== NOT EXECUTED
error = 0;
} else {
error = EINVAL;
}
} else {
*old_ceiling = 0;
40006094: c0 26 80 00 clr [ %i2 ]
error = 0;
}
unlock_error = pthread_mutex_unlock( mutex );
40006098: 90 10 00 18 mov %i0, %o0
4000609c: 40 00 00 6a call 40006244 <pthread_mutex_unlock>
400060a0: b0 10 00 1d mov %i5, %i0
_Assert( unlock_error == 0 );
(void) unlock_error;
return error;
}
400060a4: 81 c7 e0 08 ret
400060a8: 81 e8 00 00 restore
400060ac: 81 c7 e0 08 ret
<== NOT EXECUTED
400060b0: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
*old_ceiling = _POSIX_Priority_From_core( scheduler, old_priority );
400060b4: d4 06 20 34 ld [ %i0 + 0x34 ], %o2
<== NOT EXECUTED
400060b8: 39 10 00 3f sethi %hi(0x4000fc00), %i4
<== NOT EXECUTED
400060bc: 40 00 01 11 call 40006500 <_POSIX_Priority_From_core>
<== NOT EXECUTED
400060c0: 90 17 21 58 or %i4, 0x158, %o0 ! 4000fd58 <_Scheduler_Table>
<== NOT EXECUTED
400060c4: d0 26 80 00 st %o0, [ %i2 ]
<== NOT EXECUTED
new_priority = _POSIX_Priority_To_core( scheduler, prioceiling, &valid );
400060c8: 94 07 bf db add %fp, -37, %o2
<== NOT EXECUTED
400060cc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400060d0: 40 00 00 ef call 4000648c <_POSIX_Priority_To_core>
<== NOT EXECUTED
400060d4: 90 17 21 58 or %i4, 0x158, %o0
<== NOT EXECUTED
if ( valid ) {
400060d8: c2 0f bf db ldub [ %fp + -37 ], %g1
<== NOT EXECUTED
400060dc: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400060e0: 32 80 00 04 bne,a 400060f0 <pthread_mutex_setprioceiling+0x94>
<== NOT EXECUTED
400060e4: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
error = EINVAL;
400060e8: 10 bf ff ec b 40006098 <pthread_mutex_setprioceiling+0x3c>
<== NOT EXECUTED
400060ec: ba 10 20 16 mov 0x16, %i5
<== NOT EXECUTED
400060f0: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
<== NOT EXECUTED
{
Thread_Control *owner;
owner = _POSIX_Mutex_Get_owner( the_mutex );
if ( owner != NULL ) {
400060f4: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
400060f8: 22 80 00 1b be,a 40006164 <pthread_mutex_setprioceiling+0x108>
<== NOT EXECUTED
400060fc: d0 3e 20 30 std %o0, [ %i0 + 0x30 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006100: 91 d0 20 09 ta 9
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Wait_acquire(
Thread_Control *the_thread,
Thread_queue_Context *queue_context
)
{
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
40006104: c2 27 bf dc st %g1, [ %fp + -36 ]
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Priority_Node_set_priority(
Priority_Node *node,
Priority_Control priority
)
{
node->priority = priority;
40006108: d0 3e 20 30 std %o0, [ %i0 + 0x30 ]
<== NOT EXECUTED
_Thread_Priority_changed(
4000610c: b6 07 bf dc add %fp, -36, %i3
<== NOT EXECUTED
40006110: 94 10 20 00 clr %o2
<== NOT EXECUTED
40006114: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
40006118: 92 06 20 20 add %i0, 0x20, %o1
<== NOT EXECUTED
4000611c: 40 00 0d cc call 4000984c <_Thread_Priority_changed>
<== NOT EXECUTED
40006120: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006124: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006128: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000612c: 01 00 00 00 nop
<== NOT EXECUTED
const ISR_lock_Context *lock_context
)
{
uint32_t disable_level;
disable_level = cpu_self->thread_dispatch_disable_level;
40006130: 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;
40006134: 82 00 60 01 inc %g1
<== NOT EXECUTED
40006138: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== 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 );
4000613c: b8 10 00 06 mov %g6, %i4
<== NOT EXECUTED
_Thread_Priority_update( &queue_context );
40006140: 40 00 0d ca call 40009868 <_Thread_Priority_update>
<== NOT EXECUTED
40006144: 90 10 00 1b mov %i3, %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;
40006148: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000614c: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
40006150: 02 80 00 07 be 4000616c <pthread_mutex_setprioceiling+0x110>
<== NOT EXECUTED
40006154: 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;
40006158: c2 27 20 18 st %g1, [ %i4 + 0x18 ]
<== NOT EXECUTED
unlock_error = pthread_mutex_unlock( mutex );
4000615c: 10 bf ff d0 b 4000609c <pthread_mutex_setprioceiling+0x40>
<== NOT EXECUTED
40006160: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40006164: 10 bf ff f3 b 40006130 <pthread_mutex_setprioceiling+0xd4>
<== NOT EXECUTED
40006168: b6 07 bf dc add %fp, -36, %i3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000616c: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
40006170: c4 0f 20 1c ldub [ %i4 + 0x1c ], %g2
<== NOT EXECUTED
40006174: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40006178: 12 80 00 07 bne 40006194 <pthread_mutex_setprioceiling+0x138>
<== NOT EXECUTED
4000617c: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
40006180: c0 27 20 18 clr [ %i4 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006184: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006188: 01 00 00 00 nop
<== NOT EXECUTED
4000618c: 10 bf ff c4 b 4000609c <pthread_mutex_setprioceiling+0x40>
<== NOT EXECUTED
40006190: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
40006194: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
40006198: 40 00 0e 10 call 400099d8 <_Thread_Do_dispatch>
<== NOT EXECUTED
4000619c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
400061a0: 10 bf ff f9 b 40006184 <pthread_mutex_setprioceiling+0x128>
<== NOT EXECUTED
400061a4: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
4000660c <pthread_mutex_unlock>:
*/
int pthread_mutex_unlock(
pthread_mutex_t *mutex
)
{
4000660c: 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 );
40006610: 80 a6 20 00 cmp %i0, 0
40006614: 02 80 00 32 be 400066dc <pthread_mutex_unlock+0xd0>
<== NEVER TAKEN
40006618: 05 25 87 04 sethi %hi(0x961c1000), %g2
4000661c: fa 06 00 00 ld [ %i0 ], %i5
40006620: 82 1e 00 1d xor %i0, %i5, %g1
40006624: 84 10 a3 b8 or %g2, 0x3b8, %g2
40006628: 82 18 40 02 xor %g1, %g2, %g1
4000662c: 80 88 7f f8 btst -8, %g1
40006630: 12 80 00 26 bne 400066c8 <pthread_mutex_unlock+0xbc>
<== NEVER TAKEN
40006634: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006638: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000663c: c2 27 bf dc st %g1, [ %fp + -36 ]
executing = _POSIX_Mutex_Acquire( the_mutex, &queue_context );
switch ( _POSIX_Mutex_Get_protocol( flags ) ) {
40006640: ba 8f 60 03 andcc %i5, 3, %i5
40006644: 02 80 00 28 be 400066e4 <pthread_mutex_unlock+0xd8>
<== ALWAYS TAKEN
40006648: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
4000664c: 80 a7 60 02 cmp %i5, 2
<== NOT EXECUTED
40006650: 12 80 00 0a bne 40006678 <pthread_mutex_unlock+0x6c>
<== NOT EXECUTED
40006654: 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 ) ) {
40006658: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
4000665c: 22 80 00 37 be,a 40006738 <pthread_mutex_unlock+0x12c>
<== NOT EXECUTED
40006660: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006664: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006668: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000666c: 01 00 00 00 nop
<== NOT EXECUTED
40006670: 81 c7 e0 08 ret
<== NOT EXECUTED
40006674: 91 e8 20 01 restore %g0, 1, %o0
<== NOT EXECUTED
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
40006678: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
4000667c: 12 bf ff fa bne 40006664 <pthread_mutex_unlock+0x58>
<== NOT EXECUTED
40006680: 01 00 00 00 nop
<== NOT EXECUTED
nest_level = the_mutex->Recursive.nest_level;
40006684: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
if ( nest_level > 0 ) {
40006688: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000668c: 12 80 00 2e bne 40006744 <pthread_mutex_unlock+0x138>
<== NOT EXECUTED
40006690: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40006694: c0 26 20 10 clr [ %i0 + 0x10 ]
<== NOT EXECUTED
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
40006698: d2 06 20 0c ld [ %i0 + 0xc ], %o1
<== NOT EXECUTED
if ( heads == NULL ) {
4000669c: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
400066a0: 02 80 00 2f be 4000675c <pthread_mutex_unlock+0x150>
<== NOT EXECUTED
400066a4: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
_Thread_queue_Surrender(
400066a8: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
400066ac: 90 06 20 0c add %i0, 0xc, %o0
<== NOT EXECUTED
400066b0: 19 10 00 42 sethi %hi(0x40010800), %o4
<== NOT EXECUTED
400066b4: b0 10 20 00 clr %i0
<== NOT EXECUTED
400066b8: 40 00 13 1a call 4000b320 <_Thread_queue_Surrender>
<== NOT EXECUTED
400066bc: 98 13 20 e4 or %o4, 0xe4, %o4
<== NOT EXECUTED
);
break;
}
return _POSIX_Get_error( status );
}
400066c0: 81 c7 e0 08 ret
<== NOT EXECUTED
400066c4: 81 e8 00 00 restore
<== NOT EXECUTED
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
400066c8: 7f ff ff aa call 40006570 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
400066cc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400066d0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400066d4: 12 bf ff d9 bne 40006638 <pthread_mutex_unlock+0x2c>
<== NOT EXECUTED
400066d8: 01 00 00 00 nop
<== NOT EXECUTED
400066dc: 81 c7 e0 08 ret
<== NOT EXECUTED
400066e0: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
400066e4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
400066e8: 80 a2 00 01 cmp %o0, %g1
400066ec: 12 bf ff de bne 40006664 <pthread_mutex_unlock+0x58>
<== NEVER TAKEN
400066f0: 01 00 00 00 nop
nest_level = the_mutex->Recursive.nest_level;
400066f4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
if ( nest_level > 0 ) {
400066f8: 80 a0 60 00 cmp %g1, 0
400066fc: 12 80 00 12 bne 40006744 <pthread_mutex_unlock+0x138>
<== NEVER TAKEN
40006700: 82 00 7f ff add %g1, -1, %g1
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40006704: c0 26 20 10 clr [ %i0 + 0x10 ]
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
40006708: d2 06 20 0c ld [ %i0 + 0xc ], %o1
if ( heads == NULL ) {
4000670c: 80 a2 60 00 cmp %o1, 0
40006710: 02 80 00 13 be 4000675c <pthread_mutex_unlock+0x150>
40006714: 94 10 00 08 mov %o0, %o2
_Thread_queue_Surrender(
40006718: 96 07 bf dc add %fp, -36, %o3
4000671c: 90 06 20 0c add %i0, 0xc, %o0
40006720: 19 10 00 42 sethi %hi(0x40010800), %o4
40006724: b0 10 20 00 clr %i0
40006728: 40 00 12 fe call 4000b320 <_Thread_queue_Surrender>
4000672c: 98 13 21 0c or %o4, 0x10c, %o4
40006730: 81 c7 e0 08 ret
40006734: 81 e8 00 00 restore
return STATUS_NOT_OWNER;
}
nest_level = the_mutex->Recursive.nest_level;
if ( nest_level > 0 ) {
40006738: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000673c: 02 80 00 0d be 40006770 <pthread_mutex_unlock+0x164>
<== NOT EXECUTED
40006740: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
the_mutex->Recursive.nest_level = nest_level - 1;
40006744: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006748: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000674c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006750: 01 00 00 00 nop
<== NOT EXECUTED
40006754: 81 c7 e0 08 ret
<== NOT EXECUTED
40006758: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000675c: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006760: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006764: 01 00 00 00 nop
40006768: 81 c7 e0 08 ret
4000676c: 91 e8 20 00 restore %g0, 0, %o0
40006770: 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(
40006774: b6 06 20 20 add %i0, 0x20, %i3
<== NOT EXECUTED
40006778: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
4000677c: 40 00 0f f5 call 4000a750 <_Thread_Priority_remove>
<== NOT EXECUTED
40006780: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
40006784: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40006788: 82 00 60 01 inc %g1
<== NOT EXECUTED
4000678c: 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;
40006790: d0 06 20 0c ld [ %i0 + 0xc ], %o0
<== NOT EXECUTED
if ( heads != NULL ) {
40006794: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40006798: 02 80 00 2a be 40006840 <pthread_mutex_unlock+0x234>
<== NOT EXECUTED
4000679c: 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 );
400067a0: 39 10 00 42 sethi %hi(0x40010800), %i4
<== NOT EXECUTED
400067a4: b8 17 20 f8 or %i4, 0xf8, %i4 ! 400108f8 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
400067a8: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
<== NOT EXECUTED
400067ac: 9f c0 40 00 call %g1
<== NOT EXECUTED
400067b0: 01 00 00 00 nop
<== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
400067b4: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
<== NOT EXECUTED
new_owner = ( *operations->first )( heads );
400067b8: 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(
400067bc: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
400067c0: 40 00 0f df call 4000a73c <_Thread_Priority_add>
<== NOT EXECUTED
400067c4: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
new_owner,
&the_mutex->Priority_ceiling,
queue_context
);
_Thread_queue_Extract_critical(
400067c8: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
400067cc: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
400067d0: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
400067d4: 40 00 12 92 call 4000b21c <_Thread_queue_Extract_critical>
<== NOT EXECUTED
400067d8: 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 );
400067dc: 40 00 0f e9 call 4000a780 <_Thread_Priority_update>
<== NOT EXECUTED
400067e0: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
400067e4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
400067e8: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
400067ec: 02 80 00 06 be 40006804 <pthread_mutex_unlock+0x1f8>
<== NOT EXECUTED
400067f0: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
400067f4: b0 10 20 00 clr %i0
<== NOT EXECUTED
400067f8: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
400067fc: 81 c7 e0 08 ret
<== NOT EXECUTED
40006800: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006804: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
40006808: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
<== NOT EXECUTED
4000680c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40006810: 12 80 00 07 bne 4000682c <pthread_mutex_unlock+0x220>
<== NOT EXECUTED
40006814: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
40006818: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000681c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006820: 01 00 00 00 nop
<== NOT EXECUTED
40006824: 81 c7 e0 08 ret
<== NOT EXECUTED
40006828: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
4000682c: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
40006830: 40 00 10 30 call 4000a8f0 <_Thread_Do_dispatch>
<== NOT EXECUTED
40006834: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40006838: 10 bf ff f9 b 4000681c <pthread_mutex_unlock+0x210>
<== NOT EXECUTED
4000683c: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40006840: c0 26 20 10 clr [ %i0 + 0x10 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006844: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006848: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000684c: 01 00 00 00 nop
<== NOT EXECUTED
40006850: 30 bf ff e3 b,a 400067dc <pthread_mutex_unlock+0x1d0>
<== NOT EXECUTED
40006014 <pthread_rwlock_destroy>:
#include <rtems/posix/rwlockimpl.h>
int pthread_rwlock_destroy(
pthread_rwlock_t *_rwlock
)
{
40006014: 9d e3 bf a0 save %sp, -96, %sp
POSIX_RWLock_Control *the_rwlock;
Thread_queue_Context queue_context;
the_rwlock = _POSIX_RWLock_Get( _rwlock );
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
40006018: 80 a6 20 00 cmp %i0, 0
4000601c: 02 80 00 16 be 40006074 <pthread_rwlock_destroy+0x60>
<== NEVER TAKEN
40006020: 03 25 88 76 sethi %hi(0x9621d800), %g1
40006024: c4 06 00 00 ld [ %i0 ], %g2
40006028: 82 10 62 bd or %g1, 0x2bd, %g1
4000602c: 82 1e 00 01 xor %i0, %g1, %g1
40006030: 80 a0 40 02 cmp %g1, %g2
40006034: 12 80 00 0b bne 40006060 <pthread_rwlock_destroy+0x4c>
<== NEVER TAKEN
40006038: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000603c: 91 d0 20 09 ta 9
<== NOT EXECUTED
/*
* If there is at least one thread waiting, then do not delete it.
*/
if ( !_Thread_queue_Is_empty( &the_rwlock->RWLock.Queue.Queue ) ) {
40006040: c4 06 20 0c ld [ %i0 + 0xc ], %g2
40006044: 80 a0 a0 00 cmp %g2, 0
40006048: 22 80 00 0d be,a 4000607c <pthread_rwlock_destroy+0x68>
<== ALWAYS TAKEN
4000604c: c4 06 00 00 ld [ %i0 ], %g2
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006050: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006054: 01 00 00 00 nop
<== NOT EXECUTED
_CORE_RWLock_Release( &the_rwlock->RWLock, &queue_context );
return EBUSY;
40006058: 81 c7 e0 08 ret
<== NOT EXECUTED
4000605c: 91 e8 20 10 restore %g0, 0x10, %o0
<== NOT EXECUTED
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
40006060: 40 00 00 a4 call 400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
40006064: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40006068: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000606c: 12 bf ff f4 bne 4000603c <pthread_rwlock_destroy+0x28>
<== NOT EXECUTED
40006070: 01 00 00 00 nop
<== NOT EXECUTED
40006074: 81 c7 e0 08 ret
<== NOT EXECUTED
40006078: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
/*
* POSIX doesn't require behavior when it is locked.
*/
the_rwlock->flags = ~the_rwlock->flags;
4000607c: 84 38 00 02 xnor %g0, %g2, %g2
<== NOT EXECUTED
40006080: c4 26 00 00 st %g2, [ %i0 ]
<== NOT EXECUTED
40006084: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006088: 01 00 00 00 nop
_CORE_RWLock_Release( &the_rwlock->RWLock, &queue_context );
return 0;
}
4000608c: 81 c7 e0 08 ret
40006090: 91 e8 20 00 restore %g0, 0, %o0
40006094 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
40006094: 9d e3 bf a0 save %sp, -96, %sp
POSIX_RWLock_Control *the_rwlock;
the_rwlock = _POSIX_RWLock_Get( rwlock );
if ( the_rwlock == NULL ) {
40006098: 90 96 20 00 orcc %i0, 0, %o0
4000609c: 02 80 00 14 be 400060ec <pthread_rwlock_init+0x58>
<== NEVER TAKEN
400060a0: 80 a6 60 00 cmp %i1, 0
return EINVAL;
}
if ( attr != NULL ) {
400060a4: 02 80 00 0a be 400060cc <pthread_rwlock_init+0x38>
<== NEVER TAKEN
400060a8: 03 25 88 76 sethi %hi(0x9621d800), %g1
if ( !attr->is_initialized ) {
400060ac: c2 06 40 00 ld [ %i1 ], %g1
400060b0: 80 a0 60 00 cmp %g1, 0
400060b4: 02 80 00 0c be 400060e4 <pthread_rwlock_init+0x50>
<== NEVER TAKEN
400060b8: b0 10 20 16 mov 0x16, %i0
return EINVAL;
}
if ( !_POSIX_Is_valid_pshared( attr->process_shared ) ) {
400060bc: c2 06 60 04 ld [ %i1 + 4 ], %g1
400060c0: 80 a0 60 01 cmp %g1, 1
400060c4: 18 80 00 08 bgu 400060e4 <pthread_rwlock_init+0x50>
<== NEVER TAKEN
400060c8: 03 25 88 76 sethi %hi(0x9621d800), %g1
return EINVAL;
}
}
the_rwlock->flags = (uintptr_t) the_rwlock ^ POSIX_RWLOCK_MAGIC;
400060cc: 82 10 62 bd or %g1, 0x2bd, %g1 ! 9621dabd <RAM_END+0x55e1dabd>
400060d0: 82 1a 00 01 xor %o0, %g1, %g1
400060d4: c2 22 00 00 st %g1, [ %o0 ]
_CORE_RWLock_Initialize( &the_rwlock->RWLock );
return 0;
400060d8: b0 10 20 00 clr %i0
_CORE_RWLock_Initialize( &the_rwlock->RWLock );
400060dc: 40 00 01 90 call 4000671c <_CORE_RWLock_Initialize>
400060e0: 90 02 20 04 add %o0, 4, %o0
return 0;
400060e4: 81 c7 e0 08 ret
400060e8: 81 e8 00 00 restore
return EINVAL;
400060ec: b0 10 20 16 mov 0x16, %i0
<== NOT EXECUTED
}
400060f0: 81 c7 e0 08 ret
<== NOT EXECUTED
400060f4: 81 e8 00 00 restore
<== NOT EXECUTED
400060f8 <pthread_rwlock_rdlock>:
#include <rtems/posix/posixapi.h>
int pthread_rwlock_rdlock(
pthread_rwlock_t *rwlock
)
{
400060f8: 9d e3 bf 78 save %sp, -136, %sp
POSIX_RWLock_Control *the_rwlock;
Thread_queue_Context queue_context;
Status_Control status;
the_rwlock = _POSIX_RWLock_Get( rwlock );
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
400060fc: 80 a6 20 00 cmp %i0, 0
40006100: 02 80 00 16 be 40006158 <pthread_rwlock_rdlock+0x60>
<== NEVER TAKEN
40006104: 03 25 88 76 sethi %hi(0x9621d800), %g1
40006108: c4 06 00 00 ld [ %i0 ], %g2
4000610c: 82 10 62 bd or %g1, 0x2bd, %g1
40006110: 82 1e 00 01 xor %i0, %g1, %g1
40006114: 80 a0 40 02 cmp %g1, %g2
40006118: 02 80 00 07 be 40006134 <pthread_rwlock_rdlock+0x3c>
<== ALWAYS TAKEN
4000611c: 03 10 00 27 sethi %hi(0x40009c00), %g1
40006120: 40 00 00 74 call 400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
40006124: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40006128: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000612c: 02 80 00 0b be 40006158 <pthread_rwlock_rdlock+0x60>
<== NOT EXECUTED
40006130: 03 10 00 27 sethi %hi(0x40009c00), %g1
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void
_Thread_queue_Context_set_enqueue_do_nothing_extra(
Thread_queue_Context *queue_context
)
{
queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;
40006134: 82 10 61 8c or %g1, 0x18c, %g1 ! 40009d8c <_Thread_queue_Enqueue_do_nothing_extra>
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context );
status = _CORE_RWLock_Seize_for_reading(
40006138: 94 07 bf dc add %fp, -36, %o2
4000613c: c2 27 bf e4 st %g1, [ %fp + -28 ]
40006140: 90 06 20 04 add %i0, 4, %o0
40006144: 40 00 01 7c call 40006734 <_CORE_RWLock_Seize_for_reading>
40006148: 92 10 20 01 mov 1, %o1
return _POSIX_Get_by_name_error_table[ error ];
}
RTEMS_INLINE_ROUTINE int _POSIX_Get_error( Status_Control status )
{
return STATUS_GET_POSIX( status );
4000614c: b1 3a 60 08 sra %o1, 8, %i0
&the_rwlock->RWLock,
true, /* we are willing to wait forever */
&queue_context
);
return _POSIX_Get_error( status );
}
40006150: 81 c7 e0 08 ret
40006154: 81 e8 00 00 restore
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
40006158: 81 c7 e0 08 ret
<== NOT EXECUTED
4000615c: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
40006160 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
40006160: 9d e3 bf 78 save %sp, -136, %sp
POSIX_RWLock_Control *the_rwlock;
Thread_queue_Context queue_context;
Status_Control status;
the_rwlock = _POSIX_RWLock_Get( rwlock );
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
40006164: 80 a6 20 00 cmp %i0, 0
40006168: 02 80 00 17 be 400061c4 <pthread_rwlock_timedrdlock+0x64>
<== NEVER TAKEN
4000616c: 03 25 88 76 sethi %hi(0x9621d800), %g1
40006170: c4 06 00 00 ld [ %i0 ], %g2
40006174: 82 10 62 bd or %g1, 0x2bd, %g1
40006178: 82 1e 00 01 xor %i0, %g1, %g1
4000617c: 80 a0 40 02 cmp %g1, %g2
40006180: 02 80 00 07 be 4000619c <pthread_rwlock_timedrdlock+0x3c>
<== ALWAYS TAKEN
40006184: 03 10 00 2b sethi %hi(0x4000ac00), %g1
40006188: 40 00 00 5a call 400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
4000618c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40006190: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40006194: 02 80 00 0c be 400061c4 <pthread_rwlock_timedrdlock+0x64>
<== NOT EXECUTED
40006198: 03 10 00 2b sethi %hi(0x4000ac00), %g1
<== NOT EXECUTED
Thread_queue_Context *queue_context,
const struct timespec *abstime
)
{
queue_context->Timeout.arg = abstime;
queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;
4000619c: 82 10 61 24 or %g1, 0x124, %g1 ! 4000ad24 <_Thread_queue_Add_timeout_realtime_timespec>
queue_context->Timeout.arg = abstime;
400061a0: f2 27 bf e8 st %i1, [ %fp + -24 ]
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_set_enqueue_timeout_realtime_timespec(
&queue_context,
abstime
);
status = _CORE_RWLock_Seize_for_reading(
400061a4: 94 07 bf dc add %fp, -36, %o2
queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;
400061a8: c2 27 bf e4 st %g1, [ %fp + -28 ]
400061ac: 90 06 20 04 add %i0, 4, %o0
400061b0: 40 00 01 61 call 40006734 <_CORE_RWLock_Seize_for_reading>
400061b4: 92 10 20 01 mov 1, %o1
400061b8: b1 3a 60 08 sra %o1, 8, %i0
&the_rwlock->RWLock,
true,
&queue_context
);
return _POSIX_Get_error( status );
}
400061bc: 81 c7 e0 08 ret
400061c0: 81 e8 00 00 restore
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
400061c4: 81 c7 e0 08 ret
<== NOT EXECUTED
400061c8: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
400061cc <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
400061cc: 9d e3 bf 78 save %sp, -136, %sp
POSIX_RWLock_Control *the_rwlock;
Thread_queue_Context queue_context;
Status_Control status;
the_rwlock = _POSIX_RWLock_Get( rwlock );
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
400061d0: 80 a6 20 00 cmp %i0, 0
400061d4: 02 80 00 17 be 40006230 <pthread_rwlock_timedwrlock+0x64>
<== NEVER TAKEN
400061d8: 03 25 88 76 sethi %hi(0x9621d800), %g1
400061dc: c4 06 00 00 ld [ %i0 ], %g2
400061e0: 82 10 62 bd or %g1, 0x2bd, %g1
400061e4: 82 1e 00 01 xor %i0, %g1, %g1
400061e8: 80 a0 40 02 cmp %g1, %g2
400061ec: 02 80 00 07 be 40006208 <pthread_rwlock_timedwrlock+0x3c>
<== ALWAYS TAKEN
400061f0: 03 10 00 2b sethi %hi(0x4000ac00), %g1
400061f4: 40 00 00 3f call 400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
400061f8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400061fc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40006200: 02 80 00 0c be 40006230 <pthread_rwlock_timedwrlock+0x64>
<== NOT EXECUTED
40006204: 03 10 00 2b sethi %hi(0x4000ac00), %g1
<== NOT EXECUTED
40006208: 82 10 61 24 or %g1, 0x124, %g1 ! 4000ad24 <_Thread_queue_Add_timeout_realtime_timespec>
queue_context->Timeout.arg = abstime;
4000620c: f2 27 bf e8 st %i1, [ %fp + -24 ]
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_set_enqueue_timeout_realtime_timespec(
&queue_context,
abstime
);
status = _CORE_RWLock_Seize_for_writing(
40006210: 94 07 bf dc add %fp, -36, %o2
queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;
40006214: c2 27 bf e4 st %g1, [ %fp + -28 ]
40006218: 90 06 20 04 add %i0, 4, %o0
4000621c: 40 00 01 78 call 400067fc <_CORE_RWLock_Seize_for_writing>
40006220: 92 10 20 01 mov 1, %o1
40006224: b1 3a 60 08 sra %o1, 8, %i0
&the_rwlock->RWLock,
true,
&queue_context
);
return _POSIX_Get_error( status );
}
40006228: 81 c7 e0 08 ret
4000622c: 81 e8 00 00 restore
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
40006230: 81 c7 e0 08 ret
<== NOT EXECUTED
40006234: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
40006238 <pthread_rwlock_tryrdlock>:
#include <rtems/posix/posixapi.h>
int pthread_rwlock_tryrdlock(
pthread_rwlock_t *rwlock
)
{
40006238: 9d e3 bf 78 save %sp, -136, %sp
POSIX_RWLock_Control *the_rwlock;
Thread_queue_Context queue_context;
Status_Control status;
the_rwlock = _POSIX_RWLock_Get( rwlock );
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
4000623c: 80 a6 20 00 cmp %i0, 0
40006240: 02 80 00 13 be 4000628c <pthread_rwlock_tryrdlock+0x54>
<== NEVER TAKEN
40006244: 03 25 88 76 sethi %hi(0x9621d800), %g1
40006248: c4 06 00 00 ld [ %i0 ], %g2
4000624c: 82 10 62 bd or %g1, 0x2bd, %g1
40006250: 82 1e 00 01 xor %i0, %g1, %g1
40006254: 80 a0 40 02 cmp %g1, %g2
40006258: 02 80 00 07 be 40006274 <pthread_rwlock_tryrdlock+0x3c>
<== ALWAYS TAKEN
4000625c: 94 07 bf dc add %fp, -36, %o2
40006260: 40 00 00 24 call 400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
40006264: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40006268: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000626c: 02 80 00 08 be 4000628c <pthread_rwlock_tryrdlock+0x54>
<== NOT EXECUTED
40006270: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
_Thread_queue_Context_initialize( &queue_context );
status = _CORE_RWLock_Seize_for_reading(
40006274: 90 06 20 04 add %i0, 4, %o0
40006278: 40 00 01 2f call 40006734 <_CORE_RWLock_Seize_for_reading>
4000627c: 92 10 20 00 clr %o1
40006280: b1 3a 60 08 sra %o1, 8, %i0
&the_rwlock->RWLock,
false, /* do not wait for the rwlock */
&queue_context
);
return _POSIX_Get_error( status );
}
40006284: 81 c7 e0 08 ret
40006288: 81 e8 00 00 restore
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
4000628c: 81 c7 e0 08 ret
<== NOT EXECUTED
40006290: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
40006294 <pthread_rwlock_trywrlock>:
#include <rtems/posix/posixapi.h>
int pthread_rwlock_trywrlock(
pthread_rwlock_t *rwlock
)
{
40006294: 9d e3 bf 78 save %sp, -136, %sp
POSIX_RWLock_Control *the_rwlock;
Thread_queue_Context queue_context;
Status_Control status;
the_rwlock = _POSIX_RWLock_Get( rwlock );
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
40006298: 80 a6 20 00 cmp %i0, 0
4000629c: 02 80 00 13 be 400062e8 <pthread_rwlock_trywrlock+0x54>
<== NEVER TAKEN
400062a0: 03 25 88 76 sethi %hi(0x9621d800), %g1
400062a4: c4 06 00 00 ld [ %i0 ], %g2
400062a8: 82 10 62 bd or %g1, 0x2bd, %g1
400062ac: 82 1e 00 01 xor %i0, %g1, %g1
400062b0: 80 a0 40 02 cmp %g1, %g2
400062b4: 02 80 00 07 be 400062d0 <pthread_rwlock_trywrlock+0x3c>
<== ALWAYS TAKEN
400062b8: 94 07 bf dc add %fp, -36, %o2
400062bc: 40 00 00 0d call 400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
400062c0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400062c4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400062c8: 02 80 00 08 be 400062e8 <pthread_rwlock_trywrlock+0x54>
<== NOT EXECUTED
400062cc: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
_Thread_queue_Context_initialize( &queue_context );
status = _CORE_RWLock_Seize_for_writing(
400062d0: 90 06 20 04 add %i0, 4, %o0
400062d4: 40 00 01 4a call 400067fc <_CORE_RWLock_Seize_for_writing>
400062d8: 92 10 20 00 clr %o1
400062dc: b1 3a 60 08 sra %o1, 8, %i0
&the_rwlock->RWLock,
false, /* we are not willing to wait */
&queue_context
);
return _POSIX_Get_error( status );
}
400062e0: 81 c7 e0 08 ret
400062e4: 81 e8 00 00 restore
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
400062e8: 81 c7 e0 08 ret
<== NOT EXECUTED
400062ec: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
40006350 <pthread_rwlock_unlock>:
int pthread_rwlock_unlock(
pthread_rwlock_t *rwlock
)
{
40006350: 9d e3 bf a0 save %sp, -96, %sp
POSIX_RWLock_Control *the_rwlock;
Status_Control status;
the_rwlock = _POSIX_RWLock_Get( rwlock );
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
40006354: 80 a6 20 00 cmp %i0, 0
40006358: 02 80 00 12 be 400063a0 <pthread_rwlock_unlock+0x50>
<== NEVER TAKEN
4000635c: 03 25 88 76 sethi %hi(0x9621d800), %g1
40006360: c4 06 00 00 ld [ %i0 ], %g2
40006364: 82 10 62 bd or %g1, 0x2bd, %g1
40006368: 82 1e 00 01 xor %i0, %g1, %g1
4000636c: 80 a0 40 02 cmp %g1, %g2
40006370: 02 80 00 07 be 4000638c <pthread_rwlock_unlock+0x3c>
<== ALWAYS TAKEN
40006374: 01 00 00 00 nop
40006378: 7f ff ff de call 400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
4000637c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40006380: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40006384: 02 80 00 07 be 400063a0 <pthread_rwlock_unlock+0x50>
<== NOT EXECUTED
40006388: 01 00 00 00 nop
<== NOT EXECUTED
status = _CORE_RWLock_Surrender( &the_rwlock->RWLock );
4000638c: 40 00 01 63 call 40006918 <_CORE_RWLock_Surrender>
40006390: 90 06 20 04 add %i0, 4, %o0
40006394: b1 3a 60 08 sra %o1, 8, %i0
return _POSIX_Get_error( status );
}
40006398: 81 c7 e0 08 ret
4000639c: 81 e8 00 00 restore
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
400063a0: 81 c7 e0 08 ret
<== NOT EXECUTED
400063a4: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
400063a8 <pthread_rwlock_wrlock>:
#include <rtems/posix/posixapi.h>
int pthread_rwlock_wrlock(
pthread_rwlock_t *rwlock
)
{
400063a8: 9d e3 bf 78 save %sp, -136, %sp
POSIX_RWLock_Control *the_rwlock;
Thread_queue_Context queue_context;
Status_Control status;
the_rwlock = _POSIX_RWLock_Get( rwlock );
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
400063ac: 80 a6 20 00 cmp %i0, 0
400063b0: 02 80 00 16 be 40006408 <pthread_rwlock_wrlock+0x60>
<== NEVER TAKEN
400063b4: 03 25 88 76 sethi %hi(0x9621d800), %g1
400063b8: c4 06 00 00 ld [ %i0 ], %g2
400063bc: 82 10 62 bd or %g1, 0x2bd, %g1
400063c0: 82 1e 00 01 xor %i0, %g1, %g1
400063c4: 80 a0 40 02 cmp %g1, %g2
400063c8: 02 80 00 07 be 400063e4 <pthread_rwlock_wrlock+0x3c>
<== ALWAYS TAKEN
400063cc: 03 10 00 27 sethi %hi(0x40009c00), %g1
400063d0: 7f ff ff c8 call 400062f0 <_POSIX_RWLock_Auto_initialization>
<== NOT EXECUTED
400063d4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400063d8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400063dc: 02 80 00 0b be 40006408 <pthread_rwlock_wrlock+0x60>
<== NOT EXECUTED
400063e0: 03 10 00 27 sethi %hi(0x40009c00), %g1
<== NOT EXECUTED
queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;
400063e4: 82 10 61 8c or %g1, 0x18c, %g1 ! 40009d8c <_Thread_queue_Enqueue_do_nothing_extra>
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context );
status = _CORE_RWLock_Seize_for_writing(
400063e8: 94 07 bf dc add %fp, -36, %o2
400063ec: c2 27 bf e4 st %g1, [ %fp + -28 ]
400063f0: 90 06 20 04 add %i0, 4, %o0
400063f4: 40 00 01 02 call 400067fc <_CORE_RWLock_Seize_for_writing>
400063f8: 92 10 20 01 mov 1, %o1
400063fc: b1 3a 60 08 sra %o1, 8, %i0
&the_rwlock->RWLock,
true, /* do not timeout -- wait forever */
&queue_context
);
return _POSIX_Get_error( status );
}
40006400: 81 c7 e0 08 ret
40006404: 81 e8 00 00 restore
POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock );
40006408: 81 c7 e0 08 ret
<== NOT EXECUTED
4000640c: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
400064b4 <pthread_rwlockattr_init>:
int pthread_rwlockattr_init(
pthread_rwlockattr_t *attr
)
{
if ( !attr )
400064b4: 82 92 20 00 orcc %o0, 0, %g1
400064b8: 02 80 00 06 be 400064d0 <pthread_rwlockattr_init+0x1c>
<== NEVER TAKEN
400064bc: 84 10 20 01 mov 1, %g2
return EINVAL;
attr->is_initialized = true;
attr->process_shared = PTHREAD_PROCESS_PRIVATE;
400064c0: c0 20 60 04 clr [ %g1 + 4 ]
return 0;
400064c4: 90 10 20 00 clr %o0
400064c8: 81 c3 e0 08 retl
400064cc: c4 20 40 00 st %g2, [ %g1 ]
}
400064d0: 81 c3 e0 08 retl
<== NOT EXECUTED
400064d4: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
40006554 <pthread_setschedparam>:
const struct sched_param *param
#else
struct sched_param *param
#endif
)
{
40006554: 9d e3 bf 68 save %sp, -152, %sp
Thread_Control *the_thread;
Per_CPU_Control *cpu_self;
Thread_queue_Context queue_context;
int error;
if ( param == NULL ) {
40006558: 80 a6 a0 00 cmp %i2, 0
4000655c: 02 80 00 0a be 40006584 <pthread_setschedparam+0x30>
<== NEVER TAKEN
40006560: b6 10 20 16 mov 0x16, %i3
return EINVAL;
}
error = _POSIX_Thread_Translate_sched_param(
40006564: 96 07 bf d8 add %fp, -40, %o3
40006568: 94 07 bf d4 add %fp, -44, %o2
4000656c: 92 10 00 1a mov %i2, %o1
40006570: 40 00 1c 0c call 4000d5a0 <_POSIX_Thread_Translate_sched_param>
40006574: 90 10 00 19 mov %i1, %o0
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( error != 0 ) {
40006578: b6 92 20 00 orcc %o0, 0, %i3
4000657c: 02 80 00 04 be 4000658c <pthread_setschedparam+0x38>
<== ALWAYS TAKEN
40006580: 90 10 00 18 mov %i0, %o0
cpu_self = _Thread_queue_Dispatch_disable( &queue_context );
_Thread_Wait_release( the_thread, &queue_context );
_Thread_Priority_update( &queue_context );
_Thread_Dispatch_enable( cpu_self );
return error;
}
40006584: 81 c7 e0 08 ret
40006588: 91 e8 00 1b restore %g0, %i3, %o0
4000658c: c0 27 bf f0 clr [ %fp + -16 ]
the_thread = _Thread_Get( thread, &queue_context.Lock_context.Lock_context );
40006590: 40 00 0e 7b call 40009f7c <_Thread_Get>
40006594: 92 07 bf dc add %fp, -36, %o1
if ( the_thread == NULL ) {
40006598: b0 92 20 00 orcc %o0, 0, %i0
4000659c: 02 80 00 41 be 400066a0 <pthread_setschedparam+0x14c>
<== NEVER TAKEN
400065a0: ea 07 bf d4 ld [ %fp + -44 ], %l5
normal_prio = param->sched_priority;
400065a4: e0 06 80 00 ld [ %i2 ], %l0
error = _POSIX_Set_sched_param(
400065a8: e8 07 bf d8 ld [ %fp + -40 ], %l4
core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );
400065ac: 92 10 00 10 mov %l0, %o1
400065b0: 94 07 bf d3 add %fp, -45, %o2
400065b4: 23 10 00 3d sethi %hi(0x4000f400), %l1
400065b8: 40 00 1b c9 call 4000d4dc <_POSIX_Priority_To_core>
400065bc: 90 14 62 b0 or %l1, 0x2b0, %o0 ! 4000f6b0 <_Scheduler_Table>
if ( !valid ) {
400065c0: c2 0f bf d3 ldub [ %fp + -45 ], %g1
core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );
400065c4: b8 10 00 08 mov %o0, %i4
if ( !valid ) {
400065c8: 80 a0 60 00 cmp %g1, 0
400065cc: 02 80 00 37 be 400066a8 <pthread_setschedparam+0x154>
<== NEVER TAKEN
400065d0: ba 10 00 09 mov %o1, %i5
if ( policy == SCHED_SPORADIC ) {
400065d4: 80 a6 60 04 cmp %i1, 4
400065d8: 22 80 00 02 be,a 400065e0 <pthread_setschedparam+0x8c>
<== NEVER TAKEN
400065dc: e0 06 a0 04 ld [ %i2 + 4 ], %l0
<== NOT EXECUTED
core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid );
400065e0: 94 07 bf d3 add %fp, -45, %o2
400065e4: 92 10 00 10 mov %l0, %o1
400065e8: 40 00 1b bd call 4000d4dc <_POSIX_Priority_To_core>
400065ec: 90 14 62 b0 or %l1, 0x2b0, %o0
if ( !valid ) {
400065f0: c2 0f bf d3 ldub [ %fp + -45 ], %g1
core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid );
400065f4: a4 10 00 08 mov %o0, %l2
if ( !valid ) {
400065f8: 80 a0 60 00 cmp %g1, 0
400065fc: 02 80 00 2b be 400066a8 <pthread_setschedparam+0x154>
<== NEVER TAKEN
40006600: a6 10 00 09 mov %o1, %l3
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
40006604: e2 06 21 5c ld [ %i0 + 0x15c ], %l1
_Watchdog_Per_CPU_remove_ticks( &api->Sporadic.Timer );
40006608: a0 04 60 08 add %l1, 8, %l0
_Watchdog_Remove(
4000660c: 11 10 00 4b sethi %hi(0x40012c00), %o0
40006610: 92 10 00 10 mov %l0, %o1
40006614: 40 00 16 57 call 4000bf70 <_Watchdog_Remove>
40006618: 90 12 21 78 or %o0, 0x178, %o0
4000661c: f8 3e 20 30 std %i4, [ %i0 + 0x30 ]
if ( _Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
40006620: c2 04 60 34 ld [ %l1 + 0x34 ], %g1
40006624: 80 a0 7f ff cmp %g1, -1
40006628: 02 80 00 3b be 40006714 <pthread_setschedparam+0x1c0>
<== ALWAYS TAKEN
4000662c: 92 06 20 20 add %i0, 0x20, %o1
_Thread_Priority_add(
40006630: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40006634: 40 00 0d 85 call 40009c48 <_Thread_Priority_add>
<== NOT EXECUTED
40006638: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
_Thread_Priority_remove(
4000663c: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
40006640: 92 04 60 28 add %l1, 0x28, %o1
<== NOT EXECUTED
40006644: 40 00 0d 86 call 40009c5c <_Thread_Priority_remove>
<== NOT EXECUTED
40006648: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000664c: 82 10 3f ff mov -1, %g1
<== NOT EXECUTED
40006650: c2 24 60 34 st %g1, [ %l1 + 0x34 ]
<== NOT EXECUTED
if ( policy == SCHED_SPORADIC ) {
40006654: 80 a6 60 04 cmp %i1, 4
<== NOT EXECUTED
the_thread->budget_algorithm = budget_algorithm;
40006658: ea 26 20 90 st %l5, [ %i0 + 0x90 ]
the_thread->budget_callout = budget_callout;
4000665c: e8 26 20 94 st %l4, [ %i0 + 0x94 ]
40006660: e4 3c 60 38 std %l2, [ %l1 + 0x38 ]
api->Sporadic.sched_ss_max_repl = param->sched_ss_max_repl;
40006664: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
api->Sporadic.sched_ss_repl_period = param->sched_ss_repl_period;
40006668: d4 1e a0 08 ldd [ %i2 + 8 ], %o2
4000666c: d8 1e a0 10 ldd [ %i2 + 0x10 ], %o4
api->Sporadic.sched_ss_init_budget = param->sched_ss_init_budget;
40006670: f8 1e a0 18 ldd [ %i2 + 0x18 ], %i4
40006674: c4 1e a0 20 ldd [ %i2 + 0x20 ], %g2
40006678: c4 3c 60 58 std %g2, [ %l1 + 0x58 ]
api->Sporadic.sched_ss_repl_period = param->sched_ss_repl_period;
4000667c: d4 3c 60 40 std %o2, [ %l1 + 0x40 ]
40006680: d8 3c 60 48 std %o4, [ %l1 + 0x48 ]
api->Sporadic.sched_ss_init_budget = param->sched_ss_init_budget;
40006684: f8 3c 60 50 std %i4, [ %l1 + 0x50 ]
if ( policy == SCHED_SPORADIC ) {
40006688: 02 80 00 2e be 40006740 <pthread_setschedparam+0x1ec>
<== NEVER TAKEN
4000668c: c2 24 60 60 st %g1, [ %l1 + 0x60 ]
rtems_configuration_get_ticks_per_timeslice();
40006690: 03 10 00 3d sethi %hi(0x4000f400), %g1
the_thread->cpu_time_budget =
40006694: c2 00 62 04 ld [ %g1 + 0x204 ], %g1 ! 4000f604 <Configuration+0x18>
40006698: 10 80 00 05 b 400066ac <pthread_setschedparam+0x158>
4000669c: c2 26 20 8c st %g1, [ %i0 + 0x8c ]
return ESRCH;
400066a0: 10 bf ff b9 b 40006584 <pthread_setschedparam+0x30>
<== NOT EXECUTED
400066a4: b6 10 20 03 mov 3, %i3
<== NOT EXECUTED
return EINVAL;
400066a8: b6 10 20 16 mov 0x16, %i3
<== NOT EXECUTED
const ISR_lock_Context *lock_context
)
{
uint32_t disable_level;
disable_level = cpu_self->thread_dispatch_disable_level;
400066ac: 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;
400066b0: 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 );
400066b4: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
400066b8: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400066bc: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400066c0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400066c4: 01 00 00 00 nop
_Thread_Priority_update( &queue_context );
400066c8: 40 00 0d 71 call 40009c8c <_Thread_Priority_update>
400066cc: 90 07 bf dc add %fp, -36, %o0
*
* @param[in] cpu_self The current processor.
*/
RTEMS_INLINE_ROUTINE void _Thread_Dispatch_enable( Per_CPU_Control *cpu_self )
{
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
400066d0: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
if ( disable_level == 1 ) {
400066d4: 80 a0 60 01 cmp %g1, 1
400066d8: 02 80 00 06 be 400066f0 <pthread_setschedparam+0x19c>
<== ALWAYS TAKEN
400066dc: 82 00 7f ff add %g1, -1, %g1
}
400066e0: b0 10 00 1b mov %i3, %i0
<== NOT EXECUTED
}
_ISR_Local_enable( level );
} else {
_Assert( disable_level > 0 );
cpu_self->thread_dispatch_disable_level = disable_level - 1;
400066e4: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
400066e8: 81 c7 e0 08 ret
<== NOT EXECUTED
400066ec: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400066f0: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
400066f4: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
400066f8: 80 a0 a0 00 cmp %g2, 0
400066fc: 12 80 00 0c bne 4000672c <pthread_setschedparam+0x1d8>
40006700: 92 10 00 01 mov %g1, %o1
cpu_self->thread_dispatch_disable_level = 0;
40006704: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006708: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000670c: 01 00 00 00 nop
40006710: 30 bf ff 9d b,a 40006584 <pthread_setschedparam+0x30>
_Thread_Priority_changed(
40006714: 96 07 bf dc add %fp, -36, %o3
40006718: 94 10 20 00 clr %o2
4000671c: 40 00 0d 55 call 40009c70 <_Thread_Priority_changed>
40006720: 90 10 00 18 mov %i0, %o0
if ( policy == SCHED_SPORADIC ) {
40006724: 10 bf ff cd b 40006658 <pthread_setschedparam+0x104>
40006728: 80 a6 60 04 cmp %i1, 4
_Thread_Do_dispatch( cpu_self, level );
4000672c: c2 27 bf cc st %g1, [ %fp + -52 ]
40006730: 40 00 0d b3 call 40009dfc <_Thread_Do_dispatch>
40006734: 90 10 00 1d mov %i5, %o0
40006738: 10 bf ff f4 b 40006708 <pthread_setschedparam+0x1b4>
<== NOT EXECUTED
4000673c: c2 07 bf cc ld [ %fp + -52 ], %g1
<== NOT EXECUTED
_Timespec_To_ticks( &api->Sporadic.sched_ss_init_budget );
40006740: 40 00 14 dc call 4000bab0 <_Timespec_To_ticks>
<== NOT EXECUTED
40006744: 90 04 60 50 add %l1, 0x50, %o0
<== NOT EXECUTED
the_thread->cpu_time_budget =
40006748: d0 26 20 8c st %o0, [ %i0 + 0x8c ]
<== NOT EXECUTED
_Watchdog_Per_CPU_insert_ticks(
4000674c: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
40006750: 40 00 14 d8 call 4000bab0 <_Timespec_To_ticks>
<== NOT EXECUTED
40006754: 90 04 60 40 add %l1, 0x40, %o0
<== NOT EXECUTED
expire = ticks + cpu->Watchdog.ticks;
40006758: d4 1f 60 30 ldd [ %i5 + 0x30 ], %o2
<== NOT EXECUTED
_Watchdog_Insert(header, the_watchdog, expire);
4000675c: 86 82 c0 08 addcc %o3, %o0, %g3
<== NOT EXECUTED
40006760: 84 42 a0 00 addx %o2, 0, %g2
<== NOT EXECUTED
40006764: 96 10 00 03 mov %g3, %o3
<== NOT EXECUTED
40006768: 94 10 00 02 mov %g2, %o2
<== NOT EXECUTED
4000676c: 92 10 00 10 mov %l0, %o1
<== NOT EXECUTED
40006770: 40 00 15 d8 call 4000bed0 <_Watchdog_Insert>
<== NOT EXECUTED
40006774: 90 07 60 38 add %i5, 0x38, %o0
<== NOT EXECUTED
40006778: 30 bf ff cd b,a 400066ac <pthread_setschedparam+0x158>
<== NOT EXECUTED
40005ec8 <pthread_setspecific>:
int pthread_setspecific(
pthread_key_t key,
const void *value
)
{
40005ec8: 9d e3 bf 98 save %sp, -104, %sp
40005ecc: ba 10 00 18 mov %i0, %i5
Thread_Control *executing;
int eno;
executing = _Thread_Get_executing();
if ( value != NULL ) {
40005ed0: 80 a6 60 00 cmp %i1, 0
40005ed4: 02 80 00 52 be 4000601c <pthread_setspecific+0x154>
<== NEVER TAKEN
40005ed8: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005edc: 91 d0 20 09 ta 9
<== NOT EXECUTED
return &RB_ROOT( the_rbtree );
40005ee0: b6 07 21 60 add %i4, 0x160, %i3
link = _RBTree_Root_const_reference( the_rbtree );
40005ee4: 86 10 00 1b mov %i3, %g3
while ( *link != NULL ) {
40005ee8: c4 00 c0 00 ld [ %g3 ], %g2
40005eec: 80 a0 a0 00 cmp %g2, 0
40005ef0: 02 80 00 0d be 40005f24 <pthread_setspecific+0x5c>
<== ALWAYS TAKEN
40005ef4: 86 00 bf f8 add %g2, -8, %g3
return *the_left == the_right->key;
40005ef8: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
<== NOT EXECUTED
if ( ( *equal )( key, parent ) ) {
40005efc: 80 a7 40 04 cmp %i5, %g4
<== NOT EXECUTED
40005f00: 22 80 00 31 be,a 40005fc4 <pthread_setspecific+0xfc>
<== NOT EXECUTED
40005f04: f2 20 e0 20 st %i1, [ %g3 + 0x20 ]
<== NOT EXECUTED
} else if ( ( *less )( key, parent ) ) {
40005f08: 1a bf ff f8 bcc 40005ee8 <pthread_setspecific+0x20>
<== NOT EXECUTED
40005f0c: 86 00 a0 04 add %g2, 4, %g3
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
40005f10: 86 10 00 02 mov %g2, %g3
<== NOT EXECUTED
while ( *link != NULL ) {
40005f14: c4 00 c0 00 ld [ %g3 ], %g2
<== NOT EXECUTED
40005f18: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40005f1c: 12 bf ff f7 bne 40005ef8 <pthread_setspecific+0x30>
<== NOT EXECUTED
40005f20: 86 00 bf f8 add %g2, -8, %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005f24: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005f28: 01 00 00 00 nop
_RTEMS_Lock_allocator();
40005f2c: 40 00 00 f0 call 400062ec <_RTEMS_Lock_allocator>
40005f30: b0 10 20 16 mov 0x16, %i0 ! 16 <_TLS_Alignment+0x15>
return (POSIX_Keys_Control *)
40005f34: 90 10 00 1d mov %i5, %o0
40005f38: 13 10 00 49 sethi %hi(0x40012400), %o1
40005f3c: 40 00 08 27 call 40007fd8 <_Objects_Get_no_protection>
40005f40: 92 12 63 40 or %o1, 0x340, %o1 ! 40012740 <_POSIX_Keys_Information>
if ( the_key != NULL ) {
40005f44: b4 92 20 00 orcc %o0, 0, %i2
40005f48: 02 80 00 31 be 4000600c <pthread_setspecific+0x144>
<== NEVER TAKEN
40005f4c: 01 00 00 00 nop
key_value_pair = _POSIX_Keys_Key_value_allocate();
40005f50: 7f ff ff ce call 40005e88 <_POSIX_Keys_Key_value_allocate>
40005f54: b0 10 20 0c mov 0xc, %i0 ! c <_TLS_Alignment+0xb>
if ( key_value_pair != NULL ) {
40005f58: 80 a2 20 00 cmp %o0, 0
40005f5c: 02 80 00 2c be 4000600c <pthread_setspecific+0x144>
<== NEVER TAKEN
40005f60: 88 10 00 08 mov %o0, %g4
<== NOT EXECUTED
old_last = tail->previous;
40005f64: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
<== NOT EXECUTED
return &the_chain->Tail.Node;
40005f68: 84 06 a0 18 add %i2, 0x18, %g2
<== NOT EXECUTED
key_value_pair->key = key;
40005f6c: fa 22 20 18 st %i5, [ %o0 + 0x18 ]
<== NOT EXECUTED
_RBTree_Initialize_node( &key_value_pair->Lookup_node );
40005f70: b0 02 20 08 add %o0, 8, %i0
<== NOT EXECUTED
key_value_pair->thread = executing;
40005f74: f8 22 20 1c st %i4, [ %o0 + 0x1c ]
<== NOT EXECUTED
key_value_pair->value = RTEMS_DECONST( void *, value );
40005f78: f2 22 20 20 st %i1, [ %o0 + 0x20 ]
<== NOT EXECUTED
the_node->next = tail;
40005f7c: c4 22 00 00 st %g2, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
40005f80: d0 26 a0 1c st %o0, [ %i2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40005f84: d0 20 40 00 st %o0, [ %g1 ]
<== NOT EXECUTED
the_node->previous = old_last;
40005f88: c2 22 20 04 st %g1, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005f8c: 91 d0 20 09 ta 9
<== NOT EXECUTED
parent = NULL;
40005f90: b8 10 20 00 clr %i4
link = _RBTree_Root_reference( the_rbtree );
40005f94: 86 10 00 1b mov %i3, %g3
while ( *link != NULL ) {
40005f98: c4 00 c0 00 ld [ %g3 ], %g2
40005f9c: 80 a0 a0 00 cmp %g2, 0
40005fa0: 22 80 00 41 be,a 400060a4 <pthread_setspecific+0x1dc>
<== ALWAYS TAKEN
40005fa4: f8 21 20 10 st %i4, [ %g4 + 0x10 ]
if ( ( *less )( key, parent ) ) {
40005fa8: f8 00 a0 10 ld [ %g2 + 0x10 ], %i4
<== NOT EXECUTED
40005fac: 80 a7 40 1c cmp %i5, %i4
<== NOT EXECUTED
40005fb0: 1a 80 00 03 bcc 40005fbc <pthread_setspecific+0xf4>
<== NOT EXECUTED
40005fb4: 86 00 a0 04 add %g2, 4, %g3
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
40005fb8: 86 10 00 02 mov %g2, %g3
<== NOT EXECUTED
link = _RBTree_Root_const_reference( the_rbtree );
40005fbc: 10 bf ff f7 b 40005f98 <pthread_setspecific+0xd0>
<== NOT EXECUTED
40005fc0: b8 10 00 02 mov %g2, %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005fc4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005fc8: 01 00 00 00 nop
<== NOT EXECUTED
} else {
eno = _POSIX_Keys_Delete_value( key, executing );
}
return eno;
}
40005fcc: 81 c7 e0 08 ret
<== NOT EXECUTED
40005fd0: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
_RBTree_Extract(
40005fd4: 40 00 08 c9 call 400082f8 <_RBTree_Extract>
<== NOT EXECUTED
40005fd8: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40005fdc: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005fe0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005fe4: 01 00 00 00 nop
<== NOT EXECUTED
next = the_node->next;
40005fe8: c4 07 00 00 ld [ %i4 ], %g2
<== NOT EXECUTED
previous = the_node->previous;
40005fec: c2 07 20 04 ld [ %i4 + 4 ], %g1
<== NOT EXECUTED
next->previous = previous;
40005ff0: c2 20 a0 04 st %g1, [ %g2 + 4 ]
<== NOT EXECUTED
_Freechain_Put( &_POSIX_Keys_Keypool, key_value_pair );
40005ff4: 11 10 00 49 sethi %hi(0x40012400), %o0
<== NOT EXECUTED
previous->next = next;
40005ff8: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
40005ffc: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
eno = 0;
40006000: b0 10 20 00 clr %i0
<== NOT EXECUTED
40006004: 40 00 01 1b call 40006470 <_Freechain_Put>
<== NOT EXECUTED
40006008: 90 12 23 7c or %o0, 0x37c, %o0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
4000600c: 40 00 00 bd call 40006300 <_RTEMS_Unlock_allocator>
40006010: 01 00 00 00 nop
return eno;
40006014: 81 c7 e0 08 ret
40006018: 81 e8 00 00 restore
_RTEMS_Lock_allocator();
4000601c: 40 00 00 b4 call 400062ec <_RTEMS_Lock_allocator>
<== NOT EXECUTED
40006020: 01 00 00 00 nop
<== NOT EXECUTED
return (POSIX_Keys_Control *)
40006024: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40006028: 13 10 00 49 sethi %hi(0x40012400), %o1
<== NOT EXECUTED
eno = EINVAL;
4000602c: b0 10 20 16 mov 0x16, %i0
<== NOT EXECUTED
40006030: 40 00 07 ea call 40007fd8 <_Objects_Get_no_protection>
<== NOT EXECUTED
40006034: 92 12 63 40 or %o1, 0x340, %o1
<== NOT EXECUTED
if ( the_key != NULL ) {
40006038: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000603c: 02 bf ff f4 be 4000600c <pthread_setspecific+0x144>
<== NOT EXECUTED
40006040: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006044: 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(
40006048: 90 07 21 60 add %i4, 0x160, %o0
<== NOT EXECUTED
4000604c: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
while ( *link != NULL ) {
40006050: d2 00 80 00 ld [ %g2 ], %o1
<== NOT EXECUTED
40006054: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
40006058: 02 80 00 0d be 4000608c <pthread_setspecific+0x1c4>
<== NOT EXECUTED
4000605c: b8 02 7f f8 add %o1, -8, %i4
<== NOT EXECUTED
return *the_left == the_right->key;
40006060: c4 07 20 18 ld [ %i4 + 0x18 ], %g2
<== NOT EXECUTED
if ( ( *equal )( key, parent ) ) {
40006064: 80 a7 40 02 cmp %i5, %g2
<== NOT EXECUTED
40006068: 02 bf ff db be 40005fd4 <pthread_setspecific+0x10c>
<== NOT EXECUTED
4000606c: 01 00 00 00 nop
<== NOT EXECUTED
} else if ( ( *less )( key, parent ) ) {
40006070: 1a bf ff f8 bcc 40006050 <pthread_setspecific+0x188>
<== NOT EXECUTED
40006074: 84 02 60 04 add %o1, 4, %g2
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
40006078: 84 10 00 09 mov %o1, %g2
<== NOT EXECUTED
while ( *link != NULL ) {
4000607c: d2 00 80 00 ld [ %g2 ], %o1
<== NOT EXECUTED
40006080: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
40006084: 12 bf ff f7 bne 40006060 <pthread_setspecific+0x198>
<== NOT EXECUTED
40006088: b8 02 7f f8 add %o1, -8, %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000608c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006090: 01 00 00 00 nop
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
40006094: 40 00 00 9b call 40006300 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40006098: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
return eno;
4000609c: 81 c7 e0 08 ret
<== NOT EXECUTED
400060a0: 81 e8 00 00 restore
<== NOT EXECUTED
RB_SET( child, parent, Node );
400060a4: 84 10 20 01 mov 1, %g2
400060a8: c0 21 20 0c clr [ %g4 + 0xc ]
_RBTree_Insert_color( the_rbtree, the_node );
400060ac: 92 10 00 18 mov %i0, %o1
RB_SET( child, parent, Node );
400060b0: c0 21 20 08 clr [ %g4 + 8 ]
_RBTree_Insert_color( the_rbtree, the_node );
400060b4: 90 10 00 1b mov %i3, %o0
RB_SET( child, parent, Node );
400060b8: c4 21 20 14 st %g2, [ %g4 + 0x14 ]
*link = child;
400060bc: f0 20 c0 00 st %i0, [ %g3 ]
_RBTree_Insert_color( the_rbtree, the_node );
400060c0: 40 00 09 f0 call 40008880 <_RBTree_Insert_color>
400060c4: c2 27 bf fc st %g1, [ %fp + -4 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400060c8: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400060cc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400060d0: 01 00 00 00 nop
eno = 0;
400060d4: 10 bf ff ce b 4000600c <pthread_setspecific+0x144>
400060d8: b0 10 20 00 clr %i0 ! 0 <PROM_START>
4000677c <sched_get_priority_max>:
#include <rtems/score/schedulerimpl.h>
int sched_get_priority_max(
int policy
)
{
4000677c: 9d e3 bf a0 save %sp, -96, %sp
40006780: 80 a6 20 04 cmp %i0, 4
40006784: 18 80 00 09 bgu 400067a8 <sched_get_priority_max+0x2c>
<== NEVER TAKEN
40006788: 82 10 20 01 mov 1, %g1
4000678c: b1 28 40 18 sll %g1, %i0, %i0
40006790: 80 8e 20 17 btst 0x17, %i0
RTEMS_INLINE_ROUTINE int _POSIX_Priority_Get_maximum(
const Scheduler_Control *scheduler
)
{
_Assert( (int) scheduler->maximum_priority > 1 );
return (int) scheduler->maximum_priority - 1;
40006794: 02 80 00 05 be 400067a8 <sched_get_priority_max+0x2c>
<== NEVER TAKEN
40006798: 03 10 00 3d sethi %hi(0x4000f400), %g1
4000679c: f0 00 62 f4 ld [ %g1 + 0x2f4 ], %i0 ! 4000f6f4 <_Scheduler_Table+0x44>
rtems_set_errno_and_return_minus_one( EINVAL );
}
scheduler = _Thread_Scheduler_get_home( _Thread_Get_executing() );
return _POSIX_Priority_Get_maximum( scheduler );
}
400067a0: 81 c7 e0 08 ret
400067a4: 91 ee 3f ff restore %i0, -1, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
400067a8: 40 00 1e 76 call 4000e180 <__errno>
<== NOT EXECUTED
400067ac: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400067b0: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400067b4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400067b8: 81 c7 e0 08 ret
<== NOT EXECUTED
400067bc: 81 e8 00 00 restore
<== NOT EXECUTED
4000664c <sched_get_priority_min>:
* 13.3.6 Get Scheduling Parameter Limits, P1003.1b-1993, p. 258
*/
int sched_get_priority_min(
int policy
)
{
4000664c: 9d e3 bf a0 save %sp, -96, %sp
40006650: 80 a6 20 04 cmp %i0, 4
40006654: 18 80 00 08 bgu 40006674 <sched_get_priority_min+0x28>
<== NEVER TAKEN
40006658: 82 10 20 01 mov 1, %g1
4000665c: 83 28 40 18 sll %g1, %i0, %g1
40006660: 80 88 60 17 btst 0x17, %g1
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
40006664: 02 80 00 04 be 40006674 <sched_get_priority_min+0x28>
<== NEVER TAKEN
40006668: 84 10 20 01 mov 1, %g2
}
4000666c: 81 c7 e0 08 ret
40006670: 91 e8 00 02 restore %g0, %g2, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
40006674: 40 00 1e 32 call 4000df3c <__errno>
<== NOT EXECUTED
40006678: 01 00 00 00 nop
<== NOT EXECUTED
4000667c: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
40006680: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
40006684: 10 bf ff fa b 4000666c <sched_get_priority_min+0x20>
<== NOT EXECUTED
40006688: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005fac <sem_close>:
#endif
#include <rtems/posix/semaphoreimpl.h>
int sem_close( sem_t *sem )
{
40005fac: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Semaphore_Control *the_semaphore;
uint32_t open_count;
POSIX_SEMAPHORE_VALIDATE_OBJECT( sem );
40005fb0: 80 a6 20 00 cmp %i0, 0
40005fb4: 02 80 00 22 be 4000603c <sem_close+0x90>
<== NEVER TAKEN
40005fb8: 03 17 4d 9f sethi %hi(0x5d367c00), %g1
40005fbc: c4 06 00 00 ld [ %i0 ], %g2
40005fc0: 82 10 63 e7 or %g1, 0x3e7, %g1
40005fc4: 82 1e 00 01 xor %i0, %g1, %g1
40005fc8: 80 a0 40 02 cmp %g1, %g2
40005fcc: 12 80 00 1c bne 4000603c <sem_close+0x90>
<== NEVER TAKEN
40005fd0: 01 00 00 00 nop
if ( !_POSIX_Semaphore_Is_named( sem ) ) {
40005fd4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40005fd8: 80 a0 60 00 cmp %g1, 0
40005fdc: 02 80 00 18 be 4000603c <sem_close+0x90>
<== NEVER TAKEN
40005fe0: 01 00 00 00 nop
_RTEMS_Lock_allocator();
40005fe4: 40 00 01 4a call 4000650c <_RTEMS_Lock_allocator>
40005fe8: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get(
sem_t *sem
)
{
return RTEMS_CONTAINER_OF( sem, POSIX_Semaphore_Control, Semaphore );
40005fec: 90 06 3f f0 add %i0, -16, %o0
the_semaphore = _POSIX_Semaphore_Get( sem );
_Objects_Allocator_lock();
open_count = the_semaphore->open_count;
40005ff0: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
if ( open_count == 0 ) {
40005ff4: 80 a0 60 00 cmp %g1, 0
40005ff8: 02 80 00 0f be 40006034 <sem_close+0x88>
<== NEVER TAKEN
40005ffc: 80 a0 60 01 cmp %g1, 1
_Objects_Allocator_unlock();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( open_count == 1 && _POSIX_Semaphore_Is_busy( sem ) ) {
40006000: 12 80 00 06 bne 40006018 <sem_close+0x6c>
40006004: 82 00 7f ff add %g1, -1, %g1
40006008: c4 06 20 0c ld [ %i0 + 0xc ], %g2
4000600c: 80 a0 a0 00 cmp %g2, 0
40006010: 12 80 00 11 bne 40006054 <sem_close+0xa8>
<== NEVER TAKEN
40006014: 01 00 00 00 nop
_Objects_Allocator_unlock();
rtems_set_errno_and_return_minus_one( EBUSY );
}
the_semaphore->open_count = open_count - 1;
40006018: c2 22 20 30 st %g1, [ %o0 + 0x30 ]
_POSIX_Semaphore_Delete( the_semaphore );
4000601c: 40 00 1b 41 call 4000cd20 <_POSIX_Semaphore_Delete>
40006020: b0 10 20 00 clr %i0
_RTEMS_Unlock_allocator();
40006024: 40 00 01 3f call 40006520 <_RTEMS_Unlock_allocator>
40006028: 01 00 00 00 nop
_Objects_Allocator_unlock();
return 0;
}
4000602c: 81 c7 e0 08 ret
40006030: 81 e8 00 00 restore
40006034: 40 00 01 3b call 40006520 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40006038: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
4000603c: 40 00 20 db call 4000e3a8 <__errno>
<== NOT EXECUTED
40006040: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40006044: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40006048: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000604c: 81 c7 e0 08 ret
<== NOT EXECUTED
40006050: 81 e8 00 00 restore
<== NOT EXECUTED
40006054: 40 00 01 33 call 40006520 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40006058: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
4000605c: 40 00 20 d3 call 4000e3a8 <__errno>
<== NOT EXECUTED
40006060: 01 00 00 00 nop
<== NOT EXECUTED
40006064: 82 10 20 10 mov 0x10, %g1 ! 10 <_TLS_Alignment+0xf>
<== NOT EXECUTED
40006068: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000606c: 81 c7 e0 08 ret
<== NOT EXECUTED
40006070: 81 e8 00 00 restore
<== NOT EXECUTED
40006074 <sem_destroy>:
#endif
#include <rtems/posix/semaphoreimpl.h>
int sem_destroy( sem_t *sem )
{
40006074: 9d e3 bf a0 save %sp, -96, %sp
POSIX_SEMAPHORE_VALIDATE_OBJECT( sem );
40006078: 80 a6 20 00 cmp %i0, 0
4000607c: 02 80 00 13 be 400060c8 <sem_destroy+0x54>
<== NEVER TAKEN
40006080: 03 17 4d 9f sethi %hi(0x5d367c00), %g1
40006084: c4 06 00 00 ld [ %i0 ], %g2
40006088: 82 10 63 e7 or %g1, 0x3e7, %g1
4000608c: 82 1e 00 01 xor %i0, %g1, %g1
40006090: 80 a0 40 02 cmp %g1, %g2
40006094: 12 80 00 0d bne 400060c8 <sem_destroy+0x54>
<== NEVER TAKEN
40006098: 01 00 00 00 nop
if ( _POSIX_Semaphore_Is_named( sem ) ) {
4000609c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
400060a0: 80 a0 60 00 cmp %g1, 0
400060a4: 12 80 00 09 bne 400060c8 <sem_destroy+0x54>
<== NEVER TAKEN
400060a8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( _POSIX_Semaphore_Is_busy( sem ) ) {
400060ac: c2 06 20 0c ld [ %i0 + 0xc ], %g1
400060b0: 80 a0 60 00 cmp %g1, 0
400060b4: 12 80 00 0b bne 400060e0 <sem_destroy+0x6c>
<== NEVER TAKEN
400060b8: 01 00 00 00 nop
_Semaphore_Initialize_named( &sem->_Semaphore, name, value );
}
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Destroy( sem_t *sem )
{
sem->_flags = 0;
400060bc: c0 26 00 00 clr [ %i0 ]
rtems_set_errno_and_return_minus_one( EBUSY );
}
_POSIX_Semaphore_Destroy( sem );
return 0;
}
400060c0: 81 c7 e0 08 ret
400060c4: 91 e8 20 00 restore %g0, 0, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
400060c8: 40 00 20 b8 call 4000e3a8 <__errno>
<== NOT EXECUTED
400060cc: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400060d0: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400060d4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400060d8: 81 c7 e0 08 ret
<== NOT EXECUTED
400060dc: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
400060e0: 40 00 20 b2 call 4000e3a8 <__errno>
<== NOT EXECUTED
400060e4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400060e8: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
400060ec: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400060f0: 81 c7 e0 08 ret
<== NOT EXECUTED
400060f4: 81 e8 00 00 restore
<== NOT EXECUTED
40005f34 <sem_getvalue>:
int sem_getvalue(
sem_t *__restrict _sem,
int *__restrict sval
)
{
40005f34: 9d e3 bf a0 save %sp, -96, %sp
Sem_Control *sem;
ISR_Level level;
Thread_queue_Context queue_context;
POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
40005f38: 80 a6 20 00 cmp %i0, 0
40005f3c: 02 80 00 0f be 40005f78 <sem_getvalue+0x44>
<== NEVER TAKEN
40005f40: 03 17 4d 9f sethi %hi(0x5d367c00), %g1
40005f44: c4 06 00 00 ld [ %i0 ], %g2
40005f48: 82 10 63 e7 or %g1, 0x3e7, %g1
40005f4c: 82 1e 00 01 xor %i0, %g1, %g1
40005f50: 80 a0 40 02 cmp %g1, %g2
40005f54: 12 80 00 09 bne 40005f78 <sem_getvalue+0x44>
<== NEVER TAKEN
40005f58: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005f5c: 91 d0 20 09 ta 9
<== NOT EXECUTED
sem = _Sem_Get( &_sem->_Semaphore );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
_Sem_Queue_acquire_critical( sem, &queue_context );
*sval = (int) sem->count;
40005f60: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
<== NOT EXECUTED
40005f64: c4 26 40 00 st %g2, [ %i1 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005f68: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005f6c: 01 00 00 00 nop
_Sem_Queue_release( sem, level, &queue_context );
return 0;
}
40005f70: 81 c7 e0 08 ret
40005f74: 91 e8 20 00 restore %g0, 0, %o0
POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
40005f78: 40 00 20 5e call 4000e0f0 <__errno>
<== NOT EXECUTED
40005f7c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005f80: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40005f84: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005f88: 81 c7 e0 08 ret
<== NOT EXECUTED
40005f8c: 81 e8 00 00 restore
<== NOT EXECUTED
400060f8 <sem_init>:
int sem_init(
sem_t *sem,
int pshared,
unsigned int value
)
{
400060f8: 9d e3 bf a0 save %sp, -96, %sp
if ( sem == NULL ) {
400060fc: 82 96 20 00 orcc %i0, 0, %g1
40006100: 02 80 00 0f be 4000613c <sem_init+0x44>
<== NEVER TAKEN
40006104: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( value > SEM_VALUE_MAX ) {
40006108: 06 80 00 0d bl 4000613c <sem_init+0x44>
<== NEVER TAKEN
4000610c: 05 17 4d 9f sethi %hi(0x5d367c00), %g2
const char *_name, unsigned int _count)
{
struct _Semaphore_Control _init =
_SEMAPHORE_NAMED_INITIALIZER(_name, _count);
*_semaphore = _init;
40006110: c0 20 60 04 clr [ %g1 + 4 ]
40006114: c0 20 60 08 clr [ %g1 + 8 ]
sem->_flags = (uintptr_t) sem ^ POSIX_SEMAPHORE_MAGIC;
40006118: 84 10 a3 e7 or %g2, 0x3e7, %g2
4000611c: c0 20 60 0c clr [ %g1 + 0xc ]
40006120: 84 18 40 02 xor %g1, %g2, %g2
40006124: c4 20 40 00 st %g2, [ %g1 ]
40006128: c0 20 60 10 clr [ %g1 + 0x10 ]
4000612c: c0 20 60 14 clr [ %g1 + 0x14 ]
40006130: f4 20 60 18 st %i2, [ %g1 + 0x18 ]
rtems_set_errno_and_return_minus_one( EINVAL );
}
_POSIX_Semaphore_Initialize( sem, NULL, value );
return 0;
}
40006134: 81 c7 e0 08 ret
40006138: 91 e8 20 00 restore %g0, 0, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
4000613c: 40 00 20 9b call 4000e3a8 <__errno>
<== NOT EXECUTED
40006140: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006144: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40006148: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000614c: 81 c7 e0 08 ret
<== NOT EXECUTED
40006150: 81 e8 00 00 restore
<== NOT EXECUTED
40006154 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
40006154: 9d e3 bf 90 save %sp, -112, %sp
size_t name_len;
Objects_Get_by_name_error error;
sem_t *sem;
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
40006158: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
if ( oflag & O_CREAT ) {
4000615c: 80 8e 62 00 btst 0x200, %i1
va_start(arg, oflag);
40006160: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40006164: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
if ( oflag & O_CREAT ) {
40006168: 12 80 00 18 bne 400061c8 <sem_open+0x74>
4000616c: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
_RTEMS_Lock_allocator();
40006170: 40 00 00 e7 call 4000650c <_RTEMS_Lock_allocator>
40006174: 01 00 00 00 nop
const char *name,
size_t *name_length_p,
Objects_Get_by_name_error *error
)
{
return (POSIX_Semaphore_Control *) _Objects_Get_by_name(
40006178: 96 07 bf fc add %fp, -4, %o3
4000617c: 94 07 bf f8 add %fp, -8, %o2
40006180: 92 10 00 18 mov %i0, %o1
40006184: 11 10 00 4c sethi %hi(0x40013000), %o0
40006188: 40 00 08 36 call 40008260 <_Objects_Get_by_name>
4000618c: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 400132d0 <_POSIX_Semaphore_Information>
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "semaphore does not exist"
* or some other miscellaneous error on the name.
*/
if ( the_semaphore == NULL ) {
40006190: 80 a2 20 00 cmp %o0, 0
40006194: 02 80 00 3f be 40006290 <sem_open+0x13c>
<== NEVER TAKEN
40006198: 01 00 00 00 nop
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
4000619c: b2 0e 6a 00 and %i1, 0xa00, %i1
400061a0: 80 a6 6a 00 cmp %i1, 0xa00
400061a4: 02 80 00 46 be 400062bc <sem_open+0x168>
<== NEVER TAKEN
400061a8: 01 00 00 00 nop
_Objects_Allocator_unlock();
rtems_set_errno_and_return_value( EEXIST, SEM_FAILED );
}
the_semaphore->open_count += 1;
400061ac: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
400061b0: 82 00 60 01 inc %g1
400061b4: c2 22 20 30 st %g1, [ %o0 + 0x30 ]
_RTEMS_Unlock_allocator();
400061b8: 40 00 00 da call 40006520 <_RTEMS_Unlock_allocator>
400061bc: b0 02 20 10 add %o0, 0x10, %i0
_Objects_Allocator_unlock();
return &the_semaphore->Semaphore;
400061c0: 81 c7 e0 08 ret
400061c4: 81 e8 00 00 restore
va_start(arg, oflag);
400061c8: 82 07 a0 4c add %fp, 0x4c, %g1
_RTEMS_Lock_allocator();
400061cc: 40 00 00 d0 call 4000650c <_RTEMS_Lock_allocator>
400061d0: c2 27 bf f4 st %g1, [ %fp + -12 ]
400061d4: 3b 10 00 4c sethi %hi(0x40013000), %i5
400061d8: 96 07 bf fc add %fp, -4, %o3
400061dc: 94 07 bf f8 add %fp, -8, %o2
400061e0: 92 10 00 18 mov %i0, %o1
400061e4: 40 00 08 1f call 40008260 <_Objects_Get_by_name>
400061e8: 90 17 62 d0 or %i5, 0x2d0, %o0
if ( the_semaphore == NULL ) {
400061ec: 80 a2 20 00 cmp %o0, 0
400061f0: 12 bf ff eb bne 4000619c <sem_open+0x48>
<== NEVER TAKEN
400061f4: c2 07 bf fc ld [ %fp + -4 ], %g1
if ( !( error == OBJECTS_GET_BY_NAME_NO_OBJECT && (oflag & O_CREAT) ) ) {
400061f8: 80 a0 60 02 cmp %g1, 2
400061fc: 12 80 00 25 bne 40006290 <sem_open+0x13c>
<== NEVER TAKEN
40006200: 80 a6 e0 00 cmp %i3, 0
if ( value > SEM_VALUE_MAX ) {
40006204: 06 80 00 36 bl 400062dc <sem_open+0x188>
<== NEVER TAKEN
40006208: d2 07 bf f8 ld [ %fp + -8 ], %o1
name = _Workspace_String_duplicate( name_arg, name_len );
4000620c: 40 00 14 5b call 4000b378 <_Workspace_String_duplicate>
40006210: 90 10 00 18 mov %i0, %o0
if ( name == NULL ) {
40006214: b8 92 20 00 orcc %o0, 0, %i4
40006218: 02 80 00 36 be 400062f0 <sem_open+0x19c>
<== NEVER TAKEN
4000621c: 01 00 00 00 nop
return (POSIX_Semaphore_Control *)
40006220: 40 00 06 c3 call 40007d2c <_Objects_Allocate_unprotected>
40006224: 90 17 62 d0 or %i5, 0x2d0, %o0
if ( the_semaphore == NULL ) {
40006228: 80 a2 20 00 cmp %o0, 0
4000622c: 02 80 00 36 be 40006304 <sem_open+0x1b0>
<== NEVER TAKEN
40006230: 82 10 20 01 mov 1, %g1
information->local_table[ index ] = the_object;
40006234: c4 12 20 0a lduh [ %o0 + 0xa ], %g2
the_semaphore->open_count = 1;
40006238: c2 22 20 30 st %g1, [ %o0 + 0x30 ]
_POSIX_Semaphore_Initialize( &the_semaphore->Semaphore, name, value );
4000623c: b0 02 20 10 add %o0, 0x10, %i0
the_semaphore->linked = true;
40006240: c2 2a 20 2c stb %g1, [ %o0 + 0x2c ]
sem->_flags = (uintptr_t) sem ^ POSIX_SEMAPHORE_MAGIC;
40006244: 03 17 4d 9f sethi %hi(0x5d367c00), %g1
40006248: 82 10 63 e7 or %g1, 0x3e7, %g1 ! 5d367fe7 <RAM_END+0x1cf67fe7>
4000624c: 82 1e 00 01 xor %i0, %g1, %g1
40006250: c0 22 20 14 clr [ %o0 + 0x14 ]
40006254: ba 17 62 d0 or %i5, 0x2d0, %i5
40006258: c2 22 20 10 st %g1, [ %o0 + 0x10 ]
4000625c: 83 28 a0 02 sll %g2, 2, %g1
40006260: c0 22 20 18 clr [ %o0 + 0x18 ]
40006264: c0 22 20 1c clr [ %o0 + 0x1c ]
40006268: c0 22 20 20 clr [ %o0 + 0x20 ]
4000626c: f8 22 20 24 st %i4, [ %o0 + 0x24 ]
40006270: f6 22 20 28 st %i3, [ %o0 + 0x28 ]
the_object->name.name_p = name;
40006274: f8 22 20 0c st %i4, [ %o0 + 0xc ]
information->local_table[ index ] = the_object;
40006278: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
4000627c: d0 20 80 01 st %o0, [ %g2 + %g1 ]
_RTEMS_Unlock_allocator();
40006280: 40 00 00 a8 call 40006520 <_RTEMS_Unlock_allocator>
40006284: 01 00 00 00 nop
value
);
_Objects_Allocator_unlock();
return sem;
}
40006288: 81 c7 e0 08 ret
4000628c: 81 e8 00 00 restore
40006290: 40 00 00 a4 call 40006520 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40006294: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_set_errno_and_return_value(
40006298: 40 00 20 44 call 4000e3a8 <__errno>
<== NOT EXECUTED
4000629c: fa 07 bf fc ld [ %fp + -4 ], %i5
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE int _POSIX_Get_by_name_error(
Objects_Get_by_name_error error
)
{
_Assert( (size_t) error < RTEMS_ARRAY_SIZE( _POSIX_Get_by_name_error_table ) );
return _POSIX_Get_by_name_error_table[ error ];
400062a0: bb 2f 60 02 sll %i5, 2, %i5
<== NOT EXECUTED
400062a4: 03 10 00 40 sethi %hi(0x40010000), %g1
<== NOT EXECUTED
400062a8: 82 10 63 00 or %g1, 0x300, %g1 ! 40010300 <_POSIX_Get_by_name_error_table>
<== NOT EXECUTED
400062ac: c2 00 40 1d ld [ %g1 + %i5 ], %g1
<== NOT EXECUTED
400062b0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400062b4: 81 c7 e0 08 ret
<== NOT EXECUTED
400062b8: 81 e8 00 00 restore
<== NOT EXECUTED
400062bc: 40 00 00 99 call 40006520 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
400062c0: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_set_errno_and_return_value( EEXIST, SEM_FAILED );
400062c4: 40 00 20 39 call 4000e3a8 <__errno>
<== NOT EXECUTED
400062c8: 01 00 00 00 nop
<== NOT EXECUTED
400062cc: 82 10 20 11 mov 0x11, %g1 ! 11 <_TLS_Alignment+0x10>
<== NOT EXECUTED
400062d0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400062d4: 81 c7 e0 08 ret
<== NOT EXECUTED
400062d8: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_value( EINVAL, SEM_FAILED );
400062dc: 40 00 20 33 call 4000e3a8 <__errno>
<== NOT EXECUTED
400062e0: b0 10 20 00 clr %i0
<== NOT EXECUTED
400062e4: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400062e8: 10 bf ff e6 b 40006280 <sem_open+0x12c>
<== NOT EXECUTED
400062ec: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rtems_set_errno_and_return_value( ENOMEM, SEM_FAILED );
400062f0: 40 00 20 2e call 4000e3a8 <__errno>
<== NOT EXECUTED
400062f4: b0 10 20 00 clr %i0
<== NOT EXECUTED
400062f8: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
400062fc: 10 bf ff e1 b 40006280 <sem_open+0x12c>
<== NOT EXECUTED
40006300: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
_Workspace_Free( name );
40006304: 40 00 14 08 call 4000b324 <_Workspace_Free>
<== NOT EXECUTED
40006308: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
rtems_set_errno_and_return_value( ENOSPC, SEM_FAILED );
4000630c: 40 00 20 27 call 4000e3a8 <__errno>
<== NOT EXECUTED
40006310: b0 10 20 00 clr %i0
<== NOT EXECUTED
40006314: 82 10 20 1c mov 0x1c, %g1
<== NOT EXECUTED
40006318: 10 bf ff da b 40006280 <sem_open+0x12c>
<== NOT EXECUTED
4000631c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005fec <sem_post>:
#include <rtems/posix/semaphoreimpl.h>
#include <limits.h>
int sem_post( sem_t *_sem )
{
40005fec: 9d e3 bf 78 save %sp, -136, %sp
ISR_Level level;
Thread_queue_Context queue_context;
Thread_queue_Heads *heads;
unsigned int count;
POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
40005ff0: 80 a6 20 00 cmp %i0, 0
40005ff4: 02 80 00 27 be 40006090 <sem_post+0xa4>
<== NEVER TAKEN
40005ff8: 03 17 4d 9f sethi %hi(0x5d367c00), %g1
40005ffc: c4 06 00 00 ld [ %i0 ], %g2
40006000: 82 10 63 e7 or %g1, 0x3e7, %g1
40006004: 82 1e 00 01 xor %i0, %g1, %g1
40006008: 80 a0 40 02 cmp %g1, %g2
4000600c: 12 80 00 21 bne 40006090 <sem_post+0xa4>
<== NEVER TAKEN
40006010: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006014: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
40006018: 88 10 00 01 mov %g1, %g4
sem = _Sem_Get( &_sem->_Semaphore );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
_Sem_Queue_acquire_critical( sem, &queue_context );
heads = sem->Queue.Queue.heads;
4000601c: d0 06 20 0c ld [ %i0 + 0xc ], %o0
count = sem->count;
if ( __predict_true( heads == NULL && count < SEM_VALUE_MAX ) ) {
40006020: 80 a2 20 00 cmp %o0, 0
40006024: 12 80 00 0d bne 40006058 <sem_post+0x6c>
40006028: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
4000602c: 07 1f ff ff sethi %hi(0x7ffffc00), %g3
40006030: 86 10 e3 fe or %g3, 0x3fe, %g3 ! 7ffffffe <RAM_END+0x3fbffffe>
40006034: 80 a0 c0 02 cmp %g3, %g2
40006038: 0a 80 00 07 bcs 40006054 <sem_post+0x68>
<== NEVER TAKEN
4000603c: 84 00 a0 01 inc %g2
<== NOT EXECUTED
sem->count = count + 1;
40006040: c4 26 20 18 st %g2, [ %i0 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006044: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006048: 01 00 00 00 nop
_Sem_Queue_release( sem, level, &queue_context );
return 0;
4000604c: 81 c7 e0 08 ret
40006050: 91 e8 20 00 restore %g0, 0, %o0
}
if ( __predict_true( heads != NULL ) ) {
40006054: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40006058: 02 80 00 14 be 400060a8 <sem_post+0xbc>
<== NEVER TAKEN
4000605c: 3b 10 00 3e sethi %hi(0x4000f800), %i5
const Thread_queue_Operations *operations;
Thread_Control *first;
_Thread_queue_Context_set_ISR_level( &queue_context, level );
operations = SEMAPHORE_TQ_OPERATIONS;
first = ( *operations->first )( heads );
40006060: ba 17 63 e8 or %i5, 0x3e8, %i5 ! 4000fbe8 <_Thread_queue_Operations_priority>
40006064: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40006068: 9f c0 40 00 call %g1
4000606c: c8 27 bf dc st %g4, [ %fp + -36 ]
_Thread_queue_Extract_critical(
40006070: 96 07 bf dc add %fp, -36, %o3
40006074: 94 10 00 08 mov %o0, %o2
40006078: 92 10 00 1d mov %i5, %o1
4000607c: 90 06 20 0c add %i0, 0xc, %o0
40006080: 40 00 0e 5d call 400099f4 <_Thread_queue_Extract_critical>
40006084: b0 10 20 00 clr %i0
&sem->Queue.Queue,
operations,
first,
&queue_context
);
return 0;
40006088: 81 c7 e0 08 ret
4000608c: 81 e8 00 00 restore
POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
40006090: 40 00 20 18 call 4000e0f0 <__errno>
<== NOT EXECUTED
40006094: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006098: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4000609c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400060a0: 81 c7 e0 08 ret
<== NOT EXECUTED
400060a4: 81 e8 00 00 restore
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400060a8: 82 10 00 04 mov %g4, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400060ac: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400060b0: 01 00 00 00 nop
<== NOT EXECUTED
}
_Sem_Queue_release( sem, level, &queue_context );
rtems_set_errno_and_return_minus_one( EOVERFLOW );
400060b4: 40 00 20 0f call 4000e0f0 <__errno>
<== NOT EXECUTED
400060b8: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
400060bc: 82 10 20 8b mov 0x8b, %g1
<== NOT EXECUTED
400060c0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
400060c4: 81 c7 e0 08 ret
<== NOT EXECUTED
400060c8: 81 e8 00 00 restore
<== NOT EXECUTED
400060cc <sem_trywait>:
#endif
#include <rtems/posix/semaphoreimpl.h>
int sem_trywait( sem_t *_sem )
{
400060cc: 9d e3 bf a0 save %sp, -96, %sp
Sem_Control *sem;
Thread_queue_Context queue_context;
ISR_Level level;
unsigned int count;
POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
400060d0: 80 a6 20 00 cmp %i0, 0
400060d4: 02 80 00 1a be 4000613c <sem_trywait+0x70>
<== NEVER TAKEN
400060d8: 03 17 4d 9f sethi %hi(0x5d367c00), %g1
400060dc: c4 06 00 00 ld [ %i0 ], %g2
400060e0: 82 10 63 e7 or %g1, 0x3e7, %g1
400060e4: 82 1e 00 01 xor %i0, %g1, %g1
400060e8: 80 a0 40 02 cmp %g1, %g2
400060ec: 12 80 00 14 bne 4000613c <sem_trywait+0x70>
<== NEVER TAKEN
400060f0: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400060f4: 91 d0 20 09 ta 9
<== NOT EXECUTED
sem = _Sem_Get( &_sem->_Semaphore );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
_Sem_Queue_acquire_critical( sem, &queue_context );
count = sem->count;
400060f8: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
if ( __predict_true( count > 0 ) ) {
400060fc: 80 a0 a0 00 cmp %g2, 0
40006100: 02 80 00 07 be 4000611c <sem_trywait+0x50>
40006104: 84 00 bf ff add %g2, -1, %g2
sem->count = count - 1;
40006108: c4 26 20 18 st %g2, [ %i0 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000610c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006110: 01 00 00 00 nop
_Sem_Queue_release( sem, level, &queue_context );
return 0;
40006114: 81 c7 e0 08 ret
40006118: 91 e8 20 00 restore %g0, 0, %o0
4000611c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006120: 01 00 00 00 nop
} else {
_Sem_Queue_release( sem, level, &queue_context );
rtems_set_errno_and_return_minus_one( EAGAIN );
40006124: 40 00 1f f3 call 4000e0f0 <__errno>
40006128: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
4000612c: 82 10 20 0b mov 0xb, %g1
40006130: c2 22 00 00 st %g1, [ %o0 ]
}
}
40006134: 81 c7 e0 08 ret
40006138: 81 e8 00 00 restore
POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
4000613c: 40 00 1f ed call 4000e0f0 <__errno>
<== NOT EXECUTED
40006140: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006144: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40006148: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000614c: 81 c7 e0 08 ret
<== NOT EXECUTED
40006150: 81 e8 00 00 restore
<== NOT EXECUTED
40006320 <sem_unlink>:
#endif
#include <rtems/posix/semaphoreimpl.h>
int sem_unlink( const char *name )
{
40006320: 9d e3 bf 98 save %sp, -104, %sp
_RTEMS_Lock_allocator();
40006324: 40 00 00 7a call 4000650c <_RTEMS_Lock_allocator>
40006328: 39 10 00 4c sethi %hi(0x40013000), %i4
return (POSIX_Semaphore_Control *) _Objects_Get_by_name(
4000632c: 96 07 bf fc add %fp, -4, %o3
40006330: 94 10 20 00 clr %o2
40006334: 92 10 00 18 mov %i0, %o1
40006338: 40 00 07 ca call 40008260 <_Objects_Get_by_name>
4000633c: 90 17 22 d0 or %i4, 0x2d0, %o0
Objects_Get_by_name_error error;
_Objects_Allocator_lock();
the_semaphore = _POSIX_Semaphore_Get_by_name( name, NULL, &error );
if ( the_semaphore == NULL ) {
40006340: ba 92 20 00 orcc %o0, 0, %i5
40006344: 02 80 00 0c be 40006374 <sem_unlink+0x54>
<== NEVER TAKEN
40006348: 92 10 00 1d mov %i5, %o1
_Objects_Namespace_remove(
4000634c: 40 00 07 bb call 40008238 <_Objects_Namespace_remove>
40006350: 90 17 22 d0 or %i4, 0x2d0, %o0
_Objects_Allocator_unlock();
rtems_set_errno_and_return_minus_one( _POSIX_Get_by_name_error( error ) );
}
_POSIX_Semaphore_Namespace_remove( the_semaphore );
the_semaphore->linked = false;
40006354: c0 2f 60 2c clrb [ %i5 + 0x2c ]
_POSIX_Semaphore_Delete( the_semaphore );
40006358: 90 10 00 1d mov %i5, %o0
4000635c: 40 00 1a 71 call 4000cd20 <_POSIX_Semaphore_Delete>
40006360: b0 10 20 00 clr %i0
_RTEMS_Unlock_allocator();
40006364: 40 00 00 6f call 40006520 <_RTEMS_Unlock_allocator>
40006368: 01 00 00 00 nop
_Objects_Allocator_unlock();
return 0;
}
4000636c: 81 c7 e0 08 ret
40006370: 81 e8 00 00 restore
40006374: 40 00 00 6b call 40006520 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40006378: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( _POSIX_Get_by_name_error( error ) );
4000637c: 40 00 20 0b call 4000e3a8 <__errno>
<== NOT EXECUTED
40006380: fa 07 bf fc ld [ %fp + -4 ], %i5
<== NOT EXECUTED
40006384: bb 2f 60 02 sll %i5, 2, %i5
<== NOT EXECUTED
40006388: 03 10 00 40 sethi %hi(0x40010000), %g1
<== NOT EXECUTED
4000638c: 82 10 63 00 or %g1, 0x300, %g1 ! 40010300 <_POSIX_Get_by_name_error_table>
<== NOT EXECUTED
40006390: c2 00 40 1d ld [ %g1 + %i5 ], %g1
<== NOT EXECUTED
40006394: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006398: 81 c7 e0 08 ret
<== NOT EXECUTED
4000639c: 81 e8 00 00 restore
<== NOT EXECUTED
40006154 <sem_wait>:
#endif
#include <rtems/posix/semaphoreimpl.h>
int sem_wait( sem_t *sem )
{
40006154: 9d e3 bf a0 save %sp, -96, %sp
POSIX_SEMAPHORE_VALIDATE_OBJECT( sem );
40006158: 80 a6 20 00 cmp %i0, 0
4000615c: 02 80 00 0c be 4000618c <sem_wait+0x38>
<== NEVER TAKEN
40006160: 03 17 4d 9f sethi %hi(0x5d367c00), %g1
40006164: c4 06 00 00 ld [ %i0 ], %g2
40006168: 82 10 63 e7 or %g1, 0x3e7, %g1
4000616c: 82 1e 00 01 xor %i0, %g1, %g1
40006170: 80 a0 40 02 cmp %g1, %g2
40006174: 12 80 00 06 bne 4000618c <sem_wait+0x38>
<== NEVER TAKEN
40006178: 90 06 20 04 add %i0, 4, %o0
_Semaphore_Wait( &sem->_Semaphore );
4000617c: 40 00 0b d3 call 400090c8 <_Semaphore_Wait>
40006180: b0 10 20 00 clr %i0
return 0;
}
40006184: 81 c7 e0 08 ret
40006188: 81 e8 00 00 restore
POSIX_SEMAPHORE_VALIDATE_OBJECT( sem );
4000618c: 40 00 1f d9 call 4000e0f0 <__errno>
<== NOT EXECUTED
40006190: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006194: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40006198: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000619c: 81 c7 e0 08 ret
<== NOT EXECUTED
400061a0: 81 e8 00 00 restore
<== NOT EXECUTED
4000f994 <sigemptyset>:
#include <rtems/seterr.h>
int sigemptyset(
sigset_t *set
)
{
4000f994: 9d e3 bf a0 save %sp, -96, %sp
if ( !set )
4000f998: 80 a6 20 00 cmp %i0, 0
4000f99c: 02 80 00 05 be 4000f9b0 <sigemptyset+0x1c>
<== NEVER TAKEN
4000f9a0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
*set = 0;
4000f9a4: c0 26 00 00 clr [ %i0 ]
return 0;
}
4000f9a8: 81 c7 e0 08 ret
4000f9ac: 91 e8 20 00 restore %g0, 0, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
4000f9b0: 40 00 00 90 call 4000fbf0 <__errno>
<== NOT EXECUTED
4000f9b4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000f9b8: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4000f9bc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000f9c0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f9c4: 81 e8 00 00 restore
<== NOT EXECUTED