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