=============================================================================== 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 _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 <== 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 <== 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 <== 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 #include 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 <== 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 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 <== 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 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 <== 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 #include #include 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 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 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 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 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 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 <== 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 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 <== NOT EXECUTED 40018904: 01 00 00 00 nop <== NOT EXECUTED 40018908: 40 00 01 b5 call 40018fdc <== 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 <== 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 : 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 <== 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 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 <== 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 <== 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 <== 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 : 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 <== 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 <== 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 <== NEVER TAKEN 40006200: 80 8e 62 00 btst 0x200, %i1 40006204: 02 80 00 2c be 400062b4 <== 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 <== 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 40006224: 80 a0 60 00 cmp %g1, 0 40006228: 04 80 00 36 ble 40006300 <== 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 <== 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 <== 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 <== 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 <== 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 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 40006374: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED =============================================================================== 40010774 : { 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 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 <== 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 : * 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 <== 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 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 : 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 <== 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 <== 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 <== 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 : 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 <== 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 <== 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_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 <== 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 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 <== 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 <== 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 <== 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 4000f46c: e4 01 a0 20 ld [ %g6 + 0x20 ], %l2 4000f470: 80 a0 60 02 cmp %g1, 2 4000f474: 12 80 00 90 bne 4000f6b4 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 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 <== 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 <== 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 <== 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 <== 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 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 4000f6d0: a6 10 00 01 mov %g1, %l3 switch ( the_attr->inheritsched ) { 4000f6d4: 10 bf ff 64 b 4000f464 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 4000f6f0: a0 10 20 86 mov 0x86, %l0 4000f6f4: 94 07 bf d0 add %fp, -48, %o2 4000f6f8: 40 00 00 51 call 4000f83c 4000f6fc: 92 07 bf bc add %fp, -68, %o1 break; 4000f700: 10 bf ff 6f b 4000f4bc 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 <== 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 <== 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 <== NOT EXECUTED =============================================================================== 4000f754 : /** * 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 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 <== 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 <== 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 <== NOT EXECUTED 4000f7f8: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED =============================================================================== 4000f80c : #include #include 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 : 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 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 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 <== 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 <== 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 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 <== NOT EXECUTED 400081a0: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED =============================================================================== 4000f83c : 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 <== NEVER TAKEN 4000f848: 80 a6 a0 00 cmp %i2, 0 4000f84c: 02 80 00 29 be 4000f8f0 <== 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 <== 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 : 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 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 <== 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 <== 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 <== 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 : 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NEVER TAKEN 4000f9bc: 92 07 bf dc add %fp, -36, %o1 value = executing->Wait.return_argument; 4000f9c0: 10 bf ff f3 b 4000f98c 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 : * 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 <== 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 <== 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 <== 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 : #include #include #include 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 400190b4: 82 10 20 00 clr %g1 ! 0 <== 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 <== 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 <== NOT EXECUTED 400190e0: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED =============================================================================== 40007f38 : */ 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 <== 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 <== 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 <== 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 <== 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 : 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== ALWAYS TAKEN 40008058: 80 a0 60 02 cmp %g1, 2 4000805c: 02 80 00 27 be 400080f8 <== NOT EXECUTED 40008060: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008064: 12 bf ff e7 bne 40008000 <== 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 <== 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 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 <== 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 <== 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 <== NOT EXECUTED 400080b4: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED 400080b8: 12 80 00 05 bne 400080cc <== 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 <== 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 400080f4: 84 10 20 01 mov 1, %g2 break; 400080f8: 10 bf ff dd b 4000806c <== 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 4000810c: 92 10 20 00 clr %o1 =============================================================================== 4000845c : */ 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED =============================================================================== 40007e80 : */ 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 <== 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 <== 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 : */ 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 <== 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 : 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 <== 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 <== NEVER TAKEN 40007f18: 80 a2 60 02 cmp %o1, 2 return EINVAL; switch ( protocol ) { 40007f1c: 18 80 00 05 bgu 40007f30 <== 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 : 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 <== NEVER TAKEN 40009bdc: 80 a2 60 00 cmp %o1, 0 40009be0: 02 80 00 05 be 40009bf4 <== 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 : 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 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 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 <== 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 <== 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 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 <== NOT EXECUTED 4000825c: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED =============================================================================== 400063d4 : 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 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 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 <== ALWAYS TAKEN 40006410: f2 20 e0 20 st %i1, [ %g3 + 0x20 ] } else if ( ( *less )( key, parent ) ) { 40006414: 1a bf ff f8 bcc 400063f4 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 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 <== 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 <== ALWAYS TAKEN 40006578: 01 00 00 00 nop } else if ( ( *less )( key, parent ) ) { 4000657c: 1a bf ff f8 bcc 4000655c <== 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 <== 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 <== 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 400065e4: b0 10 20 00 clr %i0 ! 0 =============================================================================== 400190f0 : #include 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 <== 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 : { 40001470: 9d e3 bf a0 save %sp, -96, %sp sc = rtems_task_wake_after(4); 40001474: 40 00 21 b4 call 40009b44 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 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 <== NOT EXECUTED 400014b0: 90 10 20 00 clr %o0 <== NOT EXECUTED 400014b4: 01 00 00 00 nop <== NOT EXECUTED