RTEMS-5
Annotated Report
Fri Aug 10 16:40:19 2018
40011210 <_POSIX_Get_by_name_error_table>:
40011210: 00 00 00 16 00 00 00 5b 00 00 00 02 .......[....
40006394 <_POSIX_Keys_Key_value_allocate>:
uint32_t max = Configuration.maximum_key_value_pairs;
40006394: 03 10 00 3d sethi %hi(0x4000f400), %g1
40006398: c2 00 63 fc ld [ %g1 + 0x3fc ], %g1 ! 4000f7fc <Configuration+0x10>
_Objects_Maximum_per_allocation( max ) : 0;
4000639c: 80 a0 60 00 cmp %g1, 0
400063a0: 16 80 00 05 bge 400063b4 <_POSIX_Keys_Key_value_allocate+0x20>
<== ALWAYS TAKEN
400063a4: 94 10 20 00 clr %o2
400063a8: 15 00 00 3f sethi %hi(0xfc00), %o2
<== NOT EXECUTED
400063ac: 94 12 a3 ff or %o2, 0x3ff, %o2 ! ffff <_Configuration_Interrupt_stack_size+0xefff>
<== NOT EXECUTED
400063b0: 94 08 40 0a and %g1, %o2, %o2
<== NOT EXECUTED
return (POSIX_Keys_Key_value_pair *) _Freechain_Get(
400063b4: 13 10 00 31 sethi %hi(0x4000c400), %o1
400063b8: 11 10 00 4d sethi %hi(0x40013400), %o0
400063bc: 96 10 20 24 mov 0x24, %o3
400063c0: 92 12 61 58 or %o1, 0x158, %o1
400063c4: 90 12 23 14 or %o0, 0x314, %o0
400063c8: 82 13 c0 00 mov %o7, %g1
400063cc: 40 00 01 c1 call 40006ad0 <_Freechain_Get>
400063d0: 9e 10 40 00 mov %g1, %o7
40006390 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
const struct timespec *abstime,
Thread_queue_Enqueue_callout enqueue_callout
)
{
40006390: 9d e3 bf 70 save %sp, -144, %sp
<== NOT EXECUTED
return (POSIX_Message_queue_Control *) _Objects_Get(
40006394: 15 10 00 51 sethi %hi(0x40014400), %o2
<== NOT EXECUTED
40006398: 92 07 bf dc add %fp, -36, %o1
<== NOT EXECUTED
4000639c: 94 12 a1 08 or %o2, 0x108, %o2
<== NOT EXECUTED
400063a0: 40 00 0d 48 call 400098c0 <_Objects_Get>
<== NOT EXECUTED
400063a4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
Thread_Control *executing;
Status_Control status;
the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
if ( the_mq == NULL ) {
400063a8: 80 a2 20 00 cmp %o0, 0
400063ac: 02 80 00 2c be 4000645c <_POSIX_Message_queue_Receive_support+0xcc>
<== NEVER TAKEN
400063b0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EBADF );
}
if ( ( the_mq->oflag & O_ACCMODE ) == O_WRONLY ) {
400063b4: d8 02 20 68 ld [ %o0 + 0x68 ], %o4
400063b8: 82 0b 20 03 and %o4, 3, %g1
400063bc: 80 a0 60 01 cmp %g1, 1
400063c0: 02 80 00 24 be 40006450 <_POSIX_Message_queue_Receive_support+0xc0>
<== NEVER TAKEN
400063c4: 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 ) {
400063c8: c2 02 20 28 ld [ %o0 + 0x28 ], %g1
400063cc: 80 a0 40 1a cmp %g1, %i2
400063d0: 18 80 00 29 bgu 40006474 <_POSIX_Message_queue_Receive_support+0xe4>
<== NEVER TAKEN
400063d4: 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;
400063d8: 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;
400063dc: c2 27 bf d8 st %g1, [ %fp + -40 ]
queue_context->Timeout.arg = arg;
400063e0: 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 ) {
400063e4: c2 02 20 50 ld [ %o0 + 0x50 ], %g1
400063e8: 80 a0 60 00 cmp %g1, 0
400063ec: 02 80 00 19 be 40006450 <_POSIX_Message_queue_Receive_support+0xc0>
<== NEVER TAKEN
400063f0: 84 02 20 10 add %o0, 0x10, %g2
}
/*
* Now perform the actual message receive
*/
executing = _Thread_Executing;
400063f4: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
status = _CORE_message_queue_Seize(
400063f8: 99 33 20 0e srl %o4, 0xe, %o4
400063fc: 9a 07 bf dc add %fp, -36, %o5
40006400: 98 1b 20 01 xor %o4, 1, %o4
40006404: 96 07 bf d8 add %fp, -40, %o3
40006408: 98 0b 20 01 and %o4, 1, %o4
4000640c: 94 10 00 19 mov %i1, %o2
40006410: 92 10 00 1d mov %i5, %o1
40006414: 40 00 05 38 call 400078f4 <_CORE_message_queue_Seize>
40006418: 90 10 00 02 mov %g2, %o0
&length_out,
( the_mq->oflag & O_NONBLOCK ) == 0,
&queue_context
);
if ( status != STATUS_SUCCESSFUL ) {
4000641c: 80 92 00 09 orcc %o0, %o1, %g0
40006420: 12 80 00 1e bne 40006498 <_POSIX_Message_queue_Receive_support+0x108>
<== NEVER TAKEN
40006424: 80 a6 e0 00 cmp %i3, 0
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
}
if ( msg_prio != NULL ) {
40006428: 22 80 00 08 be,a 40006448 <_POSIX_Message_queue_Receive_support+0xb8>
<== NEVER TAKEN
4000642c: f0 07 bf d8 ld [ %fp + -40 ], %i0
<== NOT EXECUTED
return (unsigned int) ((priority >= 0) ? priority : -priority);
40006430: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
40006434: 85 38 60 1f sra %g1, 0x1f, %g2
40006438: 82 18 80 01 xor %g2, %g1, %g1
4000643c: 82 20 40 02 sub %g1, %g2, %g1
*msg_prio = _POSIX_Message_queue_Priority_from_core(
40006440: c2 26 c0 00 st %g1, [ %i3 ]
executing->Wait.count
);
}
return length_out;
40006444: f0 07 bf d8 ld [ %fp + -40 ], %i0
}
40006448: 81 c7 e0 08 ret
4000644c: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006450: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006454: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006458: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
4000645c: 40 00 24 3f call 4000f558 <__errno>
<== NOT EXECUTED
40006460: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40006464: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40006468: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000646c: 81 c7 e0 08 ret
<== NOT EXECUTED
40006470: 81 e8 00 00 restore
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006474: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006478: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000647c: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EMSGSIZE );
40006480: 40 00 24 36 call 4000f558 <__errno>
<== NOT EXECUTED
40006484: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40006488: 82 10 20 7a mov 0x7a, %g1
<== NOT EXECUTED
4000648c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006490: 81 c7 e0 08 ret
<== NOT EXECUTED
40006494: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
40006498: 40 00 24 30 call 4000f558 <__errno>
<== NOT EXECUTED
4000649c: 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 );
400064a0: d2 07 bf d4 ld [ %fp + -44 ], %o1
<== NOT EXECUTED
400064a4: 93 3a 60 08 sra %o1, 8, %o1
<== NOT EXECUTED
400064a8: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
400064ac: 81 c7 e0 08 ret
<== NOT EXECUTED
400064b0: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
400064cc <_POSIX_Message_queue_Send_support>:
size_t msg_len,
unsigned int msg_prio,
const struct timespec *abstime,
Thread_queue_Enqueue_callout enqueue_callout
)
{
400064cc: 9d e3 bf 68 save %sp, -152, %sp
<== NOT EXECUTED
/*
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX ) {
400064d0: 80 a6 e0 20 cmp %i3, 0x20
<== NOT EXECUTED
400064d4: 18 80 00 34 bgu 400065a4 <_POSIX_Message_queue_Send_support+0xd8>
<== NOT EXECUTED
400064d8: 92 07 bf dc add %fp, -36, %o1
return (POSIX_Message_queue_Control *) _Objects_Get(
400064dc: 15 10 00 51 sethi %hi(0x40014400), %o2
400064e0: 90 10 00 18 mov %i0, %o0
400064e4: 40 00 0c f7 call 400098c0 <_Objects_Get>
400064e8: 94 12 a1 08 or %o2, 0x108, %o2
rtems_set_errno_and_return_minus_one( EINVAL );
}
the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
if ( the_mq == NULL ) {
400064ec: 80 a2 20 00 cmp %o0, 0
400064f0: 02 80 00 27 be 4000658c <_POSIX_Message_queue_Send_support+0xc0>
<== NEVER TAKEN
400064f4: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EBADF );
}
if ( ( the_mq->oflag & O_ACCMODE ) == O_RDONLY ) {
400064f8: da 02 20 68 ld [ %o0 + 0x68 ], %o5
400064fc: 80 8b 60 03 btst 3, %o5
40006500: 02 80 00 20 be 40006580 <_POSIX_Message_queue_Send_support+0xb4>
<== NEVER TAKEN
40006504: 01 00 00 00 nop
queue_context->enqueue_callout = enqueue_callout;
40006508: fa 27 bf e4 st %i5, [ %fp + -28 ]
queue_context->Timeout.arg = arg;
4000650c: 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 ) {
40006510: c2 02 20 50 ld [ %o0 + 0x50 ], %g1
40006514: 80 a0 60 00 cmp %g1, 0
40006518: 02 80 00 1a be 40006580 <_POSIX_Message_queue_Send_support+0xb4>
<== NEVER TAKEN
4000651c: 84 02 20 10 add %o0, 0x10, %g2
/*
* Now perform the actual message receive
*/
executing = _Thread_Executing;
status = _CORE_message_queue_Submit(
40006520: 82 07 bf dc add %fp, -36, %g1
40006524: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40006528: 9b 33 60 0e srl %o5, 0xe, %o5
4000652c: d2 01 a0 20 ld [ %g6 + 0x20 ], %o1
40006530: 9a 1b 60 01 xor %o5, 1, %o5
40006534: 98 20 00 1b neg %i3, %o4
40006538: 9a 0b 60 01 and %o5, 1, %o5
4000653c: 96 10 00 1a mov %i2, %o3
40006540: 94 10 00 19 mov %i1, %o2
40006544: 90 10 00 02 mov %g2, %o0
40006548: 40 00 05 37 call 40007a24 <_CORE_message_queue_Submit>
4000654c: b0 10 20 00 clr %i0
RTEMS_INLINE_ROUTINE int _POSIX_Zero_or_minus_one_plus_errno(
Status_Control status
)
{
if ( status == STATUS_SUCCESSFUL ) {
40006550: 80 92 00 09 orcc %o0, %o1, %g0
<== NOT EXECUTED
40006554: 12 80 00 04 bne 40006564 <_POSIX_Message_queue_Send_support+0x98>
<== NOT EXECUTED
40006558: 01 00 00 00 nop
<== NOT EXECUTED
_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 );
}
4000655c: 81 c7 e0 08 ret
<== NOT EXECUTED
40006560: 81 e8 00 00 restore
<== NOT EXECUTED
return 0;
}
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
40006564: 40 00 23 fd call 4000f558 <__errno>
<== NOT EXECUTED
40006568: d2 27 bf d4 st %o1, [ %fp + -44 ]
<== NOT EXECUTED
return STATUS_GET_POSIX( status );
4000656c: d2 07 bf d4 ld [ %fp + -44 ], %o1
<== NOT EXECUTED
40006570: 93 3a 60 08 sra %o1, 8, %o1
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
40006574: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
40006578: 81 c7 e0 08 ret
<== NOT EXECUTED
4000657c: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006580: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006584: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006588: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
4000658c: 40 00 23 f3 call 4000f558 <__errno>
<== NOT EXECUTED
40006590: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40006594: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40006598: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000659c: 81 c7 e0 08 ret
<== NOT EXECUTED
400065a0: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
400065a4: 40 00 23 ed call 4000f558 <__errno>
<== NOT EXECUTED
400065a8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400065ac: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400065b0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400065b4: 81 c7 e0 08 ret
<== NOT EXECUTED
400065b8: 81 e8 00 00 restore
<== NOT EXECUTED
400083c0 <_POSIX_Mutex_Auto_initialization>:
#include <rtems/posix/posixapi.h>
#include <string.h>
bool _POSIX_Mutex_Auto_initialization( POSIX_Mutex_Control *the_mutex )
{
400083c0: 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;
400083c4: f2 06 20 04 ld [ %i0 + 4 ], %i1
<== NOT EXECUTED
zero |= (unsigned long) the_mutex->Priority_ceiling.priority;
400083c8: de 06 20 30 ld [ %i0 + 0x30 ], %o7
<== NOT EXECUTED
400083cc: da 06 20 34 ld [ %i0 + 0x34 ], %o5
<== NOT EXECUTED
zero |= (unsigned long) the_mutex->scheduler;
400083d0: c4 06 00 00 ld [ %i0 ], %g2
<== NOT EXECUTED
400083d4: d4 06 20 08 ld [ %i0 + 8 ], %o2
<== NOT EXECUTED
400083d8: d6 06 20 18 ld [ %i0 + 0x18 ], %o3
<== NOT EXECUTED
400083dc: f4 06 20 0c ld [ %i0 + 0xc ], %i2
<== NOT EXECUTED
400083e0: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
<== NOT EXECUTED
400083e4: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
<== NOT EXECUTED
400083e8: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
<== NOT EXECUTED
400083ec: c8 06 20 24 ld [ %i0 + 0x24 ], %g4
<== NOT EXECUTED
400083f0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
<== NOT EXECUTED
400083f4: d8 06 20 2c ld [ %i0 + 0x2c ], %o4
<== NOT EXECUTED
400083f8: c6 06 20 38 ld [ %i0 + 0x38 ], %g3
<== NOT EXECUTED
400083fc: 84 10 80 19 or %g2, %i1, %g2
<== NOT EXECUTED
40008400: 84 10 80 0a or %g2, %o2, %g2
<== NOT EXECUTED
40008404: 84 10 80 0b or %g2, %o3, %g2
<== NOT EXECUTED
40008408: 84 16 80 02 or %i2, %g2, %g2
<== NOT EXECUTED
4000840c: 84 16 c0 02 or %i3, %g2, %g2
<== NOT EXECUTED
40008410: 84 17 00 02 or %i4, %g2, %g2
<== NOT EXECUTED
40008414: 84 17 40 02 or %i5, %g2, %g2
<== NOT EXECUTED
40008418: 84 11 00 02 or %g4, %g2, %g2
<== NOT EXECUTED
4000841c: 82 10 40 02 or %g1, %g2, %g1
<== NOT EXECUTED
40008420: 82 10 40 0c or %g1, %o4, %g1
<== NOT EXECUTED
40008424: 82 10 40 0d or %g1, %o5, %g1
<== NOT EXECUTED
40008428: 82 10 c0 01 or %g3, %g1, %g1
<== NOT EXECUTED
if ( zero != 0 ) {
4000842c: 80 90 40 0f orcc %g1, %o7, %g0
<== NOT EXECUTED
40008430: 12 80 00 08 bne 40008450 <_POSIX_Mutex_Auto_initialization+0x90>
<== NOT EXECUTED
40008434: b2 10 20 00 clr %i1
<== NOT EXECUTED
return false;
}
flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
40008438: 03 25 87 04 sethi %hi(0x961c1000), %g1
<== NOT EXECUTED
4000843c: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 <RAM_END+0x55dc13b8>
<== NOT EXECUTED
40008440: 82 1e 00 01 xor %i0, %g1, %g1
<== NOT EXECUTED
flags &= ~POSIX_MUTEX_FLAGS_MASK;
40008444: 82 08 7f f8 and %g1, -8, %g1
<== NOT EXECUTED
the_mutex->flags = flags;
40008448: c2 26 00 00 st %g1, [ %i0 ]
<== NOT EXECUTED
return true;
4000844c: b2 10 20 01 mov 1, %i1
<== NOT EXECUTED
}
40008450: b0 0e 60 01 and %i1, 1, %i0
<== NOT EXECUTED
40008454: 81 c7 e0 08 ret
<== NOT EXECUTED
40008458: 81 e8 00 00 restore
<== NOT EXECUTED
40013a68 <_POSIX_Mutex_Default_attributes>:
40013a68: 00 00 00 01 00 00 00 00 7f ff ff ff 00 00 00 00 ................
40013a78: 00 00 00 03 00 00 00 00 ........
40008188 <_POSIX_Mutex_Lock_support>:
int _POSIX_Mutex_Lock_support(
pthread_mutex_t *mutex,
const struct timespec *abstime,
Thread_queue_Enqueue_callout enqueue_callout
)
{
40008188: 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 );
4000818c: 80 a6 20 00 cmp %i0, 0
40008190: 02 80 00 3f be 4000828c <_POSIX_Mutex_Lock_support+0x104>
<== NEVER TAKEN
40008194: 05 25 87 04 sethi %hi(0x961c1000), %g2
40008198: fa 06 00 00 ld [ %i0 ], %i5
4000819c: 82 1e 00 1d xor %i0, %i5, %g1
400081a0: 84 10 a3 b8 or %g2, 0x3b8, %g2
400081a4: 82 18 40 02 xor %g1, %g2, %g1
400081a8: 80 88 7f f8 btst -8, %g1
400081ac: 12 80 00 33 bne 40008278 <_POSIX_Mutex_Lock_support+0xf0>
<== NEVER TAKEN
400081b0: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400081b4: 91 d0 20 09 ta 9
<== NOT EXECUTED
)
{
#if defined( RTEMS_SMP )
context->Lock_context.isr_level = level;
#else
context->isr_level = level;
400081b8: 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 ) ) {
400081bc: 82 8f 60 03 andcc %i5, 3, %g1
queue_context->enqueue_callout = enqueue_callout;
400081c0: f4 27 bf e4 st %i2, [ %fp + -28 ]
queue_context->Timeout.arg = arg;
400081c4: f2 27 bf e8 st %i1, [ %fp + -24 ]
400081c8: 02 80 00 34 be 40008298 <_POSIX_Mutex_Lock_support+0x110>
<== NEVER TAKEN
400081cc: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
400081d0: 80 a0 60 02 cmp %g1, 2
400081d4: 12 80 00 10 bne 40008214 <_POSIX_Mutex_Lock_support+0x8c>
<== ALWAYS TAKEN
400081d8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
{
Thread_Control *owner;
owner = _POSIX_Mutex_Get_owner( the_mutex );
if ( owner == NULL ) {
400081dc: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400081e0: 02 80 00 43 be 400082ec <_POSIX_Mutex_Lock_support+0x164>
<== NOT EXECUTED
400081e4: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
executing,
queue_context
);
}
if ( owner == executing ) {
400081e8: 02 80 00 18 be 40008248 <_POSIX_Mutex_Lock_support+0xc0>
<== NOT EXECUTED
400081ec: 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(
400081f0: 98 07 bf dc add %fp, -36, %o4
<== NOT EXECUTED
400081f4: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
400081f8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400081fc: 13 10 00 4e sethi %hi(0x40013800), %o1
<== NOT EXECUTED
40008200: 7f ff ff ca call 40008128 <_POSIX_Mutex_Seize_slow>
<== NOT EXECUTED
40008204: 92 12 62 f8 or %o1, 0x2f8, %o1 ! 40013af8 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
40008208: 93 3a 60 08 sra %o1, 8, %o1
<== NOT EXECUTED
);
break;
}
return _POSIX_Get_error( status );
}
4000820c: 81 c7 e0 08 ret
<== NOT EXECUTED
40008210: 91 e8 00 09 restore %g0, %o1, %o0
<== NOT EXECUTED
if ( owner == NULL ) {
40008214: 80 a0 60 00 cmp %g1, 0
40008218: 02 80 00 2e be 400082d0 <_POSIX_Mutex_Lock_support+0x148>
4000821c: 80 a2 00 01 cmp %o0, %g1
if ( owner == executing ) {
40008220: 02 80 00 0a be 40008248 <_POSIX_Mutex_Lock_support+0xc0>
<== NEVER TAKEN
40008224: 94 10 00 08 mov %o0, %o2
return _POSIX_Mutex_Seize_slow(
40008228: 98 07 bf dc add %fp, -36, %o4
4000822c: 96 10 00 19 mov %i1, %o3
40008230: 90 10 00 18 mov %i0, %o0
40008234: 13 10 00 4e sethi %hi(0x40013800), %o1
40008238: 7f ff ff bc call 40008128 <_POSIX_Mutex_Seize_slow>
4000823c: 92 12 62 e4 or %o1, 0x2e4, %o1 ! 40013ae4 <_Thread_queue_Operations_priority_inherit>
return _POSIX_Get_error( status );
40008240: 10 80 00 0c b 40008270 <_POSIX_Mutex_Lock_support+0xe8>
40008244: 93 3a 60 08 sra %o1, 8, %o1
if ( _POSIX_Mutex_Is_recursive( flags ) ) {
40008248: 80 8f 60 04 btst 4, %i5
<== NOT EXECUTED
4000824c: 02 80 00 06 be 40008264 <_POSIX_Mutex_Lock_support+0xdc>
<== NOT EXECUTED
40008250: 92 10 20 2d mov 0x2d, %o1
<== NOT EXECUTED
++the_mutex->Recursive.nest_level;
40008254: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
40008258: 82 00 60 01 inc %g1
<== NOT EXECUTED
4000825c: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
<== NOT EXECUTED
40008260: 92 10 20 00 clr %o1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008264: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008268: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000826c: 01 00 00 00 nop
<== NOT EXECUTED
}
40008270: 81 c7 e0 08 ret
40008274: 91 e8 00 09 restore %g0, %o1, %o0
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40008278: 40 00 00 52 call 400083c0 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
4000827c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40008280: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40008284: 12 bf ff cc bne 400081b4 <_POSIX_Mutex_Lock_support+0x2c>
<== NOT EXECUTED
40008288: 01 00 00 00 nop
<== NOT EXECUTED
4000828c: 92 10 20 16 mov 0x16, %o1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
}
40008290: 81 c7 e0 08 ret
<== NOT EXECUTED
40008294: 91 e8 00 09 restore %g0, %o1, %o0
<== NOT EXECUTED
40008298: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
<== NOT EXECUTED
if ( owner == NULL ) {
4000829c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400082a0: 02 80 00 0c be 400082d0 <_POSIX_Mutex_Lock_support+0x148>
<== NOT EXECUTED
400082a4: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
if ( owner == executing ) {
400082a8: 02 bf ff e8 be 40008248 <_POSIX_Mutex_Lock_support+0xc0>
<== NOT EXECUTED
400082ac: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
return _POSIX_Mutex_Seize_slow(
400082b0: 98 07 bf dc add %fp, -36, %o4
<== NOT EXECUTED
400082b4: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
400082b8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400082bc: 13 10 00 4e sethi %hi(0x40013800), %o1
<== NOT EXECUTED
400082c0: 7f ff ff 9a call 40008128 <_POSIX_Mutex_Seize_slow>
<== NOT EXECUTED
400082c4: 92 12 63 0c or %o1, 0x30c, %o1 ! 40013b0c <_Thread_queue_Operations_FIFO>
<== NOT EXECUTED
400082c8: 10 bf ff ea b 40008270 <_POSIX_Mutex_Lock_support+0xe8>
<== NOT EXECUTED
400082cc: 93 3a 60 08 sra %o1, 8, %o1
<== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
400082d0: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400082d4: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400082d8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400082dc: 01 00 00 00 nop
400082e0: 92 10 20 00 clr %o1 ! 0 <PROM_START>
400082e4: 81 c7 e0 08 ret
400082e8: 91 e8 00 09 restore %g0, %o1, %o0
if (
400082ec: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
<== NOT EXECUTED
queue_context->Priority.update_count = 0;
400082f0: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
400082f4: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
<== NOT EXECUTED
400082f8: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
<== NOT EXECUTED
400082fc: 80 a0 c0 02 cmp %g3, %g2
<== NOT EXECUTED
40008300: 18 80 00 09 bgu 40008324 <_POSIX_Mutex_Lock_support+0x19c>
<== NOT EXECUTED
40008304: 01 00 00 00 nop
<== NOT EXECUTED
40008308: 32 80 00 0c bne,a 40008338 <_POSIX_Mutex_Lock_support+0x1b0>
<== NOT EXECUTED
4000830c: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
<== NOT EXECUTED
40008310: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
<== NOT EXECUTED
40008314: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
40008318: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4000831c: 28 80 00 07 bleu,a 40008338 <_POSIX_Mutex_Lock_support+0x1b0>
<== NOT EXECUTED
40008320: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008324: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008328: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000832c: 01 00 00 00 nop
<== NOT EXECUTED
40008330: 10 bf ff d8 b 40008290 <_POSIX_Mutex_Lock_support+0x108>
<== NOT EXECUTED
40008334: 92 10 20 16 mov 0x16, %o1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
_Thread_Priority_add(
40008338: 92 06 20 20 add %i0, 0x20, %o1
<== NOT EXECUTED
4000833c: 40 00 15 20 call 4000d7bc <_Thread_Priority_add>
<== NOT EXECUTED
40008340: 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;
40008344: 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;
40008348: 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 );
4000834c: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40008350: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008354: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008358: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000835c: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( queue_context );
40008360: 40 00 15 28 call 4000d800 <_Thread_Priority_update>
<== NOT EXECUTED
40008364: 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;
40008368: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000836c: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
40008370: 02 80 00 05 be 40008384 <_POSIX_Mutex_Lock_support+0x1fc>
<== NOT EXECUTED
40008374: 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;
40008378: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000837c: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
40008380: 30 bf ff bc b,a 40008270 <_POSIX_Mutex_Lock_support+0xe8>
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008384: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
40008388: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
<== NOT EXECUTED
4000838c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40008390: 32 80 00 07 bne,a 400083ac <_POSIX_Mutex_Lock_support+0x224>
<== NOT EXECUTED
40008394: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
40008398: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000839c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400083a0: 01 00 00 00 nop
<== NOT EXECUTED
400083a4: 10 bf ff b3 b 40008270 <_POSIX_Mutex_Lock_support+0xe8>
<== NOT EXECUTED
400083a8: 92 10 20 00 clr %o1 ! 0 <PROM_START>
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
400083ac: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
400083b0: 40 00 15 9b call 4000da1c <_Thread_Do_dispatch>
<== NOT EXECUTED
400083b4: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
400083b8: 10 bf ff f9 b 4000839c <_POSIX_Mutex_Lock_support+0x214>
<== NOT EXECUTED
400083bc: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
40008128 <_POSIX_Mutex_Seize_slow>:
const Thread_queue_Operations *operations,
Thread_Control *executing,
const struct timespec *abstime,
Thread_queue_Context *queue_context
)
{
40008128: 9d e3 bf a0 save %sp, -96, %sp
if ( (uintptr_t) abstime != POSIX_MUTEX_ABSTIME_TRY_LOCK ) {
4000812c: 80 a6 e0 01 cmp %i3, 1
40008130: 02 80 00 0f be 4000816c <_POSIX_Mutex_Seize_slow+0x44>
<== NEVER TAKEN
40008134: 82 10 20 01 mov 1, %g1
queue_context->thread_state = thread_state;
40008138: c2 27 20 04 st %g1, [ %i4 + 4 ]
queue_context->deadlock_callout = deadlock_callout;
4000813c: 03 10 00 38 sethi %hi(0x4000e000), %g1
40008140: 82 10 61 4c or %g1, 0x14c, %g1 ! 4000e14c <_Thread_queue_Deadlock_status>
40008144: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
);
_Thread_queue_Context_set_deadlock_callout(
queue_context,
_Thread_queue_Deadlock_status
);
_Thread_queue_Enqueue(
40008148: 92 10 00 19 mov %i1, %o1
4000814c: 90 06 20 0c add %i0, 0xc, %o0
40008150: 96 10 00 1c mov %i4, %o3
40008154: 94 10 00 1a mov %i2, %o2
40008158: 40 00 18 05 call 4000e16c <_Thread_queue_Enqueue>
4000815c: 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;
40008160: 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;
}
}
40008164: 81 c7 e0 08 ret
40008168: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000816c: c2 07 00 00 ld [ %i4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008170: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008174: 01 00 00 00 nop
<== NOT EXECUTED
40008178: 33 00 00 04 sethi %hi(0x1000), %i1
<== NOT EXECUTED
4000817c: b2 16 60 0d or %i1, 0xd, %i1 ! 100d <_Configuration_Interrupt_stack_size+0xd>
<== NOT EXECUTED
40008180: 81 c7 e0 08 ret
<== NOT EXECUTED
40008184: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
400086a4 <_POSIX_Priority_To_core>:
Priority_Control _POSIX_Priority_To_core(
const Scheduler_Control *scheduler,
int posix_priority,
bool *valid
)
{
400086a4: 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;
400086a8: f8 1e 20 40 ldd [ %i0 + 0x40 ], %i4
core_posix_priority = (Priority_Control) posix_priority;
400086ac: 83 3e 60 1f sra %i1, 0x1f, %g1
400086b0: 86 10 00 19 mov %i1, %g3
400086b4: 84 10 00 01 mov %g1, %g2
*valid = ( posix_priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY
&& core_posix_priority < scheduler->maximum_priority );
400086b8: 80 a7 00 01 cmp %i4, %g1
400086bc: 18 80 00 05 bgu 400086d0 <_POSIX_Priority_To_core+0x2c>
<== NEVER TAKEN
400086c0: 88 10 20 01 mov 1, %g4
400086c4: 02 80 00 11 be 40008708 <_POSIX_Priority_To_core+0x64>
<== ALWAYS TAKEN
400086c8: 80 a7 40 19 cmp %i5, %i1
400086cc: 88 10 20 00 clr %g4
<== NOT EXECUTED
400086d0: 82 20 40 19 sub %g1, %i1, %g1
<== NOT EXECUTED
400086d4: 83 30 60 1f srl %g1, 0x1f, %g1
400086d8: 82 08 40 04 and %g1, %g4, %g1
*valid = ( posix_priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY
400086dc: c2 2e 80 00 stb %g1, [ %i2 ]
core_priority = scheduler->maximum_priority - core_posix_priority;
400086e0: b6 a7 40 03 subcc %i5, %g3, %i3
RTEMS_INLINE_ROUTINE Priority_Control _Scheduler_Map_priority(
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
return ( *scheduler->Operations.map_priority )( scheduler, priority );
400086e4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
400086e8: b4 67 00 02 subx %i4, %g2, %i2
400086ec: 94 10 00 1b mov %i3, %o2
400086f0: 92 10 00 1a mov %i2, %o1
400086f4: 9f c0 40 00 call %g1
400086f8: 90 10 00 18 mov %i0, %o0
return _Scheduler_Map_priority( scheduler, core_priority );
}
400086fc: b0 10 00 08 mov %o0, %i0
40008700: 81 c7 e0 08 ret
40008704: 93 e8 00 09 restore %g0, %o1, %o1
&& core_posix_priority < scheduler->maximum_priority );
40008708: 38 bf ff f3 bgu,a 400086d4 <_POSIX_Priority_To_core+0x30>
<== ALWAYS TAKEN
4000870c: 82 20 40 19 sub %g1, %i1, %g1
40008710: 10 bf ff f0 b 400086d0 <_POSIX_Priority_To_core+0x2c>
<== NOT EXECUTED
40008714: 88 10 20 00 clr %g4
<== NOT EXECUTED
40010dd4 <_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
)
{
40010dd4: 9d e3 bf a0 save %sp, -96, %sp
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
40010dd8: c0 26 80 00 clr [ %i2 ]
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
40010ddc: 80 a6 20 00 cmp %i0, 0
40010de0: 02 80 00 29 be 40010e84 <_POSIX_Thread_Translate_sched_param+0xb0>
<== NEVER TAKEN
40010de4: c0 26 c0 00 clr [ %i3 ]
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
40010de8: 80 a6 20 01 cmp %i0, 1
40010dec: 02 80 00 2a be 40010e94 <_POSIX_Thread_Translate_sched_param+0xc0>
<== ALWAYS TAKEN
40010df0: 80 a6 20 02 cmp %i0, 2
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
40010df4: 02 80 00 2d be 40010ea8 <_POSIX_Thread_Translate_sched_param+0xd4>
<== NOT EXECUTED
40010df8: 80 a6 20 04 cmp %i0, 4
<== NOT EXECUTED
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
40010dfc: 12 80 00 29 bne 40010ea0 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
40010e00: 01 00 00 00 nop
<== NOT EXECUTED
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
40010e04: c4 06 60 08 ld [ %i1 + 8 ], %g2
<== NOT EXECUTED
40010e08: c2 06 60 0c ld [ %i1 + 0xc ], %g1
<== NOT EXECUTED
40010e0c: 80 90 80 01 orcc %g2, %g1, %g0
<== NOT EXECUTED
40010e10: 32 80 00 07 bne,a 40010e2c <_POSIX_Thread_Translate_sched_param+0x58>
<== NOT EXECUTED
40010e14: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
<== NOT EXECUTED
40010e18: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
<== NOT EXECUTED
40010e1c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40010e20: 02 80 00 20 be 40010ea0 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
40010e24: 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) &&
40010e28: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
<== NOT EXECUTED
40010e2c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
<== NOT EXECUTED
40010e30: 80 90 80 01 orcc %g2, %g1, %g0
<== NOT EXECUTED
40010e34: 12 80 00 06 bne 40010e4c <_POSIX_Thread_Translate_sched_param+0x78>
<== NOT EXECUTED
40010e38: 01 00 00 00 nop
<== NOT EXECUTED
40010e3c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
<== NOT EXECUTED
40010e40: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40010e44: 02 80 00 17 be 40010ea0 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
40010e48: 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 ) <
40010e4c: 7f ff ff 1c call 40010abc <_Timespec_To_ticks>
<== NOT EXECUTED
40010e50: 90 06 60 08 add %i1, 8, %o0
<== NOT EXECUTED
40010e54: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
40010e58: 7f ff ff 19 call 40010abc <_Timespec_To_ticks>
<== NOT EXECUTED
40010e5c: 90 06 60 18 add %i1, 0x18, %o0
<== NOT EXECUTED
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
40010e60: 80 a7 40 08 cmp %i5, %o0
<== NOT EXECUTED
40010e64: 0a 80 00 0f bcs 40010ea0 <_POSIX_Thread_Translate_sched_param+0xcc>
<== NOT EXECUTED
40010e68: 82 10 20 03 mov 3, %g1
<== NOT EXECUTED
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
40010e6c: c2 26 80 00 st %g1, [ %i2 ]
<== NOT EXECUTED
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
40010e70: 03 10 00 3e sethi %hi(0x4000f800), %g1
<== NOT EXECUTED
40010e74: 82 10 63 70 or %g1, 0x370, %g1 ! 4000fb70 <_POSIX_Threads_Sporadic_budget_callout>
<== NOT EXECUTED
40010e78: c2 26 c0 00 st %g1, [ %i3 ]
<== NOT EXECUTED
return 0;
}
return EINVAL;
}
40010e7c: 81 c7 e0 08 ret
<== NOT EXECUTED
40010e80: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
40010e84: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
40010e88: c2 26 80 00 st %g1, [ %i2 ]
<== NOT EXECUTED
return 0;
40010e8c: 81 c7 e0 08 ret
<== NOT EXECUTED
40010e90: 81 e8 00 00 restore
<== NOT EXECUTED
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
40010e94: c0 26 80 00 clr [ %i2 ]
return 0;
40010e98: 81 c7 e0 08 ret
40010e9c: 91 e8 20 00 restore %g0, 0, %o0
return EINVAL;
40010ea0: 81 c7 e0 08 ret
<== NOT EXECUTED
40010ea4: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
40010ea8: f0 26 80 00 st %i0, [ %i2 ]
<== NOT EXECUTED
return 0;
40010eac: 81 c7 e0 08 ret
<== NOT EXECUTED
40010eb0: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
40010dac <_POSIX_Thread_Translate_to_sched_policy>:
#include <rtems/posix/pthreadimpl.h>
int _POSIX_Thread_Translate_to_sched_policy(
Thread_CPU_budget_algorithms budget_algorithm
)
{
40010dac: 82 02 3f ff add %o0, -1, %g1
40010db0: 80 a0 60 02 cmp %g1, 2
40010db4: 18 80 00 06 bgu 40010dcc <_POSIX_Thread_Translate_to_sched_policy+0x20>
<== ALWAYS TAKEN
40010db8: 90 10 20 01 mov 1, %o0
40010dbc: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
40010dc0: 05 10 00 4b sethi %hi(0x40012c00), %g2
<== NOT EXECUTED
40010dc4: 84 10 a2 70 or %g2, 0x270, %g2 ! 40012e70 <CSWTCH.1>
<== NOT EXECUTED
40010dc8: 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;
}
}
40010dcc: 81 c3 e0 08 retl
40010dd0: 01 00 00 00 nop
40012e80 <_POSIX_Threads_Default_attributes>:
40012e80: 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 ................
40012e90: 00 00 00 01 00 00 00 01 00 00 00 02 00 00 00 00 ................
...
40012ecc: 00 00 00 01 00 00 00 01 00 00 00 04 40 01 2e dc ............@...
40012edc: ff ff ff ff ....
40007bb4 <_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)
{
40007bb4: 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;
40007bb8: 03 10 00 52 sethi %hi(0x40014800), %g1
40007bbc: 82 10 61 84 or %g1, 0x184, %g1 ! 40014984 <Configuration_POSIX_API>
40007bc0: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
maximum = Configuration_POSIX_API.number_of_initialization_threads;
if ( !user_threads )
40007bc4: 80 a7 60 00 cmp %i5, 0
40007bc8: 02 80 00 1f be 40007c44 <_POSIX_Threads_Initialize_user_threads_body+0x90>
<== NEVER TAKEN
40007bcc: 01 00 00 00 nop
maximum = Configuration_POSIX_API.number_of_initialization_threads;
40007bd0: 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++ ) {
40007bd4: 80 a6 a0 00 cmp %i2, 0
40007bd8: 02 80 00 1b be 40007c44 <_POSIX_Threads_Initialize_user_threads_body+0x90>
<== NEVER TAKEN
40007bdc: b8 10 20 00 clr %i4
);
if ( eno != 0 ) {
_Internal_error( INTERNAL_ERROR_POSIX_INIT_THREAD_CREATE_FAILED );
}
if ( _Thread_Global_constructor == 0 ) {
40007be0: 37 10 00 5b sethi %hi(0x40016c00), %i3
eno = pthread_attr_init( &attr );
40007be4: 40 00 1b 93 call 4000ea30 <pthread_attr_init>
40007be8: 90 07 bf a0 add %fp, -96, %o0
eno = pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
40007bec: 92 10 20 02 mov 2, %o1
40007bf0: 40 00 1b 9f call 4000ea6c <pthread_attr_setinheritsched>
40007bf4: 90 07 bf a0 add %fp, -96, %o0
eno = pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
40007bf8: d2 07 60 04 ld [ %i5 + 4 ], %o1
40007bfc: 40 00 1b ab call 4000eaa8 <pthread_attr_setstacksize>
40007c00: 90 07 bf a0 add %fp, -96, %o0
eno = pthread_create(
40007c04: d4 07 40 00 ld [ %i5 ], %o2
40007c08: 96 10 20 00 clr %o3
40007c0c: 92 07 bf a0 add %fp, -96, %o1
40007c10: 40 00 1b b2 call 4000ead8 <pthread_create>
40007c14: 90 07 bf 9c add %fp, -100, %o0
if ( eno != 0 ) {
40007c18: 80 a2 20 00 cmp %o0, 0
40007c1c: 12 80 00 0c bne 40007c4c <_POSIX_Threads_Initialize_user_threads_body+0x98>
<== NEVER TAKEN
40007c20: c2 06 e0 50 ld [ %i3 + 0x50 ], %g1
if ( _Thread_Global_constructor == 0 ) {
40007c24: 80 a0 60 00 cmp %g1, 0
40007c28: 12 80 00 04 bne 40007c38 <_POSIX_Threads_Initialize_user_threads_body+0x84>
<== ALWAYS TAKEN
40007c2c: b8 07 20 01 inc %i4
_Thread_Global_constructor = thread_id;
40007c30: c2 07 bf 9c ld [ %fp + -100 ], %g1
<== NOT EXECUTED
40007c34: c2 26 e0 50 st %g1, [ %i3 + 0x50 ]
<== NOT EXECUTED
for ( index=0 ; index < maximum ; index++ ) {
40007c38: 80 a6 80 1c cmp %i2, %i4
40007c3c: 12 bf ff ea bne 40007be4 <_POSIX_Threads_Initialize_user_threads_body+0x30>
<== NEVER TAKEN
40007c40: ba 07 60 08 add %i5, 8, %i5
}
}
}
40007c44: 81 c7 e0 08 ret
40007c48: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_POSIX_INIT_THREAD_CREATE_FAILED );
40007c4c: 40 00 04 02 call 40008c54 <_Internal_error>
<== NOT EXECUTED
40007c50: 90 10 20 21 mov 0x21, %o0
<== NOT EXECUTED
40007c54: 01 00 00 00 nop
<== NOT EXECUTED
4000fb70 <_POSIX_Threads_Sporadic_budget_callout>:
{
4000fb70: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
4000fb74: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000fb78: d2 06 21 5c ld [ %i0 + 0x15c ], %o1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000fb7c: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000fb80: c2 27 bf dc st %g1, [ %fp + -36 ]
<== NOT EXECUTED
the_thread->cpu_time_budget = UINT32_MAX;
4000fb84: 82 10 3f ff mov -1, %g1
<== NOT EXECUTED
4000fb88: c2 26 20 8c st %g1, [ %i0 + 0x8c ]
<== NOT EXECUTED
if ( !_Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
4000fb8c: c2 02 60 34 ld [ %o1 + 0x34 ], %g1
<== NOT EXECUTED
4000fb90: 80 a0 7f ff cmp %g1, -1
<== NOT EXECUTED
4000fb94: 02 80 00 09 be 4000fbb8 <_POSIX_Threads_Sporadic_budget_callout+0x48>
<== NOT EXECUTED
4000fb98: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000fb9c: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000fba0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000fba4: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( &queue_context );
4000fba8: 40 00 02 fe call 400107a0 <_Thread_Priority_update>
<== NOT EXECUTED
4000fbac: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
}
4000fbb0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fbb4: 81 e8 00 00 restore
<== NOT EXECUTED
_Thread_Priority_add(
4000fbb8: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
4000fbbc: 40 00 02 e8 call 4001075c <_Thread_Priority_add>
<== NOT EXECUTED
4000fbc0: 92 02 60 28 add %o1, 0x28, %o1
<== NOT EXECUTED
_Thread_Priority_remove(
4000fbc4: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
4000fbc8: 92 06 20 20 add %i0, 0x20, %o1
<== NOT EXECUTED
4000fbcc: 40 00 02 e9 call 40010770 <_Thread_Priority_remove>
<== NOT EXECUTED
4000fbd0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000fbd4: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000fbd8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000fbdc: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( &queue_context );
4000fbe0: 40 00 02 f0 call 400107a0 <_Thread_Priority_update>
<== NOT EXECUTED
4000fbe4: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
}
4000fbe8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fbec: 81 e8 00 00 restore
<== NOT EXECUTED
4000fabc <_POSIX_Threads_Sporadic_timer>:
{
4000fabc: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
queue_context->Priority.update_count = 0;
4000fac0: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
api = RTEMS_CONTAINER_OF( watchdog, POSIX_API_Control, Sporadic.Timer );
4000fac4: ba 06 3f f8 add %i0, -8, %i5
<== NOT EXECUTED
the_thread = api->Sporadic.thread;
4000fac8: f8 06 3f f8 ld [ %i0 + -8 ], %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000facc: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
4000fad0: c2 27 bf dc st %g1, [ %fp + -36 ]
<== NOT EXECUTED
if ( _Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
4000fad4: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
<== NOT EXECUTED
4000fad8: 80 a0 7f ff cmp %g1, -1
<== NOT EXECUTED
4000fadc: 02 80 00 0b be 4000fb08 <_POSIX_Threads_Sporadic_timer+0x4c>
<== NOT EXECUTED
4000fae0: 92 07 20 20 add %i4, 0x20, %o1
<== NOT EXECUTED
_Thread_Priority_add(
4000fae4: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000fae8: 40 00 03 1d call 4001075c <_Thread_Priority_add>
<== NOT EXECUTED
4000faec: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
_Thread_Priority_remove(
4000faf0: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
4000faf4: 92 06 20 20 add %i0, 0x20, %o1
<== NOT EXECUTED
4000faf8: 40 00 03 1e call 40010770 <_Thread_Priority_remove>
<== NOT EXECUTED
4000fafc: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000fb00: 82 10 3f ff mov -1, %g1
<== NOT EXECUTED
4000fb04: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
<== NOT EXECUTED
_Watchdog_Per_CPU_remove_ticks( &api->Sporadic.Timer );
4000fb08: b6 07 60 08 add %i5, 8, %i3
<== NOT EXECUTED
4000fb0c: 11 10 00 57 sethi %hi(0x40015c00), %o0
<== NOT EXECUTED
4000fb10: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4000fb14: 7f ff f7 06 call 4000d72c <_Watchdog_Remove>
<== NOT EXECUTED
4000fb18: 90 12 21 b8 or %o0, 0x1b8, %o0
<== NOT EXECUTED
_Timespec_To_ticks( &api->Sporadic.sched_ss_init_budget );
4000fb1c: 40 00 03 e8 call 40010abc <_Timespec_To_ticks>
<== NOT EXECUTED
4000fb20: 90 07 60 50 add %i5, 0x50, %o0
<== NOT EXECUTED
the_thread->cpu_time_budget =
4000fb24: d0 27 20 8c st %o0, [ %i4 + 0x8c ]
<== NOT EXECUTED
_Watchdog_Per_CPU_insert_ticks(
4000fb28: b8 10 00 06 mov %g6, %i4
<== NOT EXECUTED
4000fb2c: 40 00 03 e4 call 40010abc <_Timespec_To_ticks>
<== NOT EXECUTED
4000fb30: 90 07 60 40 add %i5, 0x40, %o0
<== NOT EXECUTED
expire = ticks + cpu->Watchdog.ticks;
4000fb34: d4 1f 20 30 ldd [ %i4 + 0x30 ], %o2
<== NOT EXECUTED
_Watchdog_Insert(header, the_watchdog, expire);
4000fb38: 86 82 c0 08 addcc %o3, %o0, %g3
<== NOT EXECUTED
4000fb3c: 84 42 a0 00 addx %o2, 0, %g2
<== NOT EXECUTED
4000fb40: 96 10 00 03 mov %g3, %o3
<== NOT EXECUTED
4000fb44: 94 10 00 02 mov %g2, %o2
<== NOT EXECUTED
4000fb48: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4000fb4c: 7f ff f6 d0 call 4000d68c <_Watchdog_Insert>
<== NOT EXECUTED
4000fb50: 90 07 20 38 add %i4, 0x38, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000fb54: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000fb58: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000fb5c: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( &queue_context );
4000fb60: 40 00 03 10 call 400107a0 <_Thread_Priority_update>
<== NOT EXECUTED
4000fb64: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
}
4000fb68: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fb6c: 81 e8 00 00 restore
<== NOT EXECUTED
40018bc0 <_POSIX_signals_Abnormal_termination_handler>:
sigset_t _POSIX_signals_Pending;
void _POSIX_signals_Abnormal_termination_handler(
int signo RTEMS_UNUSED )
{
40018bc0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
exit( 1 );
40018bc4: 40 00 02 11 call 40019408 <exit>
<== NOT EXECUTED
40018bc8: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
40018bcc: 01 00 00 00 nop
<== NOT EXECUTED
400193a0 <_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 ) {
400193a0: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
400193a4: 05 10 00 79 sethi %hi(0x4001e400), %g2
<== NOT EXECUTED
400193a8: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
400193ac: 84 10 a0 50 or %g2, 0x50, %g2
<== NOT EXECUTED
400193b0: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
400193b4: c4 00 80 01 ld [ %g2 + %g1 ], %g2
<== NOT EXECUTED
400193b8: 90 02 3f ff add %o0, -1, %o0
<== NOT EXECUTED
400193bc: 80 a0 a0 02 cmp %g2, 2
<== NOT EXECUTED
400193c0: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
400193c4: 02 80 00 07 be 400193e0 <_POSIX_signals_Clear_process_signals+0x40>
<== NOT EXECUTED
400193c8: 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;
400193cc: 03 10 00 79 sethi %hi(0x4001e400), %g1
<== NOT EXECUTED
400193d0: c4 00 61 dc ld [ %g1 + 0x1dc ], %g2 ! 4001e5dc <_POSIX_signals_Pending>
<== NOT EXECUTED
400193d4: 90 28 80 08 andn %g2, %o0, %o0
<== NOT EXECUTED
}
}
400193d8: 81 c3 e0 08 retl
<== NOT EXECUTED
400193dc: d0 20 61 dc st %o0, [ %g1 + 0x1dc ]
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
400193e0: 05 10 00 79 sethi %hi(0x4001e400), %g2
<== NOT EXECUTED
400193e4: 84 10 a1 e0 or %g2, 0x1e0, %g2 ! 4001e5e0 <_POSIX_signals_Siginfo>
<== NOT EXECUTED
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
400193e8: c6 00 80 01 ld [ %g2 + %g1 ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
400193ec: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
400193f0: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
400193f4: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
400193f8: 02 bf ff f6 be 400193d0 <_POSIX_signals_Clear_process_signals+0x30>
<== NOT EXECUTED
400193fc: 03 10 00 79 sethi %hi(0x4001e400), %g1
<== NOT EXECUTED
}
40019400: 81 c3 e0 08 retl
<== NOT EXECUTED
40019404: 01 00 00 00 nop
<== NOT EXECUTED
4001924c <_POSIX_signals_Clear_signals>:
siginfo_t *info,
bool is_global,
bool check_blocked,
bool do_signals_acquire_release
)
{
4001924c: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
40019250: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
40019254: 86 06 7f ff add %i1, -1, %g3
<== NOT EXECUTED
*/
if ( check_blocked )
signals_unblocked = api->signals_unblocked;
else
signals_unblocked = SIGNAL_ALL_MASK;
40019258: 88 10 3f ff mov -1, %g4
<== NOT EXECUTED
if ( check_blocked )
4001925c: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
40019260: 02 80 00 03 be 4001926c <_POSIX_signals_Clear_signals+0x20>
<== NOT EXECUTED
40019264: 85 28 80 03 sll %g2, %g3, %g2
<== NOT EXECUTED
signals_unblocked = api->signals_unblocked;
40019268: 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 ) {
4001926c: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
40019270: 02 80 00 04 be 40019280 <_POSIX_signals_Clear_signals+0x34>
<== NOT EXECUTED
40019274: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40019278: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Thread_queue_Context_initialize( &queue_context );
_POSIX_signals_Acquire( &queue_context );
}
if ( is_global ) {
4001927c: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
40019280: 22 80 00 10 be,a 400192c0 <_POSIX_signals_Clear_signals+0x74>
<== NOT EXECUTED
40019284: f8 06 20 6c ld [ %i0 + 0x6c ], %i4
<== NOT EXECUTED
if ( mask & (_POSIX_signals_Pending & signals_unblocked) ) {
40019288: 07 10 00 79 sethi %hi(0x4001e400), %g3
<== NOT EXECUTED
4001928c: c6 00 e1 dc ld [ %g3 + 0x1dc ], %g3 ! 4001e5dc <_POSIX_signals_Pending>
<== NOT EXECUTED
40019290: 84 08 80 03 and %g2, %g3, %g2
<== NOT EXECUTED
40019294: 80 88 80 04 btst %g2, %g4
<== NOT EXECUTED
40019298: 12 80 00 12 bne 400192e0 <_POSIX_signals_Clear_signals+0x94>
<== NOT EXECUTED
4001929c: 86 10 20 00 clr %g3
<== NOT EXECUTED
api->signals_pending &= ~mask;
do_callout = true;
}
}
if ( do_signals_acquire_release ) {
400192a0: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
400192a4: 22 80 00 05 be,a 400192b8 <_POSIX_signals_Clear_signals+0x6c>
<== NOT EXECUTED
400192a8: b0 08 e0 01 and %g3, 1, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400192ac: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400192b0: 01 00 00 00 nop
<== NOT EXECUTED
_POSIX_signals_Release( &queue_context );
}
return do_callout;
}
400192b4: b0 08 e0 01 and %g3, 1, %i0
<== NOT EXECUTED
400192b8: 81 c7 e0 08 ret
<== NOT EXECUTED
400192bc: 81 e8 00 00 restore
<== NOT EXECUTED
if ( mask & (api->signals_pending & signals_unblocked) ) {
400192c0: b6 0f 00 02 and %i4, %g2, %i3
<== NOT EXECUTED
400192c4: 80 8e c0 04 btst %i3, %g4
<== NOT EXECUTED
400192c8: 02 bf ff f6 be 400192a0 <_POSIX_signals_Clear_signals+0x54>
<== NOT EXECUTED
400192cc: 86 10 20 00 clr %g3
<== NOT EXECUTED
api->signals_pending &= ~mask;
400192d0: 84 2f 00 02 andn %i4, %g2, %g2
<== NOT EXECUTED
do_callout = true;
400192d4: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
api->signals_pending &= ~mask;
400192d8: 10 bf ff f2 b 400192a0 <_POSIX_signals_Clear_signals+0x54>
<== NOT EXECUTED
400192dc: c4 26 20 6c st %g2, [ %i0 + 0x6c ]
<== NOT EXECUTED
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
400192e0: 85 2e 60 01 sll %i1, 1, %g2
<== NOT EXECUTED
400192e4: 07 10 00 79 sethi %hi(0x4001e400), %g3
<== NOT EXECUTED
400192e8: 84 00 80 19 add %g2, %i1, %g2
<== NOT EXECUTED
400192ec: 86 10 e0 50 or %g3, 0x50, %g3
<== NOT EXECUTED
400192f0: 85 28 a0 02 sll %g2, 2, %g2
<== NOT EXECUTED
400192f4: c6 00 c0 02 ld [ %g3 + %g2 ], %g3
<== NOT EXECUTED
400192f8: 80 a0 e0 02 cmp %g3, 2
<== NOT EXECUTED
400192fc: 22 80 00 08 be,a 4001931c <_POSIX_signals_Clear_signals+0xd0>
<== NOT EXECUTED
40019300: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
40019304: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
_POSIX_signals_Clear_process_signals( signo );
40019308: 40 00 00 26 call 400193a0 <_POSIX_signals_Clear_process_signals>
<== NOT EXECUTED
4001930c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
do_callout = true;
40019310: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
40019314: 10 bf ff e3 b 400192a0 <_POSIX_signals_Clear_signals+0x54>
<== NOT EXECUTED
40019318: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
_Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] );
4001931c: 07 10 00 79 sethi %hi(0x4001e400), %g3
<== NOT EXECUTED
40019320: 86 10 e1 e0 or %g3, 0x1e0, %g3 ! 4001e5e0 <_POSIX_signals_Siginfo>
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40019324: f8 00 80 03 ld [ %g2 + %g3 ], %i4
<== NOT EXECUTED
return &the_chain->Tail.Node;
40019328: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
4001932c: 88 01 00 03 add %g4, %g3, %g4
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
40019330: 80 a7 00 04 cmp %i4, %g4
<== NOT EXECUTED
40019334: 02 80 00 17 be 40019390 <_POSIX_signals_Clear_signals+0x144>
<== NOT EXECUTED
40019338: b6 00 80 03 add %g2, %g3, %i3
<== NOT EXECUTED
new_first = old_first->next;
4001933c: c8 07 00 00 ld [ %i4 ], %g4
<== NOT EXECUTED
head->next = new_first;
40019340: c8 20 80 03 st %g4, [ %g2 + %g3 ]
<== NOT EXECUTED
_POSIX_signals_Clear_process_signals( signo );
40019344: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40019348: 40 00 00 16 call 400193a0 <_POSIX_signals_Clear_process_signals>
<== NOT EXECUTED
4001934c: f6 21 20 04 st %i3, [ %g4 + 4 ]
<== NOT EXECUTED
*info = psiginfo->Info;
40019350: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
40019354: c4 26 80 00 st %g2, [ %i2 ]
<== NOT EXECUTED
40019358: c4 07 20 0c ld [ %i4 + 0xc ], %g2
<== NOT EXECUTED
4001935c: c4 26 a0 04 st %g2, [ %i2 + 4 ]
<== NOT EXECUTED
old_last = tail->previous;
40019360: 05 10 00 79 sethi %hi(0x4001e400), %g2
<== NOT EXECUTED
40019364: c6 07 20 10 ld [ %i4 + 0x10 ], %g3
<== NOT EXECUTED
40019368: c6 26 a0 08 st %g3, [ %i2 + 8 ]
<== NOT EXECUTED
4001936c: 84 10 a1 d0 or %g2, 0x1d0, %g2
<== NOT EXECUTED
40019370: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
the_node->next = tail;
40019374: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
40019378: c8 27 00 00 st %g4, [ %i4 ]
<== NOT EXECUTED
tail->previous = the_node;
4001937c: f8 20 a0 08 st %i4, [ %g2 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
40019380: f8 20 c0 00 st %i4, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40019384: c6 27 20 04 st %g3, [ %i4 + 4 ]
<== NOT EXECUTED
40019388: 10 bf ff df b 40019304 <_POSIX_signals_Clear_signals+0xb8>
<== NOT EXECUTED
4001938c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
_POSIX_signals_Clear_process_signals( signo );
40019390: 40 00 00 04 call 400193a0 <_POSIX_signals_Clear_process_signals>
<== NOT EXECUTED
40019394: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40019398: 10 bf ff db b 40019304 <_POSIX_signals_Clear_signals+0xb8>
<== NOT EXECUTED
4001939c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
4001b1d0 <_POSIX_signals_Default_vectors>:
4001b1d0: 00 00 00 00 ff ff ff ff 00 00 00 01 00 00 00 00 ................
4001b1e0: ff ff ff ff 40 01 8b c0 00 00 00 00 ff ff ff ff ....@...........
4001b1f0: 40 01 8b c0 00 00 00 00 ff ff ff ff 40 01 8b c0 @...........@...
4001b200: 00 00 00 00 ff ff ff ff 40 01 8b c0 00 00 00 00 ........@.......
4001b210: ff ff ff ff 40 01 8b c0 00 00 00 00 ff ff ff ff ....@...........
4001b220: 40 01 8b c0 00 00 00 00 ff ff ff ff 40 01 8b c0 @...........@...
4001b230: 00 00 00 00 ff ff ff ff 40 01 8b c0 00 00 00 00 ........@.......
4001b240: ff ff ff ff 40 01 8b c0 00 00 00 00 ff ff ff ff ....@...........
4001b250: 40 01 8b c0 00 00 00 00 ff ff ff ff 40 01 8b c0 @...........@...
4001b260: 00 00 00 00 ff ff ff ff 40 01 8b c0 00 00 00 00 ........@.......
4001b270: ff ff ff ff 40 01 8b c0 00 00 00 00 ff ff ff ff ....@...........
4001b280: 40 01 8b c0 00 00 00 00 ff ff ff ff 40 01 8b c0 @...........@...
4001b290: 00 00 00 00 ff ff ff ff 40 01 8b c0 00 00 00 00 ........@.......
4001b2a0: ff ff ff ff 40 01 8b c0 00 00 00 00 ff ff ff ff ....@...........
4001b2b0: 40 01 8b c0 00 00 00 00 ff ff ff ff 40 01 8b c0 @...........@...
4001b2c0: 00 00 00 00 ff ff ff ff 40 01 8b c0 00 00 00 00 ........@.......
4001b2d0: ff ff ff ff 40 01 8b c0 00 00 00 00 ff ff ff ff ....@...........
4001b2e0: 40 01 8b c0 00 00 00 00 ff ff ff ff 40 01 8b c0 @...........@...
4001b2f0: 00 00 00 00 ff ff ff ff 40 01 8b c0 00 00 00 00 ........@.......
4001b300: ff ff ff ff 40 01 8b c0 00 00 00 00 ff ff ff ff ....@...........
4001b310: 40 01 8b c0 00 00 00 00 ff ff ff ff 40 01 8b c0 @...........@...
4001b320: 00 00 00 00 ff ff ff ff 40 01 8b c0 00 00 00 00 ........@.......
4001b330: ff ff ff ff 40 01 8b c0 00 00 00 00 ff ff ff ff ....@...........
4001b340: 40 01 8b c0 00 00 00 00 ff ff ff ff 40 01 8b c0 @...........@...
40018790 <_POSIX_signals_Send>:
int _POSIX_signals_Send(
pid_t pid,
int sig,
const union sigval *value
)
{
40018790: 9d e3 bf 88 save %sp, -120, %sp
Per_CPU_Control *cpu_self;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
40018794: 7f ff fe e7 call 40018330 <getpid>
40018798: 01 00 00 00 nop
4001879c: 80 a2 00 18 cmp %o0, %i0
400187a0: 12 80 00 e7 bne 40018b3c <_POSIX_signals_Send+0x3ac>
<== NEVER TAKEN
400187a4: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
400187a8: 02 80 00 df be 40018b24 <_POSIX_signals_Send+0x394>
<== NEVER TAKEN
400187ac: b8 06 7f ff add %i1, -1, %i4
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
400187b0: 80 a7 20 1f cmp %i4, 0x1f
400187b4: 18 80 00 dc bgu 40018b24 <_POSIX_signals_Send+0x394>
<== NEVER TAKEN
400187b8: bb 2e 60 01 sll %i1, 1, %i5
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 )
400187bc: 37 10 00 79 sethi %hi(0x4001e400), %i3
400187c0: ba 07 40 19 add %i5, %i1, %i5
400187c4: b6 16 e0 50 or %i3, 0x50, %i3
400187c8: 83 2f 60 02 sll %i5, 2, %g1
400187cc: 82 06 c0 01 add %i3, %g1, %g1
400187d0: c2 00 60 08 ld [ %g1 + 8 ], %g1
400187d4: 80 a0 60 01 cmp %g1, 1
400187d8: 02 80 00 56 be 40018930 <_POSIX_signals_Send+0x1a0>
<== NEVER TAKEN
400187dc: b0 10 20 00 clr %i0
/*
* 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 ) )
400187e0: 82 06 7f fc add %i1, -4, %g1
400187e4: 80 88 7f fb btst -5, %g1
400187e8: 02 80 00 46 be 40018900 <_POSIX_signals_Send+0x170>
<== NEVER TAKEN
400187ec: 80 a6 60 0b cmp %i1, 0xb
400187f0: 02 80 00 44 be 40018900 <_POSIX_signals_Send+0x170>
<== NEVER TAKEN
400187f4: 82 10 20 01 mov 1, %g1
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
400187f8: f2 27 bf f4 st %i1, [ %fp + -12 ]
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
400187fc: b9 28 40 1c sll %g1, %i4, %i4
siginfo->si_code = SI_USER;
if ( !value ) {
40018800: 80 a6 a0 00 cmp %i2, 0
40018804: 02 80 00 99 be 40018a68 <_POSIX_signals_Send+0x2d8>
<== ALWAYS TAKEN
40018808: c2 27 bf f8 st %g1, [ %fp + -8 ]
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
4001880c: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
40018810: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40018814: b4 10 00 06 mov %g6, %i2
disable_level = cpu_self->thread_dispatch_disable_level;
40018818: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
return cpu->executing;
4001881c: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40018820: 82 00 60 01 inc %g1
* 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 ) ) {
40018824: c4 02 21 5c ld [ %o0 + 0x15c ], %g2
40018828: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
4001882c: c2 00 a0 68 ld [ %g2 + 0x68 ], %g1
40018830: 80 8f 00 01 btst %i4, %g1
40018834: 12 80 00 1a bne 4001889c <_POSIX_signals_Send+0x10c>
<== NEVER TAKEN
40018838: 03 10 00 72 sethi %hi(0x4001c800), %g1
* 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;
4001883c: c4 00 61 c4 ld [ %g1 + 0x1c4 ], %g2 ! 4001c9c4 <_POSIX_signals_Wait_queue>
if ( heads != NULL ) {
40018840: 80 a0 a0 00 cmp %g2, 0
40018844: 02 80 00 3d be 40018938 <_POSIX_signals_Send+0x1a8>
<== ALWAYS TAKEN
40018848: 17 10 00 68 sethi %hi(0x4001a000), %o3
4001884c: c2 00 80 00 ld [ %g2 ], %g1
<== NOT EXECUTED
return &the_chain->Tail.Node;
40018850: 84 00 a0 04 add %g2, 4, %g2
<== NOT EXECUTED
Chain_Control *the_chain = &heads->Heads.Fifo;
for ( the_node = _Chain_First( the_chain );
40018854: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40018858: 32 80 00 0d bne,a 4001888c <_POSIX_signals_Send+0xfc>
<== NOT EXECUTED
4001885c: d0 00 7f f8 ld [ %g1 + -8 ], %o0
<== NOT EXECUTED
40018860: 10 80 00 37 b 4001893c <_POSIX_signals_Send+0x1ac>
<== NOT EXECUTED
40018864: 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)
40018868: c6 01 20 68 ld [ %g4 + 0x68 ], %g3
<== NOT EXECUTED
4001886c: 80 8f 00 03 btst %i4, %g3
<== NOT EXECUTED
40018870: 12 80 00 0c bne 400188a0 <_POSIX_signals_Send+0x110>
<== NOT EXECUTED
40018874: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
the_node = the_node->next ) {
40018878: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
4001887c: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40018880: 02 80 00 2e be 40018938 <_POSIX_signals_Send+0x1a8>
<== NOT EXECUTED
40018884: 17 10 00 68 sethi %hi(0x4001a000), %o3
<== NOT EXECUTED
40018888: d0 00 7f f8 ld [ %g1 + -8 ], %o0
<== NOT EXECUTED
if (the_thread->Wait.option & mask)
4001888c: c6 02 20 48 ld [ %o0 + 0x48 ], %g3
<== NOT EXECUTED
40018890: 80 8f 00 03 btst %i4, %g3
<== NOT EXECUTED
40018894: 02 bf ff f5 be 40018868 <_POSIX_signals_Send+0xd8>
<== NOT EXECUTED
40018898: 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 ) ) {
4001889c: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
400188a0: 40 00 01 60 call 40018e20 <_POSIX_signals_Unblock_thread>
<== NOT EXECUTED
400188a4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400188a8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400188ac: 12 80 00 1b bne 40018918 <_POSIX_signals_Send+0x188>
<== NOT EXECUTED
400188b0: 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 );
400188b4: 40 00 00 f0 call 40018c74 <_POSIX_signals_Set_process_signals>
400188b8: 90 10 00 1c mov %i4, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400188bc: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
400188c0: 86 10 00 01 mov %g1, %g3
_Thread_queue_Context_initialize( &queue_context );
_POSIX_signals_Acquire( &queue_context );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
400188c4: bb 2f 60 02 sll %i5, 2, %i5
400188c8: c4 06 c0 1d ld [ %i3 + %i5 ], %g2
400188cc: 80 a0 a0 02 cmp %g2, 2
400188d0: 02 80 00 6c be 40018a80 <_POSIX_signals_Send+0x2f0>
<== NEVER TAKEN
400188d4: 09 10 00 79 sethi %hi(0x4001e400), %g4
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400188d8: 82 10 00 03 mov %g3, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400188dc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400188e0: 01 00 00 00 nop
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
400188e4: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
if ( disable_level == 1 ) {
400188e8: 80 a0 60 01 cmp %g1, 1
400188ec: 02 80 00 7f be 40018ae8 <_POSIX_signals_Send+0x358>
<== ALWAYS TAKEN
400188f0: 82 00 7f ff add %g1, -1, %g1
cpu_self->thread_dispatch_disable_level = disable_level - 1;
400188f4: 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;
}
400188f8: 81 c7 e0 08 ret
<== NOT EXECUTED
400188fc: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
return pthread_kill( pthread_self(), sig );
40018900: 40 00 01 f9 call 400190e4 <pthread_self>
<== NOT EXECUTED
40018904: 01 00 00 00 nop
<== NOT EXECUTED
40018908: 40 00 01 b5 call 40018fdc <pthread_kill>
<== NOT EXECUTED
4001890c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40018910: 81 c7 e0 08 ret
<== NOT EXECUTED
40018914: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
40018918: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4001891c: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
40018920: 02 80 00 72 be 40018ae8 <_POSIX_signals_Send+0x358>
<== NOT EXECUTED
40018924: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
return 0;
40018928: b0 10 20 00 clr %i0
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4001892c: c2 26 a0 18 st %g1, [ %i2 + 0x18 ]
<== NOT EXECUTED
40018930: 81 c7 e0 08 ret
<== NOT EXECUTED
40018934: 81 e8 00 00 restore
<== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
40018938: 9e 10 3f ff mov -1, %o7
4001893c: 94 10 3f ff mov -1, %o2
40018940: 90 10 20 00 clr %o0
40018944: 98 10 20 02 mov 2, %o4
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
40018948: 13 04 00 00 sethi %hi(0x10000000), %o1
4001894c: 96 12 e0 5c or %o3, 0x5c, %o3
if ( !_Objects_Information_table[ the_api ] )
40018950: 83 2b 20 02 sll %o4, 2, %g1
40018954: c2 02 c0 01 ld [ %o3 + %g1 ], %g1
40018958: 80 a0 60 00 cmp %g1, 0
4001895c: 02 80 00 39 be 40018a40 <_POSIX_signals_Send+0x2b0>
<== NEVER TAKEN
40018960: 80 a3 20 03 cmp %o4, 3
the_info = _Objects_Information_table[ the_api ][ 1 ];
40018964: c2 00 60 04 ld [ %g1 + 4 ], %g1
if ( !the_info )
40018968: 80 a0 60 00 cmp %g1, 0
4001896c: 02 80 00 35 be 40018a40 <_POSIX_signals_Send+0x2b0>
40018970: 80 a3 20 03 cmp %o4, 3
maximum = the_info->maximum;
40018974: f0 10 60 10 lduh [ %g1 + 0x10 ], %i0
for ( index = 1 ; index <= maximum ; index++ ) {
40018978: 80 a6 20 00 cmp %i0, 0
4001897c: 02 80 00 30 be 40018a3c <_POSIX_signals_Send+0x2ac>
<== NEVER TAKEN
40018980: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
40018984: 82 00 60 04 add %g1, 4, %g1
40018988: b1 2e 20 02 sll %i0, 2, %i0
4001898c: b0 06 00 01 add %i0, %g1, %i0
the_thread = (Thread_Control *) object_table[ index ];
40018990: c4 00 40 00 ld [ %g1 ], %g2
if ( !the_thread )
40018994: 80 a0 a0 00 cmp %g2, 0
40018998: 22 80 00 26 be,a 40018a30 <_POSIX_signals_Send+0x2a0>
4001899c: 82 00 60 04 add %g1, 4, %g1
400189a0: c6 00 a0 38 ld [ %g2 + 0x38 ], %g3
400189a4: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
if ( _Thread_Get_priority( the_thread ) > interested_priority )
400189a8: 80 a1 00 0f cmp %g4, %o7
400189ac: 18 80 00 20 bgu 40018a2c <_POSIX_signals_Send+0x29c>
<== NEVER TAKEN
400189b0: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
400189b4: 02 80 00 29 be 40018a58 <_POSIX_signals_Send+0x2c8>
<== NEVER TAKEN
400189b8: 80 a0 c0 0a cmp %g3, %o2
if ( !_POSIX_signals_Is_interested( api, mask ) )
400189bc: da 00 a1 5c ld [ %g2 + 0x15c ], %o5
400189c0: da 03 60 68 ld [ %o5 + 0x68 ], %o5
400189c4: 80 8f 00 0d btst %i4, %o5
400189c8: 02 80 00 19 be 40018a2c <_POSIX_signals_Send+0x29c>
<== ALWAYS TAKEN
400189cc: 80 a3 c0 04 cmp %o7, %g4
if ( _Thread_Get_priority( the_thread ) < interested_priority ) {
400189d0: 38 80 00 15 bgu,a 40018a24 <_POSIX_signals_Send+0x294>
<== NOT EXECUTED
400189d4: 9e 10 00 04 mov %g4, %o7
<== NOT EXECUTED
400189d8: 02 80 00 26 be 40018a70 <_POSIX_signals_Send+0x2e0>
<== NOT EXECUTED
400189dc: 80 a2 80 03 cmp %o2, %g3
<== NOT EXECUTED
if ( interested && !_States_Is_ready( interested->current_state ) ) {
400189e0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400189e4: 22 80 00 13 be,a 40018a30 <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
400189e8: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
400189ec: da 02 20 1c ld [ %o0 + 0x1c ], %o5
<== NOT EXECUTED
400189f0: 80 a3 60 00 cmp %o5, 0
<== NOT EXECUTED
400189f4: 22 80 00 0f be,a 40018a30 <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
400189f8: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
if ( _States_Is_ready( the_thread->current_state ) ) {
400189fc: e0 00 a0 1c ld [ %g2 + 0x1c ], %l0
<== NOT EXECUTED
40018a00: 80 a4 20 00 cmp %l0, 0
<== NOT EXECUTED
40018a04: 02 80 00 07 be 40018a20 <_POSIX_signals_Send+0x290>
<== NOT EXECUTED
40018a08: 80 8b 40 09 btst %o5, %o1
<== NOT EXECUTED
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
40018a0c: 32 80 00 09 bne,a 40018a30 <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
40018a10: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
40018a14: 80 8c 00 09 btst %l0, %o1
<== NOT EXECUTED
40018a18: 22 80 00 06 be,a 40018a30 <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
40018a1c: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
40018a20: 9e 10 00 04 mov %g4, %o7
<== NOT EXECUTED
40018a24: 94 10 00 03 mov %g3, %o2
<== NOT EXECUTED
40018a28: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
40018a2c: 82 00 60 04 add %g1, 4, %g1
for ( index = 1 ; index <= maximum ; index++ ) {
40018a30: 80 a6 00 01 cmp %i0, %g1
40018a34: 32 bf ff d8 bne,a 40018994 <_POSIX_signals_Send+0x204>
40018a38: c4 00 40 00 ld [ %g1 ], %g2
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
40018a3c: 80 a3 20 03 cmp %o4, 3
40018a40: 12 bf ff c4 bne 40018950 <_POSIX_signals_Send+0x1c0>
40018a44: 98 10 20 03 mov 3, %o4
if ( interested ) {
40018a48: 80 a2 20 00 cmp %o0, 0
40018a4c: 12 bf ff 95 bne 400188a0 <_POSIX_signals_Send+0x110>
<== NEVER TAKEN
40018a50: 94 07 bf f4 add %fp, -12, %o2
40018a54: 30 bf ff 98 b,a 400188b4 <_POSIX_signals_Send+0x124>
if ( _Thread_Get_priority( the_thread ) > interested_priority )
40018a58: 28 bf ff da bleu,a 400189c0 <_POSIX_signals_Send+0x230>
<== NOT EXECUTED
40018a5c: da 00 a1 5c ld [ %g2 + 0x15c ], %o5
<== NOT EXECUTED
40018a60: 10 bf ff f4 b 40018a30 <_POSIX_signals_Send+0x2a0>
<== NOT EXECUTED
40018a64: 82 00 60 04 add %g1, 4, %g1
<== NOT EXECUTED
40018a68: 10 bf ff 6b b 40018814 <_POSIX_signals_Send+0x84>
40018a6c: c0 27 bf fc clr [ %fp + -4 ]
if ( _Thread_Get_priority( the_thread ) < interested_priority ) {
40018a70: 08 bf ff dd bleu 400189e4 <_POSIX_signals_Send+0x254>
<== NOT EXECUTED
40018a74: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40018a78: 10 bf ff eb b 40018a24 <_POSIX_signals_Send+0x294>
<== NOT EXECUTED
40018a7c: 9e 10 00 04 mov %g4, %o7
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40018a80: c4 01 21 d0 ld [ %g4 + 0x1d0 ], %g2
<== NOT EXECUTED
40018a84: b8 11 21 d0 or %g4, 0x1d0, %i4
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
40018a88: b6 07 20 04 add %i4, 4, %i3
<== NOT EXECUTED
40018a8c: 80 a0 80 1b cmp %g2, %i3
<== NOT EXECUTED
40018a90: 02 80 00 31 be 40018b54 <_POSIX_signals_Send+0x3c4>
<== NOT EXECUTED
40018a94: 01 00 00 00 nop
<== NOT EXECUTED
new_first = old_first->next;
40018a98: c2 00 80 00 ld [ %g2 ], %g1
<== NOT EXECUTED
new_first->previous = head;
40018a9c: f8 20 60 04 st %i4, [ %g1 + 4 ]
<== NOT EXECUTED
psiginfo->Info = *siginfo;
40018aa0: f6 07 bf fc ld [ %fp + -4 ], %i3
<== NOT EXECUTED
40018aa4: f2 07 bf f8 ld [ %fp + -8 ], %i1
<== NOT EXECUTED
head->next = new_first;
40018aa8: c2 21 21 d0 st %g1, [ %g4 + 0x1d0 ]
<== NOT EXECUTED
_Chain_Append_unprotected(
40018aac: 03 10 00 79 sethi %hi(0x4001e400), %g1
<== NOT EXECUTED
psiginfo->Info = *siginfo;
40018ab0: c8 07 bf f4 ld [ %fp + -12 ], %g4
<== NOT EXECUTED
40018ab4: c8 20 a0 08 st %g4, [ %g2 + 8 ]
<== NOT EXECUTED
_Chain_Append_unprotected(
40018ab8: 82 10 61 e0 or %g1, 0x1e0, %g1
<== NOT EXECUTED
psiginfo->Info = *siginfo;
40018abc: f2 20 a0 0c st %i1, [ %g2 + 0xc ]
<== NOT EXECUTED
_Chain_Append_unprotected(
40018ac0: b8 07 40 01 add %i5, %g1, %i4
<== NOT EXECUTED
return &the_chain->Tail.Node;
40018ac4: ba 07 60 04 add %i5, 4, %i5
<== NOT EXECUTED
old_last = tail->previous;
40018ac8: c8 07 20 08 ld [ %i4 + 8 ], %g4
<== NOT EXECUTED
return &the_chain->Tail.Node;
40018acc: ba 07 40 01 add %i5, %g1, %i5
<== NOT EXECUTED
psiginfo->Info = *siginfo;
40018ad0: f6 20 a0 10 st %i3, [ %g2 + 0x10 ]
<== NOT EXECUTED
the_node->next = tail;
40018ad4: fa 20 80 00 st %i5, [ %g2 ]
<== NOT EXECUTED
tail->previous = the_node;
40018ad8: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
40018adc: c4 21 00 00 st %g2, [ %g4 ]
<== NOT EXECUTED
the_node->previous = old_last;
40018ae0: 10 bf ff 7e b 400188d8 <_POSIX_signals_Send+0x148>
<== NOT EXECUTED
40018ae4: c8 20 a0 04 st %g4, [ %g2 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018ae8: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
40018aec: c4 0e a0 1c ldub [ %i2 + 0x1c ], %g2
40018af0: 80 a0 a0 00 cmp %g2, 0
40018af4: 12 80 00 07 bne 40018b10 <_POSIX_signals_Send+0x380>
<== NEVER TAKEN
40018af8: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
40018afc: c0 26 a0 18 clr [ %i2 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018b00: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018b04: 01 00 00 00 nop
return 0;
40018b08: 81 c7 e0 08 ret
40018b0c: 91 e8 20 00 restore %g0, 0, %o0
_Thread_Do_dispatch( cpu_self, level );
40018b10: c2 27 bf ec st %g1, [ %fp + -20 ]
<== NOT EXECUTED
40018b14: 7f ff d4 7d call 4000dd08 <_Thread_Do_dispatch>
<== NOT EXECUTED
40018b18: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
40018b1c: 10 bf ff f9 b 40018b00 <_POSIX_signals_Send+0x370>
<== NOT EXECUTED
40018b20: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
40018b24: 7f ff d5 d3 call 4000e270 <__errno>
<== NOT EXECUTED
40018b28: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40018b2c: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40018b30: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40018b34: 81 c7 e0 08 ret
<== NOT EXECUTED
40018b38: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ESRCH );
40018b3c: 7f ff d5 cd call 4000e270 <__errno>
<== NOT EXECUTED
40018b40: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40018b44: 82 10 20 03 mov 3, %g1
<== NOT EXECUTED
40018b48: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40018b4c: 81 c7 e0 08 ret
<== NOT EXECUTED
40018b50: 81 e8 00 00 restore
<== NOT EXECUTED
40018b54: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018b58: 01 00 00 00 nop
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
40018b5c: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
40018b60: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
40018b64: 02 80 00 09 be 40018b88 <_POSIX_signals_Send+0x3f8>
<== NOT EXECUTED
40018b68: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
40018b6c: c2 26 a0 18 st %g1, [ %i2 + 0x18 ]
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EAGAIN );
40018b70: 7f ff d5 c0 call 4000e270 <__errno>
<== NOT EXECUTED
40018b74: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40018b78: 82 10 20 0b mov 0xb, %g1
<== NOT EXECUTED
40018b7c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40018b80: 81 c7 e0 08 ret
<== NOT EXECUTED
40018b84: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018b88: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
40018b8c: c4 0e a0 1c ldub [ %i2 + 0x1c ], %g2
<== NOT EXECUTED
40018b90: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40018b94: 12 80 00 06 bne 40018bac <_POSIX_signals_Send+0x41c>
<== NOT EXECUTED
40018b98: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
40018b9c: c0 26 a0 18 clr [ %i2 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018ba0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018ba4: 01 00 00 00 nop
<== NOT EXECUTED
40018ba8: 30 bf ff f2 b,a 40018b70 <_POSIX_signals_Send+0x3e0>
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
40018bac: c2 27 bf ec st %g1, [ %fp + -20 ]
<== NOT EXECUTED
40018bb0: 7f ff d4 56 call 4000dd08 <_Thread_Do_dispatch>
<== NOT EXECUTED
40018bb4: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
40018bb8: 10 bf ff fa b 40018ba0 <_POSIX_signals_Send+0x410>
<== NOT EXECUTED
40018bbc: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
40018c74 <_POSIX_signals_Set_process_signals>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018c74: 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;
40018c78: 07 10 00 79 sethi %hi(0x4001e400), %g3
<== NOT EXECUTED
40018c7c: c4 00 e1 dc ld [ %g3 + 0x1dc ], %g2 ! 4001e5dc <_POSIX_signals_Pending>
<== NOT EXECUTED
40018c80: 90 10 80 08 or %g2, %o0, %o0
<== NOT EXECUTED
40018c84: d0 20 e1 dc st %o0, [ %g3 + 0x1dc ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018c88: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018c8c: 01 00 00 00 nop
_POSIX_signals_Release( &queue_context );
}
40018c90: 81 c3 e0 08 retl
40018c94: 01 00 00 00 nop
40018e20 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
40018e20: 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 ];
40018e24: 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 ) ) {
40018e28: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
<== NOT EXECUTED
40018e2c: 05 04 00 01 sethi %hi(0x10000400), %g2
<== NOT EXECUTED
40018e30: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
40018e34: 82 06 7f ff add %i1, -1, %g1
<== NOT EXECUTED
40018e38: b8 08 c0 02 and %g3, %g2, %i4
<== NOT EXECUTED
40018e3c: 83 29 00 01 sll %g4, %g1, %g1
<== NOT EXECUTED
40018e40: 80 a7 00 02 cmp %i4, %g2
<== NOT EXECUTED
40018e44: 02 80 00 19 be 40018ea8 <_POSIX_signals_Unblock_thread+0x88>
<== NOT EXECUTED
40018e48: b6 07 60 70 add %i5, 0x70, %i3
<== NOT EXECUTED
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( api->signals_unblocked & mask ) {
40018e4c: c4 07 60 68 ld [ %i5 + 0x68 ], %g2
<== NOT EXECUTED
40018e50: 80 88 40 02 btst %g1, %g2
<== NOT EXECUTED
40018e54: 02 80 00 05 be 40018e68 <_POSIX_signals_Unblock_thread+0x48>
<== NOT EXECUTED
40018e58: 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 ) ) {
40018e5c: 80 88 c0 01 btst %g3, %g1
<== NOT EXECUTED
40018e60: 12 80 00 4b bne 40018f8c <_POSIX_signals_Unblock_thread+0x16c>
<== NOT EXECUTED
40018e64: 82 10 24 0d mov 0x40d, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018e68: 91 d0 20 09 ta 9
<== NOT EXECUTED
action->handler = handler;
40018e6c: 05 10 00 63 sethi %hi(0x40018c00), %g2
<== NOT EXECUTED
40018e70: 84 10 a1 34 or %g2, 0x134, %g2 ! 40018d34 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
40018e74: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
cpu_self->dispatch_necessary = true;
40018e78: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
40018e7c: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
<== NOT EXECUTED
if ( _Chain_Is_node_off_chain( the_node ) ) {
40018e80: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
40018e84: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40018e88: 22 80 00 1a be,a 40018ef0 <_POSIX_signals_Unblock_thread+0xd0>
<== NOT EXECUTED
40018e8c: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018e90: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018e94: 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 );
40018e98: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
}
40018e9c: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
40018ea0: 81 c7 e0 08 ret
<== NOT EXECUTED
40018ea4: 81 e8 00 00 restore
<== NOT EXECUTED
if ( (the_thread->Wait.option & mask) || (api->signals_unblocked & mask) ) {
40018ea8: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
<== NOT EXECUTED
40018eac: 80 88 40 02 btst %g1, %g2
<== NOT EXECUTED
40018eb0: 32 80 00 16 bne,a 40018f08 <_POSIX_signals_Unblock_thread+0xe8>
<== NOT EXECUTED
40018eb4: 82 10 24 0d mov 0x40d, %g1
<== NOT EXECUTED
40018eb8: c4 07 60 68 ld [ %i5 + 0x68 ], %g2
<== NOT EXECUTED
40018ebc: 80 88 40 02 btst %g1, %g2
<== NOT EXECUTED
40018ec0: 12 80 00 12 bne 40018f08 <_POSIX_signals_Unblock_thread+0xe8>
<== NOT EXECUTED
40018ec4: 82 10 24 0d mov 0x40d, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018ec8: 91 d0 20 09 ta 9
<== NOT EXECUTED
40018ecc: 05 10 00 63 sethi %hi(0x40018c00), %g2
<== NOT EXECUTED
40018ed0: 84 10 a1 34 or %g2, 0x134, %g2 ! 40018d34 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
40018ed4: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
40018ed8: c8 29 a0 1c stb %g4, [ %g6 + 0x1c ]
<== NOT EXECUTED
40018edc: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
40018ee0: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40018ee4: 12 bf ff eb bne 40018e90 <_POSIX_signals_Unblock_thread+0x70>
<== NOT EXECUTED
40018ee8: 01 00 00 00 nop
<== NOT EXECUTED
old_last = tail->previous;
40018eec: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
return &the_chain->Tail.Node;
40018ef0: 86 06 20 e4 add %i0, 0xe4, %g3
<== NOT EXECUTED
the_node->next = tail;
40018ef4: c6 27 60 70 st %g3, [ %i5 + 0x70 ]
<== NOT EXECUTED
tail->previous = the_node;
40018ef8: f6 26 20 e8 st %i3, [ %i0 + 0xe8 ]
<== NOT EXECUTED
old_last->next = the_node;
40018efc: f6 20 80 00 st %i3, [ %g2 ]
<== NOT EXECUTED
the_node->previous = old_last;
40018f00: 10 bf ff e4 b 40018e90 <_POSIX_signals_Unblock_thread+0x70>
<== NOT EXECUTED
40018f04: c4 27 60 74 st %g2, [ %i5 + 0x74 ]
<== NOT EXECUTED
the_thread->Wait.return_code = STATUS_INTERRUPTED;
40018f08: c2 26 20 4c st %g1, [ %i0 + 0x4c ]
<== NOT EXECUTED
if ( !info ) {
40018f0c: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40018f10: 02 80 00 2e be 40018fc8 <_POSIX_signals_Unblock_thread+0x1a8>
<== NOT EXECUTED
40018f14: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
<== NOT EXECUTED
*the_info = *info;
40018f18: c4 06 80 00 ld [ %i2 ], %g2
<== NOT EXECUTED
40018f1c: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
40018f20: c4 06 a0 04 ld [ %i2 + 4 ], %g2
<== NOT EXECUTED
40018f24: c4 20 60 04 st %g2, [ %g1 + 4 ]
<== NOT EXECUTED
40018f28: c4 06 a0 08 ld [ %i2 + 8 ], %g2
<== NOT EXECUTED
40018f2c: c4 20 60 08 st %g2, [ %g1 + 8 ]
<== NOT EXECUTED
_Thread_queue_Extract_with_proxy( the_thread );
40018f30: 7f ff d3 c9 call 4000de54 <_Thread_queue_Extract_with_proxy>
<== NOT EXECUTED
40018f34: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40018f38: 91 d0 20 09 ta 9
<== NOT EXECUTED
40018f3c: 05 10 00 63 sethi %hi(0x40018c00), %g2
<== NOT EXECUTED
40018f40: 84 10 a1 34 or %g2, 0x134, %g2 ! 40018d34 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
40018f44: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
40018f48: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
40018f4c: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
<== NOT EXECUTED
if ( _Chain_Is_node_off_chain( the_node ) ) {
40018f50: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
40018f54: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40018f58: 12 80 00 07 bne 40018f74 <_POSIX_signals_Unblock_thread+0x154>
<== NOT EXECUTED
40018f5c: 86 06 20 e4 add %i0, 0xe4, %g3
<== NOT EXECUTED
old_last = tail->previous;
40018f60: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
the_node->next = tail;
40018f64: c6 27 60 70 st %g3, [ %i5 + 0x70 ]
<== NOT EXECUTED
tail->previous = the_node;
40018f68: f6 26 20 e8 st %i3, [ %i0 + 0xe8 ]
<== NOT EXECUTED
old_last->next = the_node;
40018f6c: f6 20 80 00 st %i3, [ %g2 ]
<== NOT EXECUTED
the_node->previous = old_last;
40018f70: c4 27 60 74 st %g2, [ %i5 + 0x74 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018f74: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018f78: 01 00 00 00 nop
<== NOT EXECUTED
return _POSIX_signals_Unblock_thread_done( the_thread, api, true );
40018f7c: b0 10 20 01 mov 1, %i0 ! 1 <_TLS_Alignment>
<== NOT EXECUTED
}
40018f80: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
40018f84: 81 c7 e0 08 ret
<== NOT EXECUTED
40018f88: 81 e8 00 00 restore
<== NOT EXECUTED
the_thread->Wait.return_code = STATUS_INTERRUPTED;
40018f8c: c2 26 20 4c st %g1, [ %i0 + 0x4c ]
<== NOT EXECUTED
_Thread_queue_Extract_with_proxy( the_thread );
40018f90: 7f ff d3 b1 call 4000de54 <_Thread_queue_Extract_with_proxy>
<== NOT EXECUTED
40018f94: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018f98: 91 d0 20 09 ta 9
<== NOT EXECUTED
40018f9c: 05 10 00 63 sethi %hi(0x40018c00), %g2
<== NOT EXECUTED
40018fa0: 84 10 a1 34 or %g2, 0x134, %g2 ! 40018d34 <_POSIX_signals_Action_handler>
<== NOT EXECUTED
40018fa4: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
<== NOT EXECUTED
40018fa8: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
40018fac: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
<== NOT EXECUTED
if ( _Chain_Is_node_off_chain( the_node ) ) {
40018fb0: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
40018fb4: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40018fb8: 12 bf ff b6 bne 40018e90 <_POSIX_signals_Unblock_thread+0x70>
<== NOT EXECUTED
40018fbc: 01 00 00 00 nop
<== NOT EXECUTED
old_last = tail->previous;
40018fc0: 10 bf ff cc b 40018ef0 <_POSIX_signals_Unblock_thread+0xd0>
<== NOT EXECUTED
40018fc4: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
<== NOT EXECUTED
the_info->si_code = SI_USER;
40018fc8: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
the_info->si_signo = signo;
40018fcc: f2 20 40 00 st %i1, [ %g1 ]
<== NOT EXECUTED
the_info->si_code = SI_USER;
40018fd0: c4 20 60 04 st %g2, [ %g1 + 4 ]
<== NOT EXECUTED
40018fd4: 10 bf ff d7 b 40018f30 <_POSIX_signals_Unblock_thread+0x110>
<== NOT EXECUTED
40018fd8: c0 20 60 08 clr [ %g1 + 8 ]
<== NOT EXECUTED
40007870 <_pthread_cleanup_pop>:
{
40007870: 9d e3 bf a0 save %sp, -96, %sp
if ( execute != 0 ) {
40007874: 80 a6 60 00 cmp %i1, 0
40007878: 02 80 00 05 be 4000788c <_pthread_cleanup_pop+0x1c>
<== ALWAYS TAKEN
4000787c: 01 00 00 00 nop
( *context->_routine )( context->_arg );
40007880: c2 06 00 00 ld [ %i0 ], %g1
<== NOT EXECUTED
40007884: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007888: d0 06 20 04 ld [ %i0 + 4 ], %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000788c: 91 d0 20 09 ta 9
<== NOT EXECUTED
executing->last_cleanup_context = context->_previous;
40007890: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2
<== NOT EXECUTED
40007894: c6 06 20 0c ld [ %i0 + 0xc ], %g3
<== NOT EXECUTED
40007898: c6 20 a1 84 st %g3, [ %g2 + 0x184 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000789c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400078a0: 01 00 00 00 nop
}
400078a4: 81 c7 e0 08 ret
400078a8: 81 e8 00 00 restore
4000783c <_pthread_cleanup_push>:
context->_canceltype = -1;
4000783c: 82 10 3f ff mov -1, %g1
<== NOT EXECUTED
context->_routine = routine;
40007840: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
context->_arg = arg;
40007844: d4 22 20 04 st %o2, [ %o0 + 4 ]
<== NOT EXECUTED
context->_canceltype = -1;
40007848: c2 22 20 08 st %g1, [ %o0 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000784c: 91 d0 20 09 ta 9
<== NOT EXECUTED
executing = _Thread_Executing;
40007850: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2
<== NOT EXECUTED
context->_previous = executing->last_cleanup_context;
40007854: c6 00 a1 84 ld [ %g2 + 0x184 ], %g3
<== NOT EXECUTED
40007858: c6 22 20 0c st %g3, [ %o0 + 0xc ]
<== NOT EXECUTED
executing->last_cleanup_context = context;
4000785c: d0 20 a1 84 st %o0, [ %g2 + 0x184 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007860: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007864: 01 00 00 00 nop
}
40007868: 81 c3 e0 08 retl
4000786c: 01 00 00 00 nop
40006a84 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
40006a84: 9d e3 bf a0 save %sp, -96, %sp
if ( !tp )
40006a88: 80 a6 60 00 cmp %i1, 0
40006a8c: 02 80 00 1f be 40006b08 <clock_gettime+0x84>
<== NEVER TAKEN
40006a90: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
40006a94: 02 80 00 18 be 40006af4 <clock_gettime+0x70>
40006a98: 82 06 3f fe add %i0, -2, %g1
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
40006a9c: 80 88 7f fd btst -3, %g1
40006aa0: 02 80 00 0a be 40006ac8 <clock_gettime+0x44>
<== ALWAYS TAKEN
40006aa4: 80 a6 20 03 cmp %i0, 3
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
40006aa8: 02 80 00 0d be 40006adc <clock_gettime+0x58>
<== NOT EXECUTED
40006aac: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
40006ab0: 40 00 29 12 call 40010ef8 <__errno>
<== NOT EXECUTED
40006ab4: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40006ab8: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40006abc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return 0;
}
40006ac0: 81 c7 e0 08 ret
<== NOT EXECUTED
40006ac4: 81 e8 00 00 restore
<== NOT EXECUTED
_Timecounter_Nanouptime( tp );
40006ac8: 90 10 00 19 mov %i1, %o0
40006acc: 40 00 0a 22 call 40009354 <_Timecounter_Nanouptime>
40006ad0: b0 10 20 00 clr %i0
return 0;
40006ad4: 81 c7 e0 08 ret
40006ad8: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( ENOSYS );
40006adc: 40 00 29 07 call 40010ef8 <__errno>
<== NOT EXECUTED
40006ae0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006ae4: 82 10 20 58 mov 0x58, %g1
<== NOT EXECUTED
40006ae8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006aec: 81 c7 e0 08 ret
<== NOT EXECUTED
40006af0: 81 e8 00 00 restore
<== NOT EXECUTED
_Timecounter_Nanotime( tod );
40006af4: 90 10 00 19 mov %i1, %o0
40006af8: 40 00 0a 52 call 40009440 <_Timecounter_Nanotime>
40006afc: b0 10 20 00 clr %i0
return 0;
40006b00: 81 c7 e0 08 ret
40006b04: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EINVAL );
40006b08: 40 00 28 fc call 40010ef8 <__errno>
<== NOT EXECUTED
40006b0c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006b10: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40006b14: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006b18: 81 c7 e0 08 ret
<== NOT EXECUTED
40006b1c: 81 e8 00 00 restore
<== NOT EXECUTED
4000618c <mq_open>:
int oflag,
...
/* mode_t mode, */
/* struct mq_attr attr */
)
{
4000618c: 9d e3 bf 90 save %sp, -112, %sp
_POSIX_Get_by_name_error( error ),
MQ_OPEN_FAILED
);
}
va_start( ap, oflag );
40006190: 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(
40006194: 37 10 00 51 sethi %hi(0x40014400), %i3
40006198: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
4000619c: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
_RTEMS_Lock_allocator();
400061a0: 40 00 05 4b call 400076cc <_RTEMS_Lock_allocator>
400061a4: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
400061a8: 96 07 bf f8 add %fp, -8, %o3
400061ac: 94 07 bf f4 add %fp, -12, %o2
400061b0: 92 10 00 18 mov %i0, %o1
400061b4: 40 00 0e 1e call 40009a2c <_Objects_Get_by_name>
400061b8: 90 16 e1 08 or %i3, 0x108, %o0
if ( the_mq == NULL ) {
400061bc: 80 a2 20 00 cmp %o0, 0
400061c0: 02 80 00 0e be 400061f8 <mq_open+0x6c>
<== ALWAYS TAKEN
400061c4: c2 07 bf f8 ld [ %fp + -8 ], %g1
/*
* Check for existence with creation.
*/
if ( ( oflag & ( O_CREAT | O_EXCL ) ) == ( O_CREAT | O_EXCL ) ) {
400061c8: b2 0e 6a 00 and %i1, 0xa00, %i1
<== NOT EXECUTED
400061cc: 80 a6 6a 00 cmp %i1, 0xa00
<== NOT EXECUTED
400061d0: 02 80 00 44 be 400062e0 <mq_open+0x154>
<== NOT EXECUTED
400061d4: 01 00 00 00 nop
<== NOT EXECUTED
_Objects_Allocator_unlock();
rtems_set_errno_and_return_value( EEXIST, MQ_OPEN_FAILED );
}
the_mq->open_count += 1;
400061d8: c2 02 20 50 ld [ %o0 + 0x50 ], %g1
<== NOT EXECUTED
400061dc: 82 00 60 01 inc %g1
<== NOT EXECUTED
400061e0: c2 22 20 50 st %g1, [ %o0 + 0x50 ]
<== NOT EXECUTED
status = the_mq->Object.id;
400061e4: f0 02 20 08 ld [ %o0 + 8 ], %i0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
400061e8: 40 00 05 3e call 400076e0 <_RTEMS_Unlock_allocator>
400061ec: 01 00 00 00 nop
}
_Objects_Allocator_unlock();
return status;
}
400061f0: 81 c7 e0 08 ret
400061f4: 81 e8 00 00 restore
if ( error != OBJECTS_GET_BY_NAME_NO_OBJECT || ( oflag & O_CREAT ) == 0 ) {
400061f8: 80 a0 60 02 cmp %g1, 2
400061fc: 12 80 00 2e bne 400062b4 <mq_open+0x128>
<== NEVER TAKEN
40006200: 80 8e 62 00 btst 0x200, %i1
40006204: 02 80 00 2c be 400062b4 <mq_open+0x128>
<== NEVER TAKEN
40006208: 82 07 a0 4c add %fp, 0x4c, %g1
va_start( ap, oflag );
4000620c: c2 27 bf fc st %g1, [ %fp + -4 ]
attr = va_arg( ap, const struct mq_attr * );
40006210: f8 07 a0 50 ld [ %fp + 0x50 ], %i4
if ( attr == NULL ) {
40006214: 80 a7 20 00 cmp %i4, 0
40006218: 22 80 00 48 be,a 40006338 <mq_open+0x1ac>
<== NEVER TAKEN
4000621c: 39 10 00 44 sethi %hi(0x40011000), %i4
<== NOT EXECUTED
if ( attr->mq_maxmsg <= 0 ){
40006220: c2 07 20 04 ld [ %i4 + 4 ], %g1 ! 40011004 <IMFS_link_handlers+0x34>
40006224: 80 a0 60 00 cmp %g1, 0
40006228: 04 80 00 36 ble 40006300 <mq_open+0x174>
<== NEVER TAKEN
4000622c: f4 07 bf f4 ld [ %fp + -12 ], %i2
if ( attr->mq_msgsize <= 0 ){
40006230: c2 07 20 08 ld [ %i4 + 8 ], %g1
40006234: 80 a0 60 00 cmp %g1, 0
40006238: 04 80 00 32 ble 40006300 <mq_open+0x174>
<== NEVER TAKEN
4000623c: 01 00 00 00 nop
return (POSIX_Message_queue_Control *)
40006240: 40 00 0c 51 call 40009384 <_Objects_Allocate_unprotected>
40006244: 90 16 e1 08 or %i3, 0x108, %o0
if ( !the_mq ) {
40006248: ba 92 20 00 orcc %o0, 0, %i5
4000624c: 02 80 00 3e be 40006344 <mq_open+0x1b8>
<== NEVER TAKEN
40006250: 92 10 00 1a mov %i2, %o1
name = _Workspace_String_duplicate( name_arg, name_len );
40006254: 40 00 1c f2 call 4000d61c <_Workspace_String_duplicate>
40006258: 90 10 00 18 mov %i0, %o0
if ( !name ) {
4000625c: b4 92 20 00 orcc %o0, 0, %i2
40006260: 02 80 00 3e be 40006358 <mq_open+0x1cc>
<== NEVER TAKEN
40006264: 82 10 20 01 mov 1, %g1
the_mq->open_count = 1;
40006268: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
!_CORE_message_queue_Initialize(
4000626c: 92 10 20 00 clr %o1
the_mq->linked = true;
40006270: c2 2f 60 4c stb %g1, [ %i5 + 0x4c ]
!_CORE_message_queue_Initialize(
40006274: 90 07 60 10 add %i5, 0x10, %o0
the_mq->oflag = oflag;
40006278: f2 27 60 68 st %i1, [ %i5 + 0x68 ]
!_CORE_message_queue_Initialize(
4000627c: d6 07 20 08 ld [ %i4 + 8 ], %o3
40006280: 40 00 05 6d call 40007834 <_CORE_message_queue_Initialize>
40006284: d4 07 20 04 ld [ %i4 + 4 ], %o2
if (
40006288: 80 a2 20 00 cmp %o0, 0
4000628c: 02 80 00 22 be 40006314 <mq_open+0x188>
<== NEVER TAKEN
40006290: 92 10 00 1d mov %i5, %o1
information->local_table[ index ] = the_object;
40006294: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
the_object->name.name_p = name;
40006298: f4 27 60 0c st %i2, [ %i5 + 0xc ]
information->local_table[ index ] = the_object;
4000629c: b6 16 e1 08 or %i3, 0x108, %i3
400062a0: c4 06 e0 1c ld [ %i3 + 0x1c ], %g2
400062a4: f0 07 60 08 ld [ %i5 + 8 ], %i0
400062a8: 83 28 60 02 sll %g1, 2, %g1
400062ac: 10 bf ff cf b 400061e8 <mq_open+0x5c>
400062b0: fa 20 80 01 st %i5, [ %g2 + %g1 ]
_RTEMS_Unlock_allocator();
400062b4: 40 00 05 0b call 400076e0 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
400062b8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_set_errno_and_return_value(
400062bc: 40 00 24 a7 call 4000f558 <__errno>
<== NOT EXECUTED
400062c0: 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 ];
400062c4: bb 2f 60 02 sll %i5, 2, %i5
<== NOT EXECUTED
400062c8: 03 10 00 44 sethi %hi(0x40011000), %g1
<== NOT EXECUTED
400062cc: 82 10 62 10 or %g1, 0x210, %g1 ! 40011210 <_POSIX_Get_by_name_error_table>
<== NOT EXECUTED
400062d0: c2 00 40 1d ld [ %g1 + %i5 ], %g1
<== NOT EXECUTED
400062d4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400062d8: 81 c7 e0 08 ret
<== NOT EXECUTED
400062dc: 81 e8 00 00 restore
<== NOT EXECUTED
400062e0: 40 00 05 00 call 400076e0 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
400062e4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_set_errno_and_return_value( EEXIST, MQ_OPEN_FAILED );
400062e8: 40 00 24 9c call 4000f558 <__errno>
<== NOT EXECUTED
400062ec: 01 00 00 00 nop
<== NOT EXECUTED
400062f0: 82 10 20 11 mov 0x11, %g1 ! 11 <_TLS_Alignment+0x10>
<== 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
rtems_set_errno_and_return_value( EINVAL, MQ_OPEN_FAILED );
40006300: 40 00 24 96 call 4000f558 <__errno>
<== NOT EXECUTED
40006304: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006308: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4000630c: 10 bf ff b7 b 400061e8 <mq_open+0x5c>
<== NOT EXECUTED
40006310: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
_Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object );
40006314: 40 00 0d 1c call 40009784 <_Objects_Free>
<== NOT EXECUTED
40006318: 90 16 e1 08 or %i3, 0x108, %o0
<== NOT EXECUTED
_Workspace_Free( name );
4000631c: 40 00 1c ab call 4000d5c8 <_Workspace_Free>
<== NOT EXECUTED
40006320: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
rtems_set_errno_and_return_value( ENOSPC, MQ_OPEN_FAILED );
40006324: 40 00 24 8d call 4000f558 <__errno>
<== NOT EXECUTED
40006328: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000632c: 82 10 20 1c mov 0x1c, %g1
<== NOT EXECUTED
40006330: 10 bf ff ae b 400061e8 <mq_open+0x5c>
<== NOT EXECUTED
40006334: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
status = _POSIX_Message_queue_Create( name, name_len, oflag, attr );
40006338: f4 07 bf f4 ld [ %fp + -12 ], %i2
<== NOT EXECUTED
attr = &_POSIX_Message_queue_Default_attributes;
4000633c: 10 bf ff c1 b 40006240 <mq_open+0xb4>
<== NOT EXECUTED
40006340: b8 17 22 00 or %i4, 0x200, %i4
<== NOT EXECUTED
rtems_set_errno_and_return_value( ENFILE, MQ_OPEN_FAILED );
40006344: 40 00 24 85 call 4000f558 <__errno>
<== NOT EXECUTED
40006348: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000634c: 82 10 20 17 mov 0x17, %g1
<== NOT EXECUTED
40006350: 10 bf ff a6 b 400061e8 <mq_open+0x5c>
<== NOT EXECUTED
40006354: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006358: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000635c: 40 00 0d 0a call 40009784 <_Objects_Free>
<== NOT EXECUTED
40006360: 90 16 e1 08 or %i3, 0x108, %o0
<== NOT EXECUTED
rtems_set_errno_and_return_value( ENOMEM, MQ_OPEN_FAILED );
40006364: 40 00 24 7d call 4000f558 <__errno>
<== NOT EXECUTED
40006368: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000636c: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40006370: 10 bf ff 9e b 400061e8 <mq_open+0x5c>
<== NOT EXECUTED
40006374: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40010774 <nanosleep>:
{
40010774: 9d e3 bf a0 save %sp, -96, %sp
40010778: 92 10 20 00 clr %o1
4001077c: 94 10 00 18 mov %i0, %o2
40010780: 96 10 00 19 mov %i1, %o3
40010784: 7f ff ff 8e call 400105bc <clock_nanosleep.part.6>
40010788: 90 10 20 01 mov 1, %o0
if ( eno != 0 ) {
4001078c: b0 92 20 00 orcc %o0, 0, %i0
40010790: 12 80 00 04 bne 400107a0 <nanosleep+0x2c>
<== NEVER TAKEN
40010794: 01 00 00 00 nop
}
40010798: 81 c7 e0 08 ret
4001079c: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( eno );
400107a0: 7f ff fa dc call 4000f310 <__errno>
<== NOT EXECUTED
400107a4: 01 00 00 00 nop
<== NOT EXECUTED
400107a8: f0 22 00 00 st %i0, [ %o0 ]
<== NOT EXECUTED
}
400107ac: 81 c7 e0 08 ret
<== NOT EXECUTED
400107b0: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
4000ea30 <pthread_attr_init>:
* 16.1.1 Thread Creation Attributes, P1003.1c/Draft 10, p, 140
*/
int pthread_attr_init(
pthread_attr_t *attr
)
{
4000ea30: 9d e3 bf a0 save %sp, -96, %sp
if ( !attr )
4000ea34: 82 96 20 00 orcc %i0, 0, %g1
4000ea38: 02 80 00 0b be 4000ea64 <pthread_attr_init+0x34>
<== NEVER TAKEN
4000ea3c: 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;
4000ea40: 90 10 00 01 mov %g1, %o0
4000ea44: 13 10 00 4d sethi %hi(0x40013400), %o1
return EINVAL;
_POSIX_Threads_Initialize_attributes( attr );
return 0;
4000ea48: b0 10 20 00 clr %i0
4000ea4c: 40 00 05 e2 call 400101d4 <memcpy>
4000ea50: 92 12 61 c8 or %o1, 0x1c8, %o1
_Assert(
dst_attr->affinitysetsize == sizeof(dst_attr->affinitysetpreallocated)
);
dst_attr->affinityset = &dst_attr->affinitysetpreallocated;
4000ea54: 84 02 20 5c add %o0, 0x5c, %g2
4000ea58: c4 22 20 58 st %g2, [ %o0 + 0x58 ]
4000ea5c: 81 c7 e0 08 ret
4000ea60: 81 e8 00 00 restore
}
4000ea64: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ea68: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
4000ea6c <pthread_attr_setinheritsched>:
int pthread_attr_setinheritsched(
pthread_attr_t *attr,
int inheritsched
)
{
if ( !attr || !attr->is_initialized )
4000ea6c: 82 92 20 00 orcc %o0, 0, %g1
4000ea70: 02 80 00 0c be 4000eaa0 <pthread_attr_setinheritsched+0x34>
<== NEVER TAKEN
4000ea74: 90 10 20 16 mov 0x16, %o0
4000ea78: c4 00 40 00 ld [ %g1 ], %g2
4000ea7c: 80 a0 a0 00 cmp %g2, 0
4000ea80: 02 80 00 08 be 4000eaa0 <pthread_attr_setinheritsched+0x34>
<== NEVER TAKEN
4000ea84: 84 02 7f ff add %o1, -1, %g2
return EINVAL;
switch ( inheritsched ) {
4000ea88: 80 a0 a0 01 cmp %g2, 1
4000ea8c: 18 80 00 05 bgu 4000eaa0 <pthread_attr_setinheritsched+0x34>
<== NEVER TAKEN
4000ea90: 90 10 20 86 mov 0x86, %o0
case PTHREAD_INHERIT_SCHED:
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
4000ea94: d2 20 60 10 st %o1, [ %g1 + 0x10 ]
return 0;
4000ea98: 81 c3 e0 08 retl
4000ea9c: 90 10 20 00 clr %o0
default:
return ENOTSUP;
}
}
4000eaa0: 81 c3 e0 08 retl
<== NOT EXECUTED
4000eaa4: 01 00 00 00 nop
<== NOT EXECUTED
4000eaa8 <pthread_attr_setstacksize>:
int pthread_attr_setstacksize(
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
4000eaa8: 82 92 20 00 orcc %o0, 0, %g1
4000eaac: 02 80 00 09 be 4000ead0 <pthread_attr_setstacksize+0x28>
<== NEVER TAKEN
4000eab0: 90 10 20 16 mov 0x16, %o0
4000eab4: c4 00 40 00 ld [ %g1 ], %g2
4000eab8: 80 a0 a0 00 cmp %g2, 0
4000eabc: 02 80 00 05 be 4000ead0 <pthread_attr_setstacksize+0x28>
<== NEVER TAKEN
4000eac0: 01 00 00 00 nop
return EINVAL;
attr->stacksize = stacksize;
4000eac4: d2 20 60 08 st %o1, [ %g1 + 8 ]
return 0;
4000eac8: 81 c3 e0 08 retl
4000eacc: 90 10 20 00 clr %o0
}
4000ead0: 81 c3 e0 08 retl
<== NOT EXECUTED
4000ead4: 01 00 00 00 nop
<== NOT EXECUTED
4000f3fc <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
4000f3fc: 9d e3 bf 20 save %sp, -224, %sp
Thread_Entry_information entry = {
4000f400: 03 10 00 42 sethi %hi(0x40010800), %g1
4000f404: 82 10 60 00 mov %g1, %g1 ! 40010800 <_Thread_Entry_adaptor_pointer>
4000f408: f4 27 bf c8 st %i2, [ %fp + -56 ]
size_t stacksize;
Objects_Name name;
int error;
ISR_lock_Context lock_context;
if ( !start_routine )
4000f40c: 80 a6 a0 00 cmp %i2, 0
Thread_Entry_information entry = {
4000f410: c2 27 bf c4 st %g1, [ %fp + -60 ]
int schedpolicy = SCHED_RR;
4000f414: 82 10 20 02 mov 2, %g1
Thread_Entry_information entry = {
4000f418: f6 27 bf cc st %i3, [ %fp + -52 ]
if ( !start_routine )
4000f41c: 02 80 00 b0 be 4000f6dc <pthread_create+0x2e0>
<== NEVER TAKEN
4000f420: c2 27 bf bc st %g1, [ %fp + -68 ]
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
4000f424: 80 a6 60 00 cmp %i1, 0
4000f428: 22 80 00 a5 be,a 4000f6bc <pthread_create+0x2c0>
4000f42c: 33 10 00 4b sethi %hi(0x40012c00), %i1
if ( !the_attr->is_initialized )
4000f430: c2 06 40 00 ld [ %i1 ], %g1
4000f434: 80 a0 60 00 cmp %g1, 0
4000f438: 02 80 00 9e be 4000f6b0 <pthread_create+0x2b4>
<== NEVER TAKEN
4000f43c: 03 10 00 50 sethi %hi(0x40014000), %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 ) {
4000f440: c4 06 60 04 ld [ %i1 + 4 ], %g2
4000f444: e6 06 60 08 ld [ %i1 + 8 ], %l3
4000f448: 80 a0 a0 00 cmp %g2, 0
4000f44c: 02 80 00 9e be 4000f6c4 <pthread_create+0x2c8>
<== ALWAYS TAKEN
4000f450: c2 00 60 c0 ld [ %g1 + 0xc0 ], %g1
if ( !_Stack_Is_enough(the_attr->stacksize) ) {
4000f454: 80 a0 40 13 cmp %g1, %l3
<== NOT EXECUTED
4000f458: 18 80 00 97 bgu 4000f6b4 <pthread_create+0x2b8>
<== NOT EXECUTED
4000f45c: 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 ) {
4000f460: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000f464: 80 a0 60 01 cmp %g1, 1
4000f468: 02 80 00 a1 be 4000f6ec <pthread_create+0x2f0>
4000f46c: e4 01 a0 20 ld [ %g6 + 0x20 ], %l2
4000f470: 80 a0 60 02 cmp %g1, 2
4000f474: 12 80 00 90 bne 4000f6b4 <pthread_create+0x2b8>
<== NEVER TAKEN
4000f478: a0 10 20 16 mov 0x16, %l0
);
_Assert( error == 0 );
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
4000f47c: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
schedparam = the_attr->schedparam;
4000f480: d4 1e 60 18 ldd [ %i1 + 0x18 ], %o2
4000f484: f4 1e 60 20 ldd [ %i1 + 0x20 ], %i2
4000f488: f8 1e 60 28 ldd [ %i1 + 0x28 ], %i4
4000f48c: c4 1e 60 30 ldd [ %i1 + 0x30 ], %g2
4000f490: d0 1e 60 38 ldd [ %i1 + 0x38 ], %o0
4000f494: e0 1e 60 40 ldd [ %i1 + 0x40 ], %l0
schedpolicy = the_attr->schedpolicy;
4000f498: c2 27 bf bc st %g1, [ %fp + -68 ]
schedparam = the_attr->schedparam;
4000f49c: d4 3f bf d0 std %o2, [ %fp + -48 ]
4000f4a0: f4 3f bf d8 std %i2, [ %fp + -40 ]
4000f4a4: f8 3f bf e0 std %i4, [ %fp + -32 ]
4000f4a8: c4 3f bf e8 std %g2, [ %fp + -24 ]
4000f4ac: d0 3f bf f0 std %o0, [ %fp + -16 ]
4000f4b0: 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;
4000f4b4: a0 10 20 86 mov 0x86, %l0
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
4000f4b8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000f4bc: 80 a0 60 00 cmp %g1, 0
4000f4c0: 12 80 00 7d bne 4000f6b4 <pthread_create+0x2b8>
<== NEVER TAKEN
4000f4c4: d0 07 bf bc ld [ %fp + -68 ], %o0
error = _POSIX_Thread_Translate_sched_param(
4000f4c8: 96 07 bf b8 add %fp, -72, %o3
4000f4cc: 94 07 bf b4 add %fp, -76, %o2
4000f4d0: 40 00 06 41 call 40010dd4 <_POSIX_Thread_Translate_sched_param>
4000f4d4: 92 07 bf d0 add %fp, -48, %o1
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( error != 0 ) {
4000f4d8: a0 92 20 00 orcc %o0, 0, %l0
4000f4dc: 32 80 00 82 bne,a 4000f6e4 <pthread_create+0x2e8>
<== NEVER TAKEN
4000f4e0: b0 10 00 10 mov %l0, %i0
<== NOT EXECUTED
return error;
}
normal_prio = schedparam.sched_priority;
4000f4e4: 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 );
4000f4e8: 92 10 00 1b mov %i3, %o1
4000f4ec: 94 07 bf b3 add %fp, -77, %o2
4000f4f0: 29 10 00 49 sethi %hi(0x40012400), %l4
4000f4f4: 40 00 06 07 call 40010d10 <_POSIX_Priority_To_core>
4000f4f8: 90 15 21 a0 or %l4, 0x1a0, %o0 ! 400125a0 <_Scheduler_Table>
if ( !valid ) {
4000f4fc: c2 0f bf b3 ldub [ %fp + -77 ], %g1
core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );
4000f500: b8 10 00 08 mov %o0, %i4
if ( !valid ) {
4000f504: 80 a0 60 00 cmp %g1, 0
4000f508: 02 80 00 6a be 4000f6b0 <pthread_create+0x2b4>
<== NEVER TAKEN
4000f50c: ba 10 00 09 mov %o1, %i5
return EINVAL;
}
if ( schedpolicy == SCHED_SPORADIC ) {
4000f510: c2 07 bf bc ld [ %fp + -68 ], %g1
4000f514: 80 a0 60 04 cmp %g1, 4
4000f518: 22 80 00 02 be,a 4000f520 <pthread_create+0x124>
<== NEVER TAKEN
4000f51c: 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 );
4000f520: 92 10 00 1b mov %i3, %o1
4000f524: 94 07 bf b3 add %fp, -77, %o2
4000f528: 40 00 05 fa call 40010d10 <_POSIX_Priority_To_core>
4000f52c: 90 15 21 a0 or %l4, 0x1a0, %o0
if ( !valid ) {
4000f530: c2 0f bf b3 ldub [ %fp + -77 ], %g1
core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid );
4000f534: b4 10 00 08 mov %o0, %i2
if ( !valid ) {
4000f538: 80 a0 60 00 cmp %g1, 0
4000f53c: 02 80 00 5d be 4000f6b0 <pthread_create+0x2b4>
<== NEVER TAKEN
4000f540: b6 10 00 09 mov %o1, %i3
return EINVAL;
}
if ( the_attr->affinityset == NULL ) {
4000f544: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
4000f548: 80 a0 60 00 cmp %g1, 0
4000f54c: 22 80 00 5a be,a 4000f6b4 <pthread_create+0x2b8>
<== NEVER TAKEN
4000f550: a0 10 20 16 mov 0x16, %l0
<== NOT EXECUTED
_RTEMS_Lock_allocator();
4000f554: 7f ff e0 d1 call 40007898 <_RTEMS_Lock_allocator>
4000f558: 2b 10 00 57 sethi %hi(0x40015c00), %l5
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate(void)
{
_Objects_Allocator_lock();
_Thread_Kill_zombies();
4000f55c: 7f ff f5 8f call 4000cb98 <_Thread_Kill_zombies>
4000f560: 01 00 00 00 nop
return (Thread_Control *)
4000f564: 7f ff e8 fa call 4000994c <_Objects_Allocate_unprotected>
4000f568: 90 15 62 88 or %l5, 0x288, %o0
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
4000f56c: a2 92 20 00 orcc %o0, 0, %l1
4000f570: 02 80 00 66 be 4000f708 <pthread_create+0x30c>
4000f574: 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(
4000f578: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
4000f57c: 9a 10 20 01 mov 1, %o5
4000f580: c2 07 bf b8 ld [ %fp + -72 ], %g1
4000f584: f8 3f bf a0 std %i4, [ %fp + -96 ]
4000f588: 98 10 00 13 mov %l3, %o4
4000f58c: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
4000f590: 94 15 21 a0 or %l4, 0x1a0, %o2
4000f594: c2 07 bf b4 ld [ %fp + -76 ], %g1
4000f598: c2 23 a0 68 st %g1, [ %sp + 0x68 ]
4000f59c: 82 10 20 01 mov 1, %g1
4000f5a0: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
4000f5a4: 92 10 00 11 mov %l1, %o1
4000f5a8: c2 07 bf a0 ld [ %fp + -96 ], %g1
4000f5ac: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000f5b0: 90 15 62 88 or %l5, 0x288, %o0
4000f5b4: c2 07 bf a4 ld [ %fp + -92 ], %g1
4000f5b8: c0 27 bf ac clr [ %fp + -84 ]
4000f5bc: c0 23 a0 70 clr [ %sp + 0x70 ]
4000f5c0: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
4000f5c4: 7f ff ef e3 call 4000b550 <_Thread_Initialize>
4000f5c8: 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 ) {
4000f5cc: 80 a2 20 00 cmp %o0, 0
4000f5d0: 02 80 00 52 be 4000f718 <pthread_create+0x31c>
<== NEVER TAKEN
4000f5d4: 92 10 00 11 mov %l1, %o1
_POSIX_Threads_Free( the_thread );
_Objects_Allocator_unlock();
return EAGAIN;
}
if ( the_attr->detachstate == PTHREAD_CREATE_DETACHED ) {
4000f5d8: c4 06 60 50 ld [ %i1 + 0x50 ], %g2
4000f5dc: 80 a0 a0 00 cmp %g2, 0
4000f5e0: 12 80 00 03 bne 4000f5ec <pthread_create+0x1f0>
<== ALWAYS TAKEN
4000f5e4: c2 04 61 70 ld [ %l1 + 0x170 ], %g1
the_thread->Life.state |= THREAD_LIFE_DETACHED;
4000f5e8: 82 10 60 10 or %g1, 0x10, %g1
<== NOT EXECUTED
}
the_thread->Life.state |= THREAD_LIFE_CHANGE_DEFERRED;
4000f5ec: 82 10 60 08 or %g1, 8, %g1
<== NOT EXECUTED
4000f5f0: c2 24 61 70 st %g1, [ %l1 + 0x170 ]
<== NOT EXECUTED
4000f5f4: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &lock_context );
4000f5f8: c2 27 bf c0 st %g1, [ %fp + -64 ]
status = _Scheduler_Set_affinity(
4000f5fc: d4 06 60 58 ld [ %i1 + 0x58 ], %o2
4000f600: d2 06 60 54 ld [ %i1 + 0x54 ], %o1
4000f604: 40 00 03 76 call 400103dc <_Scheduler_Set_affinity>
4000f608: 90 10 00 11 mov %l1, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f60c: c2 07 bf c0 ld [ %fp + -64 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f610: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f614: 01 00 00 00 nop
the_thread,
the_attr->affinitysetsize,
the_attr->affinityset
);
_ISR_lock_ISR_enable( &lock_context );
if ( !status ) {
4000f618: 80 a2 20 00 cmp %o0, 0
4000f61c: 02 80 00 45 be 4000f730 <pthread_create+0x334>
<== NEVER TAKEN
4000f620: 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;
4000f624: c2 04 a1 5c ld [ %l2 + 0x15c ], %g1
4000f628: c4 00 60 68 ld [ %g1 + 0x68 ], %g2
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000f62c: d0 04 61 5c ld [ %l1 + 0x15c ], %o0
the_thread->was_created_with_inherited_scheduler =
( the_attr->inheritsched == PTHREAD_INHERIT_SCHED );
4000f630: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000f634: 82 18 60 01 xor %g1, 1, %g1
api->signals_unblocked = executing_api->signals_unblocked;
4000f638: c4 22 20 68 st %g2, [ %o0 + 0x68 ]
( the_attr->inheritsched == PTHREAD_INHERIT_SCHED );
4000f63c: 80 a0 00 01 cmp %g0, %g1
4000f640: 82 60 3f ff subx %g0, -1, %g1
4000f644: c2 2c 60 8b stb %g1, [ %l1 + 0x8b ]
4000f648: 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 =
4000f64c: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
api->Sporadic.sched_ss_repl_period =
4000f650: f4 1e 60 20 ldd [ %i1 + 0x20 ], %i2
4000f654: f8 1e 60 28 ldd [ %i1 + 0x28 ], %i4
api->Sporadic.sched_ss_init_budget =
4000f658: c4 1e 60 30 ldd [ %i1 + 0x30 ], %g2
4000f65c: d8 1e 60 38 ldd [ %i1 + 0x38 ], %o4
4000f660: d8 3a 20 58 std %o4, [ %o0 + 0x58 ]
api->Sporadic.sched_ss_max_repl =
4000f664: c2 22 20 60 st %g1, [ %o0 + 0x60 ]
api->Sporadic.sched_ss_repl_period =
4000f668: f4 3a 20 40 std %i2, [ %o0 + 0x40 ]
4000f66c: f8 3a 20 48 std %i4, [ %o0 + 0x48 ]
api->Sporadic.sched_ss_init_budget =
4000f670: c4 3a 20 50 std %g2, [ %o0 + 0x50 ]
the_attr->schedparam.sched_ss_max_repl;
if ( schedpolicy == SCHED_SPORADIC ) {
4000f674: c2 07 bf bc ld [ %fp + -68 ], %g1
4000f678: 80 a0 60 04 cmp %g1, 4
4000f67c: 02 80 00 33 be 4000f748 <pthread_create+0x34c>
<== NEVER TAKEN
4000f680: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000f684: 91 d0 20 09 ta 9
<== NOT EXECUTED
}
/*
* POSIX threads are allocated and started in one operation.
*/
_ISR_lock_ISR_disable( &lock_context );
4000f688: c2 27 bf c0 st %g1, [ %fp + -64 ]
status = _Thread_Start( the_thread, &entry, &lock_context );
4000f68c: 94 07 bf c0 add %fp, -64, %o2
4000f690: 92 07 bf c4 add %fp, -60, %o1
4000f694: 7f ff f6 92 call 4000d0dc <_Thread_Start>
4000f698: 90 10 00 11 mov %l1, %o0
#endif
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
4000f69c: c2 04 60 08 ld [ %l1 + 8 ], %g1
_RTEMS_Unlock_allocator();
4000f6a0: 7f ff e0 83 call 400078ac <_RTEMS_Unlock_allocator>
4000f6a4: c2 26 00 00 st %g1, [ %i0 ]
_Objects_Allocator_unlock();
return 0;
4000f6a8: 81 c7 e0 08 ret
4000f6ac: 91 e8 00 10 restore %g0, %l0, %o0
return EINVAL;
4000f6b0: a0 10 20 16 mov 0x16, %l0
<== NOT EXECUTED
}
4000f6b4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f6b8: 91 e8 00 10 restore %g0, %l0, %o0
<== NOT EXECUTED
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
4000f6bc: 10 bf ff 5d b 4000f430 <pthread_create+0x34>
4000f6c0: b2 16 62 80 or %i1, 0x280, %i1
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
4000f6c4: 83 28 60 01 sll %g1, 1, %g1
4000f6c8: 80 a4 c0 01 cmp %l3, %g1
4000f6cc: 2a bf ff 65 bcs,a 4000f460 <pthread_create+0x64>
4000f6d0: a6 10 00 01 mov %g1, %l3
switch ( the_attr->inheritsched ) {
4000f6d4: 10 bf ff 64 b 4000f464 <pthread_create+0x68>
4000f6d8: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
return EFAULT;
4000f6dc: a0 10 20 0e mov 0xe, %l0
<== NOT EXECUTED
}
4000f6e0: b0 10 00 10 mov %l0, %i0
<== NOT EXECUTED
4000f6e4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f6e8: 81 e8 00 00 restore
<== NOT EXECUTED
error = pthread_getschedparam(
4000f6ec: 40 00 01 4b call 4000fc18 <pthread_self>
4000f6f0: a0 10 20 86 mov 0x86, %l0
4000f6f4: 94 07 bf d0 add %fp, -48, %o2
4000f6f8: 40 00 00 51 call 4000f83c <pthread_getschedparam>
4000f6fc: 92 07 bf bc add %fp, -68, %o1
break;
4000f700: 10 bf ff 6f b 4000f4bc <pthread_create+0xc0>
4000f704: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000f708: 7f ff e0 69 call 400078ac <_RTEMS_Unlock_allocator>
4000f70c: a0 10 20 0b mov 0xb, %l0
return EAGAIN;
4000f710: 81 c7 e0 08 ret
4000f714: 91 e8 00 10 restore %g0, %l0, %o0
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information.Objects, &the_pthread->Object );
4000f718: 90 15 62 88 or %l5, 0x288, %o0
<== NOT EXECUTED
4000f71c: 7f ff e9 8c call 40009d4c <_Objects_Free>
<== NOT EXECUTED
4000f720: a0 10 20 0b mov 0xb, %l0
<== NOT EXECUTED
4000f724: 7f ff e0 62 call 400078ac <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000f728: b0 10 00 10 mov %l0, %i0
<== NOT EXECUTED
return EAGAIN;
4000f72c: 30 bf ff ee b,a 4000f6e4 <pthread_create+0x2e8>
<== NOT EXECUTED
4000f730: 90 15 62 88 or %l5, 0x288, %o0
<== NOT EXECUTED
4000f734: 7f ff e9 86 call 40009d4c <_Objects_Free>
<== NOT EXECUTED
4000f738: a0 10 20 16 mov 0x16, %l0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
4000f73c: 7f ff e0 5c call 400078ac <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000f740: b0 10 00 10 mov %l0, %i0
<== NOT EXECUTED
return EINVAL;
4000f744: 30 bf ff e8 b,a 4000f6e4 <pthread_create+0x2e8>
<== NOT EXECUTED
_POSIX_Threads_Sporadic_timer( &api->Sporadic.Timer );
4000f748: 40 00 00 dd call 4000fabc <_POSIX_Threads_Sporadic_timer>
<== NOT EXECUTED
4000f74c: 90 02 20 08 add %o0, 8, %o0
<== NOT EXECUTED
4000f750: 30 bf ff cd b,a 4000f684 <pthread_create+0x288>
<== NOT EXECUTED
4000f754 <pthread_detach>:
/**
* 16.1.4 Detaching a Thread, P1003.1c/Draft 10, p. 149
*/
int pthread_detach( pthread_t thread )
{
4000f754: 9d e3 bf 90 save %sp, -112, %sp
Thread_Control *the_thread;
ISR_lock_Context lock_context;
Per_CPU_Control *cpu_self;
the_thread = _Thread_Get( thread, &lock_context );
4000f758: 90 10 00 18 mov %i0, %o0
4000f75c: 92 07 bf fc add %fp, -4, %o1
4000f760: 7f ff ef 3f call 4000b45c <_Thread_Get>
4000f764: b0 10 20 03 mov 3, %i0
if ( the_thread == NULL ) {
4000f768: 80 a2 20 00 cmp %o0, 0
4000f76c: 02 80 00 14 be 4000f7bc <pthread_detach+0x68>
4000f770: 01 00 00 00 nop
return ESRCH;
}
_Thread_State_acquire_critical( the_thread, &lock_context );
the_thread->Life.state |= THREAD_LIFE_DETACHED;
4000f774: c4 02 21 70 ld [ %o0 + 0x170 ], %g2
4000f778: 84 10 a0 10 or %g2, 0x10, %g2
4000f77c: c4 22 21 70 st %g2, [ %o0 + 0x170 ]
_Thread_Clear_state_locked( the_thread, STATES_WAITING_FOR_JOIN_AT_EXIT );
4000f780: 7f ff ee 72 call 4000b148 <_Thread_Clear_state_locked>
4000f784: 13 00 00 08 sethi %hi(0x2000), %o1
disable_level = cpu_self->thread_dispatch_disable_level;
4000f788: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000f78c: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000f790: 90 10 00 06 mov %g6, %o0
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000f794: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f798: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f79c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f7a0: 01 00 00 00 nop
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000f7a4: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
if ( disable_level == 1 ) {
4000f7a8: 80 a0 60 01 cmp %g1, 1
4000f7ac: 02 80 00 06 be 4000f7c4 <pthread_detach+0x70>
<== ALWAYS TAKEN
4000f7b0: 82 00 7f ff add %g1, -1, %g1
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000f7b4: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
_Thread_State_release( the_thread, &lock_context );
_Thread_Dispatch_enable( cpu_self );
return 0;
4000f7b8: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000f7bc: 81 c7 e0 08 ret
4000f7c0: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000f7c4: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000f7c8: c4 09 a0 1c ldub [ %g6 + 0x1c ], %g2
4000f7cc: 80 a0 a0 00 cmp %g2, 0
4000f7d0: 12 80 00 07 bne 4000f7ec <pthread_detach+0x98>
<== NEVER TAKEN
4000f7d4: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4000f7d8: c0 21 a0 18 clr [ %g6 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f7dc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f7e0: 01 00 00 00 nop
return 0;
4000f7e4: 81 c7 e0 08 ret
4000f7e8: 91 e8 20 00 restore %g0, 0, %o0
_Thread_Do_dispatch( cpu_self, level );
4000f7ec: 7f ff ee bd call 4000b2e0 <_Thread_Do_dispatch>
<== NOT EXECUTED
4000f7f0: c2 27 bf f4 st %g1, [ %fp + -12 ]
<== NOT EXECUTED
4000f7f4: 10 bf ff fa b 4000f7dc <pthread_detach+0x88>
<== NOT EXECUTED
4000f7f8: c2 07 bf f4 ld [ %fp + -12 ], %g1
<== NOT EXECUTED
4000f80c <pthread_exit>:
#include <pthread.h>
#include <rtems/score/threadimpl.h>
void pthread_exit( void *value_ptr )
{
4000f80c: 9d e3 bf a0 save %sp, -96, %sp
disable_level = cpu_self->thread_dispatch_disable_level;
4000f810: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000f814: 82 00 60 01 inc %g1
4000f818: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000f81c: 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 );
4000f820: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
4000f824: 94 10 00 18 mov %i0, %o2
4000f828: 7f ff f5 a9 call 4000cecc <_Thread_Exit>
4000f82c: 92 10 20 04 mov 4, %o1
_Thread_Dispatch_direct( cpu_self );
4000f830: 7f ff ee f4 call 4000b400 <_Thread_Dispatch_direct>
4000f834: 90 10 00 1d mov %i5, %o0
4000f838: 01 00 00 00 nop
<== NOT EXECUTED
400080e8 <pthread_getaffinity_np>:
int pthread_getaffinity_np(
pthread_t thread,
size_t cpusetsize,
cpu_set_t *cpuset
)
{
400080e8: 9d e3 bf 90 save %sp, -112, %sp
Thread_Control *the_thread;
ISR_lock_Context lock_context;
Per_CPU_Control *cpu_self;
bool ok;
if ( cpuset == NULL ) {
400080ec: 80 a6 a0 00 cmp %i2, 0
400080f0: 02 80 00 1c be 40008160 <pthread_getaffinity_np+0x78>
400080f4: 82 10 20 0e mov 0xe, %g1
return EFAULT;
}
the_thread = _Thread_Get( thread, &lock_context );
400080f8: 92 07 bf fc add %fp, -4, %o1
400080fc: 40 00 16 bf call 4000dbf8 <_Thread_Get>
40008100: 90 10 00 18 mov %i0, %o0
if ( the_thread == NULL ) {
40008104: 80 a2 20 00 cmp %o0, 0
40008108: 02 80 00 16 be 40008160 <pthread_getaffinity_np+0x78>
4000810c: 82 10 20 03 mov 3, %g1
const ISR_lock_Context *lock_context
)
{
uint32_t disable_level;
disable_level = cpu_self->thread_dispatch_disable_level;
40008110: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
_Profiling_Thread_dispatch_disable_critical(
cpu_self,
disable_level,
lock_context
);
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40008114: 82 00 60 01 inc %g1
40008118: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
*/
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 );
4000811c: ba 10 00 06 mov %g6, %i5
}
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
_Thread_State_acquire_critical( the_thread, &lock_context );
ok = _Scheduler_Get_affinity(
40008120: 94 10 00 1a mov %i2, %o2
40008124: 40 00 13 2a call 4000cdcc <_Scheduler_Get_affinity>
40008128: 92 10 00 19 mov %i1, %o1
4000812c: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008130: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008134: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008138: 01 00 00 00 nop
*
* @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;
4000813c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
if ( disable_level == 1 ) {
40008140: 80 a0 60 01 cmp %g1, 1
40008144: 02 80 00 09 be 40008168 <pthread_getaffinity_np+0x80>
<== ALWAYS TAKEN
40008148: 82 00 7f ff add %g1, -1, %g1
}
_ISR_Local_enable( level );
} else {
_Assert( disable_level > 0 );
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000814c: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
cpuset
);
_Thread_State_release( the_thread, &lock_context );
_Thread_Dispatch_enable( cpu_self );
return ok ? 0 : EINVAL;
40008150: 80 a0 00 1c cmp %g0, %i4
<== NOT EXECUTED
40008154: 82 60 20 00 subx %g0, 0, %g1
40008158: 82 08 7f ea and %g1, -22, %g1
4000815c: 82 00 60 16 add %g1, 0x16, %g1
}
40008160: 81 c7 e0 08 ret
40008164: 91 e8 00 01 restore %g0, %g1, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008168: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000816c: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
40008170: 80 a0 a0 00 cmp %g2, 0
40008174: 32 80 00 07 bne,a 40008190 <pthread_getaffinity_np+0xa8>
<== NEVER TAKEN
40008178: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4000817c: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008180: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008184: 01 00 00 00 nop
return ok ? 0 : EINVAL;
40008188: 10 bf ff f3 b 40008154 <pthread_getaffinity_np+0x6c>
4000818c: 80 a0 00 1c cmp %g0, %i4
_Thread_Do_dispatch( cpu_self, level );
40008190: c2 27 bf f4 st %g1, [ %fp + -12 ]
<== NOT EXECUTED
40008194: 40 00 16 3a call 4000da7c <_Thread_Do_dispatch>
<== NOT EXECUTED
40008198: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000819c: 10 bf ff f9 b 40008180 <pthread_getaffinity_np+0x98>
<== NOT EXECUTED
400081a0: c2 07 bf f4 ld [ %fp + -12 ], %g1
<== NOT EXECUTED
4000f83c <pthread_getschedparam>:
int pthread_getschedparam(
pthread_t thread,
int *policy,
struct sched_param *param
)
{
4000f83c: 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 ) {
4000f840: 80 a6 60 00 cmp %i1, 0
4000f844: 02 80 00 2b be 4000f8f0 <pthread_getschedparam+0xb4>
<== NEVER TAKEN
4000f848: 80 a6 a0 00 cmp %i2, 0
4000f84c: 02 80 00 29 be 4000f8f0 <pthread_getschedparam+0xb4>
<== NEVER TAKEN
4000f850: 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 );
4000f854: 92 07 bf dc add %fp, -36, %o1
4000f858: 7f ff ef 01 call 4000b45c <_Thread_Get>
4000f85c: b0 10 20 03 mov 3, %i0
if ( the_thread == NULL ) {
4000f860: 80 a2 20 00 cmp %o0, 0
4000f864: 02 80 00 21 be 4000f8e8 <pthread_getschedparam+0xac>
<== NEVER TAKEN
4000f868: a2 10 00 08 mov %o0, %l1
4000f86c: 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(
4000f870: d4 06 e0 3c ld [ %i3 + 0x3c ], %o2
4000f874: d2 06 e0 38 ld [ %i3 + 0x38 ], %o1
4000f878: 25 10 00 49 sethi %hi(0x40012400), %l2
4000f87c: 40 00 05 42 call 40010d84 <_POSIX_Priority_From_core>
4000f880: 90 14 a1 a0 or %l2, 0x1a0, %o0 ! 400125a0 <_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;
4000f884: c4 1e e0 58 ldd [ %i3 + 0x58 ], %g2
<== NOT EXECUTED
4000f888: f8 1e e0 50 ldd [ %i3 + 0x50 ], %i4
<== NOT EXECUTED
param->sched_ss_repl_period = api->Sporadic.sched_ss_repl_period;
4000f88c: d8 1e e0 40 ldd [ %i3 + 0x40 ], %o4
<== NOT EXECUTED
4000f890: d4 1e e0 48 ldd [ %i3 + 0x48 ], %o2
<== NOT EXECUTED
param->sched_ss_max_repl = api->Sporadic.sched_ss_max_repl;
4000f894: c2 06 e0 60 ld [ %i3 + 0x60 ], %g1
<== NOT EXECUTED
4000f898: c2 26 a0 28 st %g1, [ %i2 + 0x28 ]
<== NOT EXECUTED
param->sched_ss_init_budget = api->Sporadic.sched_ss_init_budget;
4000f89c: f8 3e a0 18 std %i4, [ %i2 + 0x18 ]
<== NOT EXECUTED
4000f8a0: c4 3e a0 20 std %g2, [ %i2 + 0x20 ]
<== NOT EXECUTED
param->sched_ss_repl_period = api->Sporadic.sched_ss_repl_period;
4000f8a4: d8 3e a0 08 std %o4, [ %i2 + 8 ]
<== NOT EXECUTED
4000f8a8: d4 3e a0 10 std %o2, [ %i2 + 0x10 ]
<== NOT EXECUTED
param->sched_ss_low_priority = _POSIX_Priority_From_core(
4000f8ac: 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;
4000f8b0: c4 1c 60 30 ldd [ %l1 + 0x30 ], %g2
<== NOT EXECUTED
budget_algorithm = the_thread->budget_algorithm;
4000f8b4: fa 04 60 90 ld [ %l1 + 0x90 ], %i5
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f8b8: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f8bc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f8c0: 01 00 00 00 nop
_Thread_Wait_release( the_thread, &queue_context );
param->sched_priority = _POSIX_Priority_From_core( scheduler, priority );
4000f8c4: 92 10 00 02 mov %g2, %o1
4000f8c8: 94 10 00 03 mov %g3, %o2
4000f8cc: 40 00 05 2e call 40010d84 <_POSIX_Priority_From_core>
4000f8d0: 90 14 a1 a0 or %l2, 0x1a0, %o0
4000f8d4: d0 26 80 00 st %o0, [ %i2 ]
*policy = _POSIX_Thread_Translate_to_sched_policy( budget_algorithm );
return 0;
4000f8d8: b0 10 20 00 clr %i0
*policy = _POSIX_Thread_Translate_to_sched_policy( budget_algorithm );
4000f8dc: 40 00 05 34 call 40010dac <_POSIX_Thread_Translate_to_sched_policy>
4000f8e0: 90 10 00 1d mov %i5, %o0
4000f8e4: d0 26 40 00 st %o0, [ %i1 ]
return 0;
4000f8e8: 81 c7 e0 08 ret
4000f8ec: 81 e8 00 00 restore
return EINVAL;
4000f8f0: b0 10 20 16 mov 0x16, %i0
<== NOT EXECUTED
}
4000f8f4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f8f8: 81 e8 00 00 restore
<== NOT EXECUTED
40006774 <pthread_getspecific>:
ISR_Level level;
_ISR_Local_disable( level );
#endif
executing = _Thread_Executing;
40006774: c6 01 a0 20 ld [ %g6 + 0x20 ], %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006778: 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 );
4000677c: 86 00 e1 60 add %g3, 0x160, %g3
RBTree_Node *parent;
link = _RBTree_Root_const_reference( the_rbtree );
parent = NULL;
while ( *link != NULL ) {
40006780: c4 00 c0 00 ld [ %g3 ], %g2
40006784: 80 a0 a0 00 cmp %g2, 0
40006788: 02 80 00 0d be 400067bc <pthread_getspecific+0x48>
4000678c: 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;
40006790: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
parent = *link;
if ( ( *equal )( key, parent ) ) {
40006794: 80 a2 00 04 cmp %o0, %g4
40006798: 22 80 00 0e be,a 400067d0 <pthread_getspecific+0x5c>
<== ALWAYS TAKEN
4000679c: d0 00 e0 20 ld [ %g3 + 0x20 ], %o0
return ( *map )( parent );
} else if ( ( *less )( key, parent ) ) {
400067a0: 1a bf ff f8 bcc 40006780 <pthread_getspecific+0xc>
<== NOT EXECUTED
400067a4: 86 00 a0 04 add %g2, 4, %g3
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
400067a8: 86 10 00 02 mov %g2, %g3
<== NOT EXECUTED
while ( *link != NULL ) {
400067ac: c4 00 c0 00 ld [ %g3 ], %g2
<== NOT EXECUTED
400067b0: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
400067b4: 12 bf ff f7 bne 40006790 <pthread_getspecific+0x1c>
<== NOT EXECUTED
400067b8: 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;
400067bc: 90 10 20 00 clr %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400067c0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400067c4: 01 00 00 00 nop
}
_POSIX_Keys_Key_value_release( executing, &lock_context );
return value;
}
400067c8: 81 c3 e0 08 retl
400067cc: 01 00 00 00 nop
400067d0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400067d4: 01 00 00 00 nop
400067d8: 81 c3 e0 08 retl
400067dc: 01 00 00 00 nop
4000f8fc <pthread_join>:
return 0;
}
int pthread_join( pthread_t thread, void **value_ptr )
{
4000f8fc: 9d e3 bf 78 save %sp, -136, %sp
4000f900: 37 10 00 2e sethi %hi(0x4000b800), %i3
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_join_at_exit(
States_Control the_states
)
{
return ( the_states & STATES_WAITING_FOR_JOIN_AT_EXIT ) != 0;
4000f904: 21 00 00 08 sethi %hi(0x2000), %l0
4000f908: b6 16 e2 08 or %i3, 0x208, %i3
_Thread_Join(
4000f90c: 35 04 00 10 sethi %hi(0x10004000), %i2
the_thread = _Thread_Get( thread, &queue_context.Lock_context.Lock_context );
4000f910: 92 07 bf dc add %fp, -36, %o1
queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;
4000f914: f6 27 bf e4 st %i3, [ %fp + -28 ]
4000f918: 7f ff ee d1 call 4000b45c <_Thread_Get>
4000f91c: 90 10 00 18 mov %i0, %o0
if ( the_thread == NULL ) {
4000f920: 80 a2 20 00 cmp %o0, 0
4000f924: 02 80 00 2e be 4000f9dc <pthread_join+0xe0>
<== NEVER TAKEN
4000f928: b8 10 00 06 mov %g6, %i4
return cpu->executing;
4000f92c: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
if ( executing == the_thread ) {
4000f930: 80 a2 00 1d cmp %o0, %i5
4000f934: 02 80 00 2c be 4000f9e4 <pthread_join+0xe8>
<== NEVER TAKEN
4000f938: 01 00 00 00 nop
return ( the_thread->Life.state & THREAD_LIFE_DETACHED ) == 0;
4000f93c: c4 02 21 70 ld [ %o0 + 0x170 ], %g2
if ( !_Thread_Is_joinable( the_thread ) ) {
4000f940: 80 88 a0 10 btst 0x10, %g2
4000f944: 12 80 00 21 bne 4000f9c8 <pthread_join+0xcc>
<== NEVER TAKEN
4000f948: 96 07 bf dc add %fp, -36, %o3
4000f94c: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
_Thread_Join(
4000f950: 94 10 00 1d mov %i5, %o2
if ( _States_Is_waiting_for_join_at_exit( the_thread->current_state ) ) {
4000f954: 80 88 80 10 btst %g2, %l0
4000f958: 02 80 00 13 be 4000f9a4 <pthread_join+0xa8>
<== ALWAYS TAKEN
4000f95c: 92 10 00 1a mov %i2, %o1
value = the_thread->Life.exit_value;
4000f960: fa 02 21 78 ld [ %o0 + 0x178 ], %i5
<== NOT EXECUTED
_Thread_Clear_state_locked( the_thread, STATES_WAITING_FOR_JOIN_AT_EXIT );
4000f964: 7f ff ed f9 call 4000b148 <_Thread_Clear_state_locked>
<== NOT EXECUTED
4000f968: 13 00 00 08 sethi %hi(0x2000), %o1
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000f96c: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000f970: 82 00 60 01 inc %g1
<== NOT EXECUTED
4000f974: c2 27 20 18 st %g1, [ %i4 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f978: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f97c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f980: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Dispatch_direct( cpu_self );
4000f984: 7f ff ee 9f call 4000b400 <_Thread_Dispatch_direct>
<== NOT EXECUTED
4000f988: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
if ( value_ptr != NULL ) {
4000f98c: 80 a6 60 00 cmp %i1, 0
4000f990: 02 80 00 03 be 4000f99c <pthread_join+0xa0>
<== NEVER TAKEN
4000f994: b0 10 20 00 clr %i0
*value_ptr = value;
4000f998: fa 26 40 00 st %i5, [ %i1 ]
do {
error = _POSIX_Threads_Join( thread, value_ptr );
} while ( error == EINTR );
return error;
}
4000f99c: 81 c7 e0 08 ret
4000f9a0: 81 e8 00 00 restore
_Thread_Join(
4000f9a4: 7f ff f4 c5 call 4000ccb8 <_Thread_Join>
4000f9a8: 01 00 00 00 nop
4000f9ac: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
4000f9b0: 83 38 60 08 sra %g1, 8, %g1
if ( _POSIX_Get_error_after_wait( executing ) != 0 ) {
4000f9b4: 80 a0 60 00 cmp %g1, 0
4000f9b8: 12 bf ff d7 bne 4000f914 <pthread_join+0x18>
<== NEVER TAKEN
4000f9bc: 92 07 bf dc add %fp, -36, %o1
value = executing->Wait.return_argument;
4000f9c0: 10 bf ff f3 b 4000f98c <pthread_join+0x90>
4000f9c4: fa 07 60 40 ld [ %i5 + 0x40 ], %i5
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f9c8: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f9cc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f9d0: 01 00 00 00 nop
<== NOT EXECUTED
return EINVAL;
4000f9d4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f9d8: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
return ESRCH;
4000f9dc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f9e0: 91 e8 20 03 restore %g0, 3, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f9e4: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f9e8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f9ec: 01 00 00 00 nop
<== NOT EXECUTED
return EDEADLK;
4000f9f0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f9f4: 91 e8 20 2d restore %g0, 0x2d, %o0
<== NOT EXECUTED
4000f144 <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
)
{
4000f144: 9d e3 bf 98 save %sp, -104, %sp
_RTEMS_Lock_allocator();
4000f148: 7f ff e1 d4 call 40007898 <_RTEMS_Lock_allocator>
4000f14c: 33 10 00 56 sethi %hi(0x40015800), %i1
return (POSIX_Keys_Control *)
4000f150: 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;
4000f154: b0 10 20 16 mov 0x16, %i0
4000f158: 7f ff eb 4c call 40009e88 <_Objects_Get_no_protection>
4000f15c: 92 16 60 b8 or %i1, 0xb8, %o1
if ( the_key != NULL ) {
4000f160: 80 a2 20 00 cmp %o0, 0
4000f164: 02 80 00 24 be 4000f1f4 <pthread_key_delete+0xb0>
<== NEVER TAKEN
4000f168: b8 10 00 08 mov %o0, %i4
_Objects_Close( &_POSIX_Keys_Information, &the_key->Object );
4000f16c: 92 10 00 08 mov %o0, %o1
4000f170: 40 00 04 4c call 400102a0 <_Objects_Close>
4000f174: 90 16 60 b8 or %i1, 0xb8, %o0
return _Chain_Immutable_head( the_chain )->next;
4000f178: fa 07 20 14 ld [ %i4 + 0x14 ], %i5
return &the_chain->Tail.Node;
4000f17c: b4 07 20 18 add %i4, 0x18, %i2
while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) {
4000f180: 80 a6 80 1d cmp %i2, %i5
4000f184: 02 80 00 19 be 4000f1e8 <pthread_key_delete+0xa4>
<== ALWAYS TAKEN
4000f188: 92 10 00 1c mov %i4, %o1
4000f18c: 37 10 00 56 sethi %hi(0x40015800), %i3
<== NOT EXECUTED
_Freechain_Put( &_POSIX_Keys_Keypool, key_value_pair );
4000f190: b6 16 e0 f4 or %i3, 0xf4, %i3 ! 400158f4 <_POSIX_Keys_Keypool>
<== NOT EXECUTED
the_thread = key_value_pair->thread;
4000f194: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000f198: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000f19c: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
_RBTree_Extract(
4000f1a0: 92 07 60 08 add %i5, 8, %o1
<== NOT EXECUTED
4000f1a4: 7f ff eb f7 call 4000a180 <_RBTree_Extract>
<== NOT EXECUTED
4000f1a8: 90 02 21 60 add %o0, 0x160, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f1ac: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f1b0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f1b4: 01 00 00 00 nop
<== NOT EXECUTED
next = the_node->next;
4000f1b8: c4 07 40 00 ld [ %i5 ], %g2
<== NOT EXECUTED
previous = the_node->previous;
4000f1bc: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
next->previous = previous;
4000f1c0: c2 20 a0 04 st %g1, [ %g2 + 4 ]
<== NOT EXECUTED
4000f1c4: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
previous->next = next;
4000f1c8: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
4000f1cc: 7f ff e2 14 call 40007a1c <_Freechain_Put>
<== NOT EXECUTED
4000f1d0: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000f1d4: fa 07 20 14 ld [ %i4 + 0x14 ], %i5
<== NOT EXECUTED
while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) {
4000f1d8: 80 a7 40 1a cmp %i5, %i2
<== NOT EXECUTED
4000f1dc: 32 bf ff ef bne,a 4000f198 <pthread_key_delete+0x54>
<== NOT EXECUTED
4000f1e0: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
<== NOT EXECUTED
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
4000f1e4: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4000f1e8: 90 16 60 b8 or %i1, 0xb8, %o0
4000f1ec: 7f ff ea d8 call 40009d4c <_Objects_Free>
4000f1f0: b0 10 20 00 clr %i0
_RTEMS_Unlock_allocator();
4000f1f4: 7f ff e1 ae call 400078ac <_RTEMS_Unlock_allocator>
4000f1f8: 01 00 00 00 nop
}
_Objects_Allocator_unlock();
return eno;
}
4000f1fc: 81 c7 e0 08 ret
4000f200: 81 e8 00 00 restore
40018fdc <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 )
{
40018fdc: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
40018fe0: 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 ) ) {
40018fe4: 80 a7 60 1f cmp %i5, 0x1f
<== NOT EXECUTED
40018fe8: 18 80 00 28 bgu 40019088 <pthread_kill+0xac>
<== NOT EXECUTED
40018fec: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
return EINVAL;
}
the_thread = _Thread_Get( thread, &lock_context );
40018ff0: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
40018ff4: 7f ff c2 d6 call 40009b4c <_Thread_Get>
<== NOT EXECUTED
40018ff8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( the_thread == NULL ) {
40018ffc: 86 92 20 00 orcc %o0, 0, %g3
<== NOT EXECUTED
40019000: 02 80 00 22 be 40019088 <pthread_kill+0xac>
<== NOT EXECUTED
40019004: 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 ) {
40019008: 83 2e 60 01 sll %i1, 1, %g1
<== NOT EXECUTED
4001900c: 82 00 40 19 add %g1, %i1, %g1
<== NOT EXECUTED
40019010: 85 28 60 02 sll %g1, 2, %g2
<== NOT EXECUTED
40019014: 03 10 00 79 sethi %hi(0x4001e400), %g1
<== NOT EXECUTED
40019018: 82 10 60 50 or %g1, 0x50, %g1 ! 4001e450 <_POSIX_signals_Vectors>
<== NOT EXECUTED
4001901c: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
40019020: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
40019024: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
40019028: 02 80 00 24 be 400190b8 <pthread_kill+0xdc>
<== NOT EXECUTED
4001902c: 01 00 00 00 nop
<== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
40019030: c8 00 e1 5c ld [ %g3 + 0x15c ], %g4
<== NOT EXECUTED
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
40019034: c4 01 20 6c ld [ %g4 + 0x6c ], %g2
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
40019038: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
return 1u << (sig - 1);
4001903c: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
40019040: bb 28 c0 1d sll %g3, %i5, %i5
<== NOT EXECUTED
40019044: ba 10 80 1d or %g2, %i5, %i5
<== NOT EXECUTED
40019048: fa 21 20 6c st %i5, [ %g4 + 0x6c ]
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4001904c: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40019050: b8 10 00 06 mov %g6, %i4
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40019054: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40019058: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001905c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40019060: 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 );
40019064: 94 10 20 00 clr %o2 ! 0 <PROM_START>
<== NOT EXECUTED
40019068: 7f ff ff 6e call 40018e20 <_POSIX_signals_Unblock_thread>
<== NOT EXECUTED
4001906c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
40019070: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
40019074: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
40019078: 02 80 00 06 be 40019090 <pthread_kill+0xb4>
<== NOT EXECUTED
4001907c: 84 00 7f ff add %g1, -1, %g2
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
40019080: c4 27 20 18 st %g2, [ %i4 + 0x18 ]
<== NOT EXECUTED
_Thread_Dispatch_enable( cpu_self );
return 0;
40019084: 82 10 20 00 clr %g1
<== NOT EXECUTED
}
40019088: 81 c7 e0 08 ret
<== NOT EXECUTED
4001908c: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40019090: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
40019094: c4 0f 20 1c ldub [ %i4 + 0x1c ], %g2
<== NOT EXECUTED
40019098: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4001909c: 12 80 00 0d bne 400190d0 <pthread_kill+0xf4>
<== NOT EXECUTED
400190a0: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
400190a4: c0 27 20 18 clr [ %i4 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400190a8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400190ac: 01 00 00 00 nop
<== NOT EXECUTED
return 0;
400190b0: 10 bf ff f6 b 40019088 <pthread_kill+0xac>
<== NOT EXECUTED
400190b4: 82 10 20 00 clr %g1 ! 0 <PROM_START>
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400190b8: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400190bc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400190c0: 01 00 00 00 nop
<== NOT EXECUTED
return 0;
400190c4: 82 10 20 00 clr %g1 ! 0 <PROM_START>
<== NOT EXECUTED
}
400190c8: 81 c7 e0 08 ret
<== NOT EXECUTED
400190cc: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
400190d0: c2 27 bf f4 st %g1, [ %fp + -12 ]
<== NOT EXECUTED
400190d4: 7f ff d3 0d call 4000dd08 <_Thread_Do_dispatch>
<== NOT EXECUTED
400190d8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
400190dc: 10 bf ff f3 b 400190a8 <pthread_kill+0xcc>
<== NOT EXECUTED
400190e0: c2 07 bf f4 ld [ %fp + -12 ], %g1
<== NOT EXECUTED
40007f38 <pthread_mutex_destroy>:
*/
int pthread_mutex_destroy(
pthread_mutex_t *mutex
)
{
40007f38: 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 );
40007f3c: 80 a6 20 00 cmp %i0, 0
40007f40: 02 80 00 18 be 40007fa0 <pthread_mutex_destroy+0x68>
<== NEVER TAKEN
40007f44: 05 25 87 04 sethi %hi(0x961c1000), %g2
40007f48: c2 06 00 00 ld [ %i0 ], %g1
40007f4c: 82 1e 00 01 xor %i0, %g1, %g1
40007f50: 84 10 a3 b8 or %g2, 0x3b8, %g2
40007f54: 82 18 40 02 xor %g1, %g2, %g1
40007f58: 80 88 7f f8 btst -8, %g1
40007f5c: 12 80 00 0c bne 40007f8c <pthread_mutex_destroy+0x54>
<== NEVER TAKEN
40007f60: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007f64: 91 d0 20 09 ta 9
<== NOT EXECUTED
_POSIX_Mutex_Acquire( the_mutex, &queue_context );
if ( _POSIX_Mutex_Get_owner( the_mutex ) == NULL ) {
40007f68: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
40007f6c: 80 a0 a0 00 cmp %g2, 0
40007f70: 22 80 00 0e be,a 40007fa8 <pthread_mutex_destroy+0x70>
<== ALWAYS TAKEN
40007f74: c4 06 00 00 ld [ %i0 ], %g2
the_mutex->flags = ~the_mutex->flags;
eno = 0;
} else {
eno = EBUSY;
40007f78: b0 10 20 10 mov 0x10, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007f7c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007f80: 01 00 00 00 nop
<== NOT EXECUTED
}
_POSIX_Mutex_Release( the_mutex, &queue_context );
return eno;
}
40007f84: 81 c7 e0 08 ret
<== NOT EXECUTED
40007f88: 81 e8 00 00 restore
<== NOT EXECUTED
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40007f8c: 40 00 01 0d call 400083c0 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
40007f90: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40007f94: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40007f98: 12 bf ff f3 bne 40007f64 <pthread_mutex_destroy+0x2c>
<== NOT EXECUTED
40007f9c: 01 00 00 00 nop
<== NOT EXECUTED
40007fa0: 81 c7 e0 08 ret
<== NOT EXECUTED
40007fa4: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
the_mutex->flags = ~the_mutex->flags;
40007fa8: 84 38 00 02 xnor %g0, %g2, %g2
<== NOT EXECUTED
40007fac: c4 26 00 00 st %g2, [ %i0 ]
<== NOT EXECUTED
eno = 0;
40007fb0: b0 10 20 00 clr %i0
<== NOT EXECUTED
40007fb4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007fb8: 01 00 00 00 nop
}
40007fbc: 81 c7 e0 08 ret
40007fc0: 81 e8 00 00 restore
40007fc4 <pthread_mutex_init>:
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr
)
{
40007fc4: 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;
40007fc8: 80 a6 60 00 cmp %i1, 0
40007fcc: 02 80 00 0f be 40008008 <pthread_mutex_init+0x44>
<== NEVER TAKEN
40007fd0: ba 10 00 18 mov %i0, %i5
else the_attr = &_POSIX_Mutex_Default_attributes;
/* Check for NULL mutex */
if ( !mutex )
40007fd4: 80 a6 20 00 cmp %i0, 0
40007fd8: 02 80 00 44 be 400080e8 <pthread_mutex_init+0x124>
<== NEVER TAKEN
40007fdc: 01 00 00 00 nop
* value in an uninitialized variable to make this fail.
*
* Thus, we do not look at *mutex.
*/
if ( !the_attr->is_initialized )
40007fe0: c2 06 40 00 ld [ %i1 ], %g1
40007fe4: 80 a0 60 00 cmp %g1, 0
40007fe8: 02 80 00 06 be 40008000 <pthread_mutex_init+0x3c>
<== NEVER TAKEN
40007fec: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( !_POSIX_Is_valid_pshared( the_attr->process_shared ) ) {
40007ff0: c2 06 60 04 ld [ %i1 + 4 ], %g1
40007ff4: 80 a0 60 01 cmp %g1, 1
40007ff8: 28 80 00 16 bleu,a 40008050 <pthread_mutex_init+0x8c>
<== ALWAYS TAKEN
40007ffc: c2 06 60 0c ld [ %i1 + 0xc ], %g1
);
the_mutex->Recursive.nest_level = 0;
_Priority_Node_initialize( &the_mutex->Priority_ceiling, priority );
the_mutex->scheduler = scheduler;
return 0;
}
40008000: 81 c7 e0 08 ret
<== NOT EXECUTED
40008004: 81 e8 00 00 restore
<== NOT EXECUTED
if ( !mutex )
40008008: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4000800c: 02 80 00 37 be 400080e8 <pthread_mutex_init+0x124>
<== NOT EXECUTED
40008010: 03 25 87 04 sethi %hi(0x961c1000), %g1
<== NOT EXECUTED
flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
40008014: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 <RAM_END+0x55dc13b8>
<== NOT EXECUTED
40008018: 82 1e 00 01 xor %i0, %g1, %g1
<== NOT EXECUTED
flags &= ~POSIX_MUTEX_FLAGS_MASK;
4000801c: 82 08 7f f8 and %g1, -8, %g1
<== NOT EXECUTED
the_mutex->flags = flags;
40008020: c2 26 00 00 st %g1, [ %i0 ]
<== NOT EXECUTED
scheduler = NULL;
40008024: 84 10 20 00 clr %g2
<== NOT EXECUTED
priority = 0;
40008028: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000802c: 92 10 20 00 clr %o1
<== NOT EXECUTED
)
{
#if defined(RTEMS_SMP)
_SMP_ticket_lock_Initialize( &queue->Lock );
#endif
queue->heads = NULL;
40008030: c0 27 60 0c clr [ %i5 + 0xc ]
queue->owner = NULL;
40008034: c0 27 60 10 clr [ %i5 + 0x10 ]
queue->name = name;
40008038: c0 27 60 14 clr [ %i5 + 0x14 ]
the_mutex->Recursive.nest_level = 0;
4000803c: c0 27 60 18 clr [ %i5 + 0x18 ]
RTEMS_INLINE_ROUTINE void _Priority_Node_initialize(
Priority_Node *node,
Priority_Control priority
)
{
node->priority = priority;
40008040: d0 3f 60 30 std %o0, [ %i5 + 0x30 ]
the_mutex->scheduler = scheduler;
40008044: c4 27 60 38 st %g2, [ %i5 + 0x38 ]
return 0;
40008048: 81 c7 e0 08 ret
4000804c: 91 e8 20 00 restore %g0, 0, %o0
switch ( the_attr->protocol ) {
40008050: 80 a0 60 01 cmp %g1, 1
40008054: 02 80 00 27 be 400080f0 <pthread_mutex_init+0x12c>
<== ALWAYS TAKEN
40008058: 80 a0 60 02 cmp %g1, 2
4000805c: 02 80 00 27 be 400080f8 <pthread_mutex_init+0x134>
<== NOT EXECUTED
40008060: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40008064: 12 bf ff e7 bne 40008000 <pthread_mutex_init+0x3c>
<== NOT EXECUTED
40008068: 84 10 20 00 clr %g2
<== NOT EXECUTED
switch ( the_attr->type ) {
4000806c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
40008070: 80 a0 60 03 cmp %g1, 3
40008074: 18 bf ff e3 bgu 40008000 <pthread_mutex_init+0x3c>
<== NEVER TAKEN
40008078: b0 10 20 16 mov 0x16, %i0
if ( the_attr->type == PTHREAD_MUTEX_RECURSIVE ) {
4000807c: 80 a0 60 01 cmp %g1, 1
flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
40008080: 03 25 87 04 sethi %hi(0x961c1000), %g1
40008084: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 <RAM_END+0x55dc13b8>
40008088: 82 1f 40 01 xor %i5, %g1, %g1
flags &= ~POSIX_MUTEX_FLAGS_MASK;
4000808c: 82 08 7f f8 and %g1, -8, %g1
if ( the_attr->type == PTHREAD_MUTEX_RECURSIVE ) {
40008090: 12 80 00 03 bne 4000809c <pthread_mutex_init+0xd8>
<== ALWAYS TAKEN
40008094: 82 10 80 01 or %g2, %g1, %g1
flags |= POSIX_MUTEX_RECURSIVE;
40008098: 82 10 60 04 or %g1, 4, %g1
<== NOT EXECUTED
if ( protocol == POSIX_MUTEX_PRIORITY_CEILING ) {
4000809c: 80 a0 a0 02 cmp %g2, 2
400080a0: 12 80 00 18 bne 40008100 <pthread_mutex_init+0x13c>
<== ALWAYS TAKEN
400080a4: c2 27 40 00 st %g1, [ %i5 ]
prio_ceiling = the_attr->prio_ceiling;
400080a8: d2 06 60 08 ld [ %i1 + 8 ], %o1
<== NOT EXECUTED
if ( prio_ceiling == INT_MAX ) {
400080ac: 03 1f ff ff sethi %hi(0x7ffffc00), %g1
<== NOT EXECUTED
400080b0: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff <RAM_END+0x3fbfffff>
<== NOT EXECUTED
400080b4: 80 a2 40 01 cmp %o1, %g1
<== NOT EXECUTED
400080b8: 12 80 00 05 bne 400080cc <pthread_mutex_init+0x108>
<== NOT EXECUTED
400080bc: 39 10 00 4d sethi %hi(0x40013400), %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;
400080c0: 82 17 21 08 or %i4, 0x108, %g1 ! 40013508 <_Scheduler_Table>
<== NOT EXECUTED
400080c4: d2 00 60 44 ld [ %g1 + 0x44 ], %o1
<== NOT EXECUTED
400080c8: 92 02 7f ff add %o1, -1, %o1
<== NOT EXECUTED
priority = _POSIX_Priority_To_core( scheduler, prio_ceiling, &valid );
400080cc: 94 07 bf ff add %fp, -1, %o2
<== NOT EXECUTED
400080d0: 40 00 01 75 call 400086a4 <_POSIX_Priority_To_core>
<== NOT EXECUTED
400080d4: 90 17 21 08 or %i4, 0x108, %o0
<== NOT EXECUTED
if ( !valid ) {
400080d8: c2 0f bf ff ldub [ %fp + -1 ], %g1
<== NOT EXECUTED
400080dc: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400080e0: 12 bf ff d4 bne 40008030 <pthread_mutex_init+0x6c>
<== NOT EXECUTED
400080e4: 84 17 21 08 or %i4, 0x108, %g2
<== NOT EXECUTED
return EINVAL;
400080e8: 81 c7 e0 08 ret
<== NOT EXECUTED
400080ec: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
protocol = POSIX_MUTEX_PRIORITY_INHERIT;
400080f0: 10 bf ff df b 4000806c <pthread_mutex_init+0xa8>
400080f4: 84 10 20 01 mov 1, %g2
break;
400080f8: 10 bf ff dd b 4000806c <pthread_mutex_init+0xa8>
<== NOT EXECUTED
400080fc: 84 10 20 02 mov 2, %g2
<== NOT EXECUTED
scheduler = NULL;
40008100: 84 10 20 00 clr %g2
priority = 0;
40008104: 90 10 20 00 clr %o0
40008108: 10 bf ff ca b 40008030 <pthread_mutex_init+0x6c>
4000810c: 92 10 20 00 clr %o1
4000845c <pthread_mutex_unlock>:
*/
int pthread_mutex_unlock(
pthread_mutex_t *mutex
)
{
4000845c: 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 );
40008460: 80 a6 20 00 cmp %i0, 0
40008464: 02 80 00 32 be 4000852c <pthread_mutex_unlock+0xd0>
<== NEVER TAKEN
40008468: 05 25 87 04 sethi %hi(0x961c1000), %g2
4000846c: fa 06 00 00 ld [ %i0 ], %i5
40008470: 82 1e 00 1d xor %i0, %i5, %g1
40008474: 84 10 a3 b8 or %g2, 0x3b8, %g2
40008478: 82 18 40 02 xor %g1, %g2, %g1
4000847c: 80 88 7f f8 btst -8, %g1
40008480: 12 80 00 26 bne 40008518 <pthread_mutex_unlock+0xbc>
<== NEVER TAKEN
40008484: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008488: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000848c: c2 27 bf dc st %g1, [ %fp + -36 ]
executing = _POSIX_Mutex_Acquire( the_mutex, &queue_context );
switch ( _POSIX_Mutex_Get_protocol( flags ) ) {
40008490: ba 8f 60 03 andcc %i5, 3, %i5
40008494: 02 80 00 28 be 40008534 <pthread_mutex_unlock+0xd8>
<== NEVER TAKEN
40008498: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
4000849c: 80 a7 60 02 cmp %i5, 2
400084a0: 12 80 00 0a bne 400084c8 <pthread_mutex_unlock+0x6c>
<== ALWAYS TAKEN
400084a4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
unsigned int nest_level;
ISR_lock_Context lock_context;
Per_CPU_Control *cpu_self;
Thread_queue_Heads *heads;
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
400084a8: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
400084ac: 22 80 00 37 be,a 40008588 <pthread_mutex_unlock+0x12c>
<== NOT EXECUTED
400084b0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400084b4: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400084b8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400084bc: 01 00 00 00 nop
<== NOT EXECUTED
400084c0: 81 c7 e0 08 ret
<== NOT EXECUTED
400084c4: 91 e8 20 01 restore %g0, 1, %o0
<== NOT EXECUTED
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
400084c8: 80 a2 00 01 cmp %o0, %g1
400084cc: 12 bf ff fa bne 400084b4 <pthread_mutex_unlock+0x58>
<== NEVER TAKEN
400084d0: 01 00 00 00 nop
nest_level = the_mutex->Recursive.nest_level;
400084d4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
if ( nest_level > 0 ) {
400084d8: 80 a0 60 00 cmp %g1, 0
400084dc: 12 80 00 2e bne 40008594 <pthread_mutex_unlock+0x138>
<== NEVER TAKEN
400084e0: 82 00 7f ff add %g1, -1, %g1
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
400084e4: c0 26 20 10 clr [ %i0 + 0x10 ]
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
400084e8: d2 06 20 0c ld [ %i0 + 0xc ], %o1
if ( heads == NULL ) {
400084ec: 80 a2 60 00 cmp %o1, 0
400084f0: 02 80 00 2f be 400085ac <pthread_mutex_unlock+0x150>
400084f4: 94 10 00 08 mov %o0, %o2
_Thread_queue_Surrender(
400084f8: 96 07 bf dc add %fp, -36, %o3
400084fc: 90 06 20 0c add %i0, 0xc, %o0
40008500: 19 10 00 4e sethi %hi(0x40013800), %o4
40008504: b0 10 20 00 clr %i0
40008508: 40 00 17 d0 call 4000e448 <_Thread_queue_Surrender>
4000850c: 98 13 22 e4 or %o4, 0x2e4, %o4
);
break;
}
return _POSIX_Get_error( status );
}
40008510: 81 c7 e0 08 ret
40008514: 81 e8 00 00 restore
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40008518: 7f ff ff aa call 400083c0 <_POSIX_Mutex_Auto_initialization>
<== NOT EXECUTED
4000851c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40008520: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40008524: 12 bf ff d9 bne 40008488 <pthread_mutex_unlock+0x2c>
<== NOT EXECUTED
40008528: 01 00 00 00 nop
<== NOT EXECUTED
4000852c: 81 c7 e0 08 ret
<== NOT EXECUTED
40008530: 91 e8 20 16 restore %g0, 0x16, %o0
<== NOT EXECUTED
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
40008534: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
<== NOT EXECUTED
40008538: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
4000853c: 12 bf ff de bne 400084b4 <pthread_mutex_unlock+0x58>
<== NOT EXECUTED
40008540: 01 00 00 00 nop
<== NOT EXECUTED
nest_level = the_mutex->Recursive.nest_level;
40008544: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
if ( nest_level > 0 ) {
40008548: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000854c: 12 80 00 12 bne 40008594 <pthread_mutex_unlock+0x138>
<== NOT EXECUTED
40008550: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40008554: c0 26 20 10 clr [ %i0 + 0x10 ]
<== NOT EXECUTED
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
40008558: d2 06 20 0c ld [ %i0 + 0xc ], %o1
<== NOT EXECUTED
if ( heads == NULL ) {
4000855c: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
40008560: 02 80 00 13 be 400085ac <pthread_mutex_unlock+0x150>
<== NOT EXECUTED
40008564: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
_Thread_queue_Surrender(
40008568: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
4000856c: 90 06 20 0c add %i0, 0xc, %o0
<== NOT EXECUTED
40008570: 19 10 00 4e sethi %hi(0x40013800), %o4
<== NOT EXECUTED
40008574: b0 10 20 00 clr %i0
<== NOT EXECUTED
40008578: 40 00 17 b4 call 4000e448 <_Thread_queue_Surrender>
<== NOT EXECUTED
4000857c: 98 13 23 0c or %o4, 0x30c, %o4
<== NOT EXECUTED
40008580: 81 c7 e0 08 ret
<== NOT EXECUTED
40008584: 81 e8 00 00 restore
<== NOT EXECUTED
return STATUS_NOT_OWNER;
}
nest_level = the_mutex->Recursive.nest_level;
if ( nest_level > 0 ) {
40008588: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000858c: 02 80 00 0d be 400085c0 <pthread_mutex_unlock+0x164>
<== NOT EXECUTED
40008590: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
the_mutex->Recursive.nest_level = nest_level - 1;
40008594: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008598: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000859c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400085a0: 01 00 00 00 nop
<== NOT EXECUTED
400085a4: 81 c7 e0 08 ret
<== NOT EXECUTED
400085a8: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400085ac: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400085b0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400085b4: 01 00 00 00 nop
400085b8: 81 c7 e0 08 ret
400085bc: 91 e8 20 00 restore %g0, 0, %o0
400085c0: 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(
400085c4: b6 06 20 20 add %i0, 0x20, %i3
<== NOT EXECUTED
400085c8: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
400085cc: 40 00 14 81 call 4000d7d0 <_Thread_Priority_remove>
<== NOT EXECUTED
400085d0: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
400085d4: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
400085d8: 82 00 60 01 inc %g1
<== NOT EXECUTED
400085dc: 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;
400085e0: d0 06 20 0c ld [ %i0 + 0xc ], %o0
<== NOT EXECUTED
if ( heads != NULL ) {
400085e4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400085e8: 02 80 00 2a be 40008690 <pthread_mutex_unlock+0x234>
<== NOT EXECUTED
400085ec: 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 );
400085f0: 39 10 00 4e sethi %hi(0x40013800), %i4
<== NOT EXECUTED
400085f4: b8 17 22 f8 or %i4, 0x2f8, %i4 ! 40013af8 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
400085f8: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
<== NOT EXECUTED
400085fc: 9f c0 40 00 call %g1
<== NOT EXECUTED
40008600: 01 00 00 00 nop
<== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40008604: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
<== NOT EXECUTED
new_owner = ( *operations->first )( heads );
40008608: 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(
4000860c: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
40008610: 40 00 14 6b call 4000d7bc <_Thread_Priority_add>
<== NOT EXECUTED
40008614: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
new_owner,
&the_mutex->Priority_ceiling,
queue_context
);
_Thread_queue_Extract_critical(
40008618: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
4000861c: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
40008620: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
40008624: 40 00 17 48 call 4000e344 <_Thread_queue_Extract_critical>
<== NOT EXECUTED
40008628: 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 );
4000862c: 40 00 14 75 call 4000d800 <_Thread_Priority_update>
<== NOT EXECUTED
40008630: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
40008634: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
40008638: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000863c: 02 80 00 06 be 40008654 <pthread_mutex_unlock+0x1f8>
<== NOT EXECUTED
40008640: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
40008644: b0 10 20 00 clr %i0
<== NOT EXECUTED
40008648: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
4000864c: 81 c7 e0 08 ret
<== NOT EXECUTED
40008650: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008654: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
40008658: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
<== NOT EXECUTED
4000865c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40008660: 12 80 00 07 bne 4000867c <pthread_mutex_unlock+0x220>
<== NOT EXECUTED
40008664: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
40008668: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000866c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008670: 01 00 00 00 nop
<== NOT EXECUTED
40008674: 81 c7 e0 08 ret
<== NOT EXECUTED
40008678: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
4000867c: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
40008680: 40 00 14 e7 call 4000da1c <_Thread_Do_dispatch>
<== NOT EXECUTED
40008684: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40008688: 10 bf ff f9 b 4000866c <pthread_mutex_unlock+0x210>
<== NOT EXECUTED
4000868c: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40008690: c0 26 20 10 clr [ %i0 + 0x10 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008694: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008698: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000869c: 01 00 00 00 nop
<== NOT EXECUTED
400086a0: 30 bf ff e3 b,a 4000862c <pthread_mutex_unlock+0x1d0>
<== NOT EXECUTED
40007e80 <pthread_mutexattr_destroy>:
*/
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( attr == NULL || !attr->is_initialized )
40007e80: 82 92 20 00 orcc %o0, 0, %g1
40007e84: 02 80 00 09 be 40007ea8 <pthread_mutexattr_destroy+0x28>
<== NEVER TAKEN
40007e88: 90 10 20 16 mov 0x16, %o0
40007e8c: c4 00 40 00 ld [ %g1 ], %g2
40007e90: 80 a0 a0 00 cmp %g2, 0
40007e94: 02 80 00 05 be 40007ea8 <pthread_mutexattr_destroy+0x28>
<== NEVER TAKEN
40007e98: 01 00 00 00 nop
return EINVAL;
attr->is_initialized = false;
40007e9c: c0 20 40 00 clr [ %g1 ]
return 0;
40007ea0: 81 c3 e0 08 retl
40007ea4: 90 10 20 00 clr %o0
}
40007ea8: 81 c3 e0 08 retl
<== NOT EXECUTED
40007eac: 01 00 00 00 nop
<== NOT EXECUTED
40007eb0 <pthread_mutexattr_init>:
*/
int pthread_mutexattr_init(
pthread_mutexattr_t *attr
)
{
if ( attr == NULL )
40007eb0: 82 92 20 00 orcc %o0, 0, %g1
40007eb4: 02 80 00 11 be 40007ef8 <pthread_mutexattr_init+0x48>
<== NEVER TAKEN
40007eb8: 07 10 00 4e sethi %hi(0x40013800), %g3
return EINVAL;
*attr = _POSIX_Mutex_Default_attributes;
40007ebc: 84 10 e2 68 or %g3, 0x268, %g2 ! 40013a68 <_POSIX_Mutex_Default_attributes>
40007ec0: d6 00 e2 68 ld [ %g3 + 0x268 ], %o3
40007ec4: d8 00 a0 04 ld [ %g2 + 4 ], %o4
40007ec8: da 00 a0 08 ld [ %g2 + 8 ], %o5
40007ecc: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
40007ed0: c6 00 a0 10 ld [ %g2 + 0x10 ], %g3
40007ed4: c4 00 a0 14 ld [ %g2 + 0x14 ], %g2
40007ed8: d6 20 40 00 st %o3, [ %g1 ]
return 0;
40007edc: 90 10 20 00 clr %o0
*attr = _POSIX_Mutex_Default_attributes;
40007ee0: d8 20 60 04 st %o4, [ %g1 + 4 ]
40007ee4: da 20 60 08 st %o5, [ %g1 + 8 ]
40007ee8: c8 20 60 0c st %g4, [ %g1 + 0xc ]
40007eec: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
return 0;
40007ef0: 81 c3 e0 08 retl
40007ef4: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
}
40007ef8: 81 c3 e0 08 retl
<== NOT EXECUTED
40007efc: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
40007f00 <pthread_mutexattr_setprotocol>:
int pthread_mutexattr_setprotocol(
pthread_mutexattr_t *attr,
int protocol
)
{
if ( !attr || !attr->is_initialized )
40007f00: 82 92 20 00 orcc %o0, 0, %g1
40007f04: 02 80 00 0b be 40007f30 <pthread_mutexattr_setprotocol+0x30>
<== NEVER TAKEN
40007f08: 90 10 20 16 mov 0x16, %o0
40007f0c: c4 00 40 00 ld [ %g1 ], %g2
40007f10: 80 a0 a0 00 cmp %g2, 0
40007f14: 02 80 00 07 be 40007f30 <pthread_mutexattr_setprotocol+0x30>
<== NEVER TAKEN
40007f18: 80 a2 60 02 cmp %o1, 2
return EINVAL;
switch ( protocol ) {
40007f1c: 18 80 00 05 bgu 40007f30 <pthread_mutexattr_setprotocol+0x30>
<== NEVER TAKEN
40007f20: 01 00 00 00 nop
case PTHREAD_PRIO_NONE:
case PTHREAD_PRIO_INHERIT:
case PTHREAD_PRIO_PROTECT:
attr->protocol = protocol;
40007f24: d2 20 60 0c st %o1, [ %g1 + 0xc ]
return 0;
40007f28: 81 c3 e0 08 retl
40007f2c: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
40007f30: 81 c3 e0 08 retl
<== NOT EXECUTED
40007f34: 01 00 00 00 nop
<== NOT EXECUTED
40009bd4 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
40009bd4: 80 a2 20 00 cmp %o0, 0
40009bd8: 02 80 00 07 be 40009bf4 <pthread_once+0x20>
<== NEVER TAKEN
40009bdc: 80 a2 60 00 cmp %o1, 0
40009be0: 02 80 00 05 be 40009bf4 <pthread_once+0x20>
<== NEVER TAKEN
40009be4: 01 00 00 00 nop
return EINVAL;
return _Once( &once_control->_flags, init_routine );
40009be8: 82 13 c0 00 mov %o7, %g1
40009bec: 40 00 0c d6 call 4000cf44 <_Once>
40009bf0: 9e 10 40 00 mov %g1, %o7
}
40009bf4: 81 c3 e0 08 retl
<== NOT EXECUTED
40009bf8: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
400081a4 <pthread_setaffinity_np>:
int pthread_setaffinity_np(
pthread_t thread,
size_t cpusetsize,
const cpu_set_t *cpuset
)
{
400081a4: 9d e3 bf 90 save %sp, -112, %sp
Thread_Control *the_thread;
ISR_lock_Context lock_context;
Per_CPU_Control *cpu_self;
bool ok;
if ( cpuset == NULL ) {
400081a8: 80 a6 a0 00 cmp %i2, 0
400081ac: 02 80 00 1c be 4000821c <pthread_setaffinity_np+0x78>
400081b0: 82 10 20 0e mov 0xe, %g1
return EFAULT;
}
the_thread = _Thread_Get( thread, &lock_context );
400081b4: 92 07 bf fc add %fp, -4, %o1
400081b8: 40 00 16 90 call 4000dbf8 <_Thread_Get>
400081bc: 90 10 00 18 mov %i0, %o0
if ( the_thread == NULL ) {
400081c0: 80 a2 20 00 cmp %o0, 0
400081c4: 02 80 00 16 be 4000821c <pthread_setaffinity_np+0x78>
400081c8: 82 10 20 03 mov 3, %g1
disable_level = cpu_self->thread_dispatch_disable_level;
400081cc: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
400081d0: 82 00 60 01 inc %g1
400081d4: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
400081d8: ba 10 00 06 mov %g6, %i5
}
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
_Thread_State_acquire_critical( the_thread, &lock_context );
ok = _Scheduler_Set_affinity(
400081dc: 94 10 00 1a mov %i2, %o2
400081e0: 40 00 14 af call 4000d49c <_Scheduler_Set_affinity>
400081e4: 92 10 00 19 mov %i1, %o1
400081e8: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400081ec: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400081f0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400081f4: 01 00 00 00 nop
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
400081f8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
if ( disable_level == 1 ) {
400081fc: 80 a0 60 01 cmp %g1, 1
40008200: 02 80 00 09 be 40008224 <pthread_setaffinity_np+0x80>
<== ALWAYS TAKEN
40008204: 82 00 7f ff add %g1, -1, %g1
cpu_self->thread_dispatch_disable_level = disable_level - 1;
40008208: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
cpuset
);
_Thread_State_release( the_thread, &lock_context );
_Thread_Dispatch_enable( cpu_self );
return ok ? 0 : EINVAL;
4000820c: 80 a0 00 1c cmp %g0, %i4
<== NOT EXECUTED
40008210: 82 60 20 00 subx %g0, 0, %g1
40008214: 82 08 7f ea and %g1, -22, %g1
40008218: 82 00 60 16 add %g1, 0x16, %g1
}
4000821c: 81 c7 e0 08 ret
40008220: 91 e8 00 01 restore %g0, %g1, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008224: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
40008228: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
4000822c: 80 a0 a0 00 cmp %g2, 0
40008230: 32 80 00 07 bne,a 4000824c <pthread_setaffinity_np+0xa8>
<== NEVER TAKEN
40008234: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
40008238: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000823c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008240: 01 00 00 00 nop
return ok ? 0 : EINVAL;
40008244: 10 bf ff f3 b 40008210 <pthread_setaffinity_np+0x6c>
40008248: 80 a0 00 1c cmp %g0, %i4
_Thread_Do_dispatch( cpu_self, level );
4000824c: c2 27 bf f4 st %g1, [ %fp + -12 ]
<== NOT EXECUTED
40008250: 40 00 16 0b call 4000da7c <_Thread_Do_dispatch>
<== NOT EXECUTED
40008254: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40008258: 10 bf ff f9 b 4000823c <pthread_setaffinity_np+0x98>
<== NOT EXECUTED
4000825c: c2 07 bf f4 ld [ %fp + -12 ], %g1
<== NOT EXECUTED
400063d4 <pthread_setspecific>:
int pthread_setspecific(
pthread_key_t key,
const void *value
)
{
400063d4: 9d e3 bf 98 save %sp, -104, %sp
400063d8: ba 10 00 18 mov %i0, %i5
Thread_Control *executing;
int eno;
executing = _Thread_Get_executing();
if ( value != NULL ) {
400063dc: 80 a6 60 00 cmp %i1, 0
400063e0: 02 80 00 52 be 40006528 <pthread_setspecific+0x154>
400063e4: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400063e8: 91 d0 20 09 ta 9
<== NOT EXECUTED
return &RB_ROOT( the_rbtree );
400063ec: b6 07 21 60 add %i4, 0x160, %i3
link = _RBTree_Root_const_reference( the_rbtree );
400063f0: 86 10 00 1b mov %i3, %g3
while ( *link != NULL ) {
400063f4: c4 00 c0 00 ld [ %g3 ], %g2
400063f8: 80 a0 a0 00 cmp %g2, 0
400063fc: 02 80 00 0d be 40006430 <pthread_setspecific+0x5c>
40006400: 86 00 bf f8 add %g2, -8, %g3
return *the_left == the_right->key;
40006404: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
if ( ( *equal )( key, parent ) ) {
40006408: 80 a7 40 04 cmp %i5, %g4
4000640c: 22 80 00 31 be,a 400064d0 <pthread_setspecific+0xfc>
<== ALWAYS TAKEN
40006410: f2 20 e0 20 st %i1, [ %g3 + 0x20 ]
} else if ( ( *less )( key, parent ) ) {
40006414: 1a bf ff f8 bcc 400063f4 <pthread_setspecific+0x20>
<== NOT EXECUTED
40006418: 86 00 a0 04 add %g2, 4, %g3
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
4000641c: 86 10 00 02 mov %g2, %g3
<== NOT EXECUTED
while ( *link != NULL ) {
40006420: c4 00 c0 00 ld [ %g3 ], %g2
<== NOT EXECUTED
40006424: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40006428: 12 bf ff f7 bne 40006404 <pthread_setspecific+0x30>
<== NOT EXECUTED
4000642c: 86 00 bf f8 add %g2, -8, %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006430: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006434: 01 00 00 00 nop
_RTEMS_Lock_allocator();
40006438: 40 00 01 63 call 400069c4 <_RTEMS_Lock_allocator>
4000643c: b0 10 20 16 mov 0x16, %i0 ! 16 <_TLS_Alignment+0x15>
return (POSIX_Keys_Control *)
40006440: 90 10 00 1d mov %i5, %o0
40006444: 13 10 00 4d sethi %hi(0x40013400), %o1
40006448: 40 00 09 f0 call 40008c08 <_Objects_Get_no_protection>
4000644c: 92 12 62 d8 or %o1, 0x2d8, %o1 ! 400136d8 <_POSIX_Keys_Information>
if ( the_key != NULL ) {
40006450: b4 92 20 00 orcc %o0, 0, %i2
40006454: 02 80 00 31 be 40006518 <pthread_setspecific+0x144>
<== NEVER TAKEN
40006458: 01 00 00 00 nop
key_value_pair = _POSIX_Keys_Key_value_allocate();
4000645c: 7f ff ff ce call 40006394 <_POSIX_Keys_Key_value_allocate>
40006460: b0 10 20 0c mov 0xc, %i0 ! c <_TLS_Alignment+0xb>
if ( key_value_pair != NULL ) {
40006464: 80 a2 20 00 cmp %o0, 0
40006468: 02 80 00 2c be 40006518 <pthread_setspecific+0x144>
<== NEVER TAKEN
4000646c: 88 10 00 08 mov %o0, %g4
<== NOT EXECUTED
old_last = tail->previous;
40006470: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
<== NOT EXECUTED
return &the_chain->Tail.Node;
40006474: 84 06 a0 18 add %i2, 0x18, %g2
<== NOT EXECUTED
key_value_pair->key = key;
40006478: fa 22 20 18 st %i5, [ %o0 + 0x18 ]
<== NOT EXECUTED
_RBTree_Initialize_node( &key_value_pair->Lookup_node );
4000647c: b0 02 20 08 add %o0, 8, %i0
<== NOT EXECUTED
key_value_pair->thread = executing;
40006480: f8 22 20 1c st %i4, [ %o0 + 0x1c ]
<== NOT EXECUTED
key_value_pair->value = RTEMS_DECONST( void *, value );
40006484: f2 22 20 20 st %i1, [ %o0 + 0x20 ]
<== NOT EXECUTED
the_node->next = tail;
40006488: c4 22 00 00 st %g2, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
4000648c: d0 26 a0 1c st %o0, [ %i2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40006490: d0 20 40 00 st %o0, [ %g1 ]
<== NOT EXECUTED
the_node->previous = old_last;
40006494: c2 22 20 04 st %g1, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006498: 91 d0 20 09 ta 9
<== NOT EXECUTED
parent = NULL;
4000649c: b8 10 20 00 clr %i4
link = _RBTree_Root_reference( the_rbtree );
400064a0: 86 10 00 1b mov %i3, %g3
while ( *link != NULL ) {
400064a4: c4 00 c0 00 ld [ %g3 ], %g2
400064a8: 80 a0 a0 00 cmp %g2, 0
400064ac: 22 80 00 41 be,a 400065b0 <pthread_setspecific+0x1dc>
<== ALWAYS TAKEN
400064b0: f8 21 20 10 st %i4, [ %g4 + 0x10 ]
if ( ( *less )( key, parent ) ) {
400064b4: f8 00 a0 10 ld [ %g2 + 0x10 ], %i4
<== NOT EXECUTED
400064b8: 80 a7 40 1c cmp %i5, %i4
<== NOT EXECUTED
400064bc: 1a 80 00 03 bcc 400064c8 <pthread_setspecific+0xf4>
<== NOT EXECUTED
400064c0: 86 00 a0 04 add %g2, 4, %g3
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
400064c4: 86 10 00 02 mov %g2, %g3
<== NOT EXECUTED
link = _RBTree_Root_const_reference( the_rbtree );
400064c8: 10 bf ff f7 b 400064a4 <pthread_setspecific+0xd0>
<== NOT EXECUTED
400064cc: b8 10 00 02 mov %g2, %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400064d0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400064d4: 01 00 00 00 nop
} else {
eno = _POSIX_Keys_Delete_value( key, executing );
}
return eno;
}
400064d8: 81 c7 e0 08 ret
400064dc: 91 e8 20 00 restore %g0, 0, %o0
_RBTree_Extract(
400064e0: 40 00 0a 62 call 40008e68 <_RBTree_Extract>
400064e4: c2 27 bf fc st %g1, [ %fp + -4 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400064e8: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400064ec: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400064f0: 01 00 00 00 nop
next = the_node->next;
400064f4: c4 07 00 00 ld [ %i4 ], %g2
previous = the_node->previous;
400064f8: c2 07 20 04 ld [ %i4 + 4 ], %g1
next->previous = previous;
400064fc: c2 20 a0 04 st %g1, [ %g2 + 4 ]
_Freechain_Put( &_POSIX_Keys_Keypool, key_value_pair );
40006500: 11 10 00 4d sethi %hi(0x40013400), %o0
previous->next = next;
40006504: c4 20 40 00 st %g2, [ %g1 ]
40006508: 92 10 00 1c mov %i4, %o1
eno = 0;
4000650c: b0 10 20 00 clr %i0
40006510: 40 00 01 8e call 40006b48 <_Freechain_Put>
40006514: 90 12 23 14 or %o0, 0x314, %o0
_RTEMS_Unlock_allocator();
40006518: 40 00 01 30 call 400069d8 <_RTEMS_Unlock_allocator>
4000651c: 01 00 00 00 nop
return eno;
40006520: 81 c7 e0 08 ret
40006524: 81 e8 00 00 restore
_RTEMS_Lock_allocator();
40006528: 40 00 01 27 call 400069c4 <_RTEMS_Lock_allocator>
4000652c: 01 00 00 00 nop
return (POSIX_Keys_Control *)
40006530: 90 10 00 18 mov %i0, %o0
40006534: 13 10 00 4d sethi %hi(0x40013400), %o1
eno = EINVAL;
40006538: b0 10 20 16 mov 0x16, %i0
4000653c: 40 00 09 b3 call 40008c08 <_Objects_Get_no_protection>
40006540: 92 12 62 d8 or %o1, 0x2d8, %o1
if ( the_key != NULL ) {
40006544: 80 a2 20 00 cmp %o0, 0
40006548: 02 bf ff f4 be 40006518 <pthread_setspecific+0x144>
4000654c: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006550: 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(
40006554: 90 07 21 60 add %i4, 0x160, %o0
40006558: 84 10 00 08 mov %o0, %g2
while ( *link != NULL ) {
4000655c: d2 00 80 00 ld [ %g2 ], %o1
40006560: 80 a2 60 00 cmp %o1, 0
40006564: 02 80 00 0d be 40006598 <pthread_setspecific+0x1c4>
<== NEVER TAKEN
40006568: b8 02 7f f8 add %o1, -8, %i4
return *the_left == the_right->key;
4000656c: c4 07 20 18 ld [ %i4 + 0x18 ], %g2
if ( ( *equal )( key, parent ) ) {
40006570: 80 a7 40 02 cmp %i5, %g2
40006574: 02 bf ff db be 400064e0 <pthread_setspecific+0x10c>
<== ALWAYS TAKEN
40006578: 01 00 00 00 nop
} else if ( ( *less )( key, parent ) ) {
4000657c: 1a bf ff f8 bcc 4000655c <pthread_setspecific+0x188>
<== NOT EXECUTED
40006580: 84 02 60 04 add %o1, 4, %g2
<== NOT EXECUTED
return &RB_LEFT( the_node, Node );
40006584: 84 10 00 09 mov %o1, %g2
<== NOT EXECUTED
while ( *link != NULL ) {
40006588: d2 00 80 00 ld [ %g2 ], %o1
<== NOT EXECUTED
4000658c: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
40006590: 12 bf ff f7 bne 4000656c <pthread_setspecific+0x198>
<== NOT EXECUTED
40006594: b8 02 7f f8 add %o1, -8, %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006598: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000659c: 01 00 00 00 nop
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
400065a0: 40 00 01 0e call 400069d8 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
400065a4: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
return eno;
400065a8: 81 c7 e0 08 ret
<== NOT EXECUTED
400065ac: 81 e8 00 00 restore
<== NOT EXECUTED
RB_SET( child, parent, Node );
400065b0: 84 10 20 01 mov 1, %g2
400065b4: c0 21 20 0c clr [ %g4 + 0xc ]
_RBTree_Insert_color( the_rbtree, the_node );
400065b8: 92 10 00 18 mov %i0, %o1
RB_SET( child, parent, Node );
400065bc: c0 21 20 08 clr [ %g4 + 8 ]
_RBTree_Insert_color( the_rbtree, the_node );
400065c0: 90 10 00 1b mov %i3, %o0
RB_SET( child, parent, Node );
400065c4: c4 21 20 14 st %g2, [ %g4 + 0x14 ]
*link = child;
400065c8: f0 20 c0 00 st %i0, [ %g3 ]
_RBTree_Insert_color( the_rbtree, the_node );
400065cc: 40 00 0b 89 call 400093f0 <_RBTree_Insert_color>
400065d0: c2 27 bf fc st %g1, [ %fp + -4 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400065d4: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400065d8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400065dc: 01 00 00 00 nop
eno = 0;
400065e0: 10 bf ff ce b 40006518 <pthread_setspecific+0x144>
400065e4: b0 10 20 00 clr %i0 ! 0 <PROM_START>
400190f0 <sigemptyset>:
#include <rtems/seterr.h>
int sigemptyset(
sigset_t *set
)
{
400190f0: 9d e3 bf a0 save %sp, -96, %sp
if ( !set )
400190f4: 80 a6 20 00 cmp %i0, 0
400190f8: 02 80 00 05 be 4001910c <sigemptyset+0x1c>
<== NEVER TAKEN
400190fc: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
*set = 0;
40019100: c0 26 00 00 clr [ %i0 ]
return 0;
}
40019104: 81 c7 e0 08 ret
40019108: 91 e8 20 00 restore %g0, 0, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
4001910c: 7f ff d4 59 call 4000e270 <__errno>
<== NOT EXECUTED
40019110: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40019114: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40019118: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4001911c: 81 c7 e0 08 ret
<== NOT EXECUTED
40019120: 81 e8 00 00 restore
<== NOT EXECUTED
40001470 <wait>:
{
40001470: 9d e3 bf a0 save %sp, -96, %sp
sc = rtems_task_wake_after(4);
40001474: 40 00 21 b4 call 40009b44 <rtems_task_wake_after>
40001478: 90 10 20 04 mov 4, %o0
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
4000147c: 80 a2 20 00 cmp %o0, 0
40001480: 12 80 00 04 bne 40001490 <wait+0x20>
40001484: 94 10 20 78 mov 0x78, %o2
}
40001488: 81 c7 e0 08 ret
4000148c: 81 e8 00 00 restore
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
40001490: 17 10 00 4c sethi %hi(0x40013000), %o3
40001494: 13 10 00 4c sethi %hi(0x40013000), %o1
40001498: 96 12 e2 d8 or %o3, 0x2d8, %o3
4000149c: 92 12 62 68 or %o1, 0x268, %o1
<== NOT EXECUTED
400014a0: 11 10 00 4c sethi %hi(0x40013000), %o0
<== NOT EXECUTED
400014a4: 40 00 3c 7a call 4001068c <__wrap_printf>
<== NOT EXECUTED
400014a8: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 400132c8 <_rodata_start+0x98>
<== NOT EXECUTED
400014ac: 40 00 3c 72 call 40010674 <rtems_test_exit>
<== NOT EXECUTED
400014b0: 90 10 20 00 clr %o0
<== NOT EXECUTED
400014b4: 01 00 00 00 nop
<== NOT EXECUTED