=============================================================================== 400080a4 <_API_Mutex_Is_owner>: #include #include bool _API_Mutex_Is_owner( const API_Mutex_Control *the_mutex ) { return the_mutex->Mutex._Mutex._Queue._owner == _Thread_Get_executing(); 400080a4: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED 400080a8: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2 <== NOT EXECUTED 400080ac: 82 18 40 02 xor %g1, %g2, %g1 } 400080b0: 80 a0 00 01 cmp %g0, %g1 400080b4: 81 c3 e0 08 retl 400080b8: 90 60 3f ff subx %g0, -1, %o0 =============================================================================== 40007084 <_API_Mutex_Lock>: #include #include void _API_Mutex_Lock( API_Mutex_Control *the_mutex ) { 40007084: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Thread_Life_state previous_thread_life_state; previous_thread_life_state = 40007088: 40 00 12 51 call 4000b9cc <_Thread_Set_life_protection> 4000708c: 90 10 20 01 mov 1, %o0 40007090: ba 10 00 08 mov %o0, %i5 _Thread_Set_life_protection( THREAD_LIFE_PROTECTED ); _Mutex_recursive_Acquire( &the_mutex->Mutex ); 40007094: 40 00 06 f7 call 40008c70 <_Mutex_recursive_Acquire> 40007098: 90 10 00 18 mov %i0, %o0 if ( the_mutex->Mutex._nest_level == 0 ) { 4000709c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 400070a0: 80 a0 60 00 cmp %g1, 0 400070a4: 22 80 00 02 be,a 400070ac <_API_Mutex_Lock+0x28> 400070a8: fa 26 20 18 st %i5, [ %i0 + 0x18 ] the_mutex->previous_thread_life_state = previous_thread_life_state; } } 400070ac: 81 c7 e0 08 ret 400070b0: 81 e8 00 00 restore =============================================================================== 400070b4 <_API_Mutex_Unlock>: #include #include void _API_Mutex_Unlock( API_Mutex_Control *the_mutex ) { 400070b4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Thread_Life_state previous_thread_life_state; bool restore_thread_life_protection; previous_thread_life_state = the_mutex->previous_thread_life_state; restore_thread_life_protection = the_mutex->Mutex._nest_level == 0; 400070b8: fa 06 20 14 ld [ %i0 + 0x14 ], %i5 <== NOT EXECUTED { 400070bc: 90 10 00 18 mov %i0, %o0 _Mutex_recursive_Release( &the_mutex->Mutex ); 400070c0: 40 00 07 11 call 40008d04 <_Mutex_recursive_Release> 400070c4: f0 06 20 18 ld [ %i0 + 0x18 ], %i0 if ( restore_thread_life_protection ) { 400070c8: 80 a7 60 00 cmp %i5, 0 400070cc: 02 80 00 04 be 400070dc <_API_Mutex_Unlock+0x28> 400070d0: 01 00 00 00 nop _Thread_Set_life_protection( previous_thread_life_state ); } } 400070d4: 81 c7 e0 08 ret 400070d8: 81 e8 00 00 restore _Thread_Set_life_protection( previous_thread_life_state ); 400070dc: 40 00 12 3c call 4000b9cc <_Thread_Set_life_protection> 400070e0: 81 e8 00 00 restore =============================================================================== 400098f0 <_CORE_RWLock_Initialize>: void _CORE_RWLock_Initialize( CORE_RWLock_Control *the_rwlock ) { the_rwlock->number_of_readers = 0; 400098f0: c0 22 20 18 clr [ %o0 + 0x18 ] <== NOT EXECUTED the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 400098f4: c0 22 20 14 clr [ %o0 + 0x14 ] <== NOT EXECUTED queue->heads = NULL; 400098f8: c0 22 20 08 clr [ %o0 + 8 ] <== NOT EXECUTED queue->owner = NULL; 400098fc: c0 22 20 0c clr [ %o0 + 0xc ] <== NOT EXECUTED _Thread_queue_Queue_initialize( &the_rwlock->Queue.Queue, NULL ); } 40009900: 81 c3 e0 08 retl <== NOT EXECUTED 40009904: c0 22 20 10 clr [ %o0 + 0x10 ] =============================================================================== 40009908 <_CORE_RWLock_Seize_for_reading>: Status_Control _CORE_RWLock_Seize_for_reading( CORE_RWLock_Control *the_rwlock, bool wait, Thread_queue_Context *queue_context ) { 40009908: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000990c: 91 d0 20 09 ta 9 <== NOT EXECUTED 40009910: c2 26 80 00 st %g1, [ %i2 ] * If any thread is waiting, then we wait. */ executing = _CORE_RWLock_Acquire( the_rwlock, queue_context ); switch ( the_rwlock->current_state ) { 40009914: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40009918: 80 a0 60 00 cmp %g1, 0 4000991c: 02 80 00 1f be 40009998 <_CORE_RWLock_Seize_for_reading+0x90> 40009920: 84 10 00 06 mov %g6, %g2 40009924: 80 a0 60 01 cmp %g1, 1 40009928: 12 80 00 06 bne 40009940 <_CORE_RWLock_Seize_for_reading+0x38> 4000992c: 80 a6 60 00 cmp %i1, 0 the_rwlock->number_of_readers += 1; _CORE_RWLock_Release( the_rwlock, queue_context ); return STATUS_SUCCESSFUL; case CORE_RWLOCK_LOCKED_FOR_READING: if ( _Thread_queue_Is_empty( &the_rwlock->Queue.Queue ) ) { 40009930: c2 06 20 08 ld [ %i0 + 8 ], %g1 40009934: 80 a0 60 00 cmp %g1, 0 40009938: 02 80 00 23 be 400099c4 <_CORE_RWLock_Seize_for_reading+0xbc> 4000993c: 80 a6 60 00 cmp %i1, 0 /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 40009940: 02 80 00 0f be 4000997c <_CORE_RWLock_Seize_for_reading+0x74> 40009944: 03 00 00 04 sethi %hi(0x1000), %g1 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; 40009948: fa 00 a0 20 ld [ %g2 + 0x20 ], %i5 /* * We need to wait to enter this critical section */ executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; 4000994c: c0 27 60 48 clr [ %i5 + 0x48 ] queue_context->thread_state = thread_state; 40009950: c2 26 a0 04 st %g1, [ %i2 + 4 ] _Thread_queue_Context_set_thread_state( queue_context, STATES_WAITING_FOR_RWLOCK ); _Thread_queue_Enqueue( 40009954: 90 06 20 08 add %i0, 8, %o0 40009958: 96 10 00 1a mov %i2, %o3 4000995c: 94 10 00 1d mov %i5, %o2 40009960: 13 10 00 52 sethi %hi(0x40014800), %o1 CORE_RWLOCK_TQ_OPERATIONS, executing, queue_context ); return _Thread_Wait_get_status( executing ); } 40009964: b0 10 20 00 clr %i0 _Thread_queue_Enqueue( 40009968: 40 00 11 a0 call 4000dfe8 <_Thread_queue_Enqueue> 4000996c: 92 12 61 54 or %o1, 0x154, %o1 40009970: f2 07 60 4c ld [ %i5 + 0x4c ], %i1 } 40009974: 81 c7 e0 08 ret 40009978: 81 e8 00 00 restore register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000997c: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009980: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40009984: 01 00 00 00 nop return STATUS_UNAVAILABLE; 40009988: 33 00 00 04 sethi %hi(0x1000), %i1 4000998c: b2 16 60 0d or %i1, 0xd, %i1 ! 100d <_Configuration_Interrupt_stack_size+0xd> } 40009990: 81 c7 e0 08 ret 40009994: 91 e8 20 00 restore %g0, 0, %o0 the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 40009998: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED 4000999c: c4 26 20 14 st %g2, [ %i0 + 0x14 ] <== NOT EXECUTED the_rwlock->number_of_readers += 1; 400099a0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED 400099a4: 82 00 60 01 inc %g1 <== NOT EXECUTED the_rwlock->number_of_readers += 1; 400099a8: c2 26 20 18 st %g1, [ %i0 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400099ac: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400099b0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400099b4: 01 00 00 00 nop return STATUS_SUCCESSFUL; 400099b8: b2 10 20 00 clr %i1 ! 0 } 400099bc: 81 c7 e0 08 ret 400099c0: 91 e8 20 00 restore %g0, 0, %o0 the_rwlock->number_of_readers += 1; 400099c4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 400099c8: 10 bf ff f8 b 400099a8 <_CORE_RWLock_Seize_for_reading+0xa0> 400099cc: 82 00 60 01 inc %g1 =============================================================================== 400099d0 <_CORE_RWLock_Seize_for_writing>: Status_Control _CORE_RWLock_Seize_for_writing( CORE_RWLock_Control *the_rwlock, bool wait, Thread_queue_Context *queue_context ) { 400099d0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400099d4: 91 d0 20 09 ta 9 <== NOT EXECUTED 400099d8: c2 26 80 00 st %g1, [ %i2 ] * If any thread is waiting, then we wait. */ executing = _CORE_RWLock_Acquire( the_rwlock, queue_context ); switch ( the_rwlock->current_state ) { 400099dc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 400099e0: 80 a0 60 00 cmp %g1, 0 400099e4: 02 80 00 19 be 40009a48 <_CORE_RWLock_Seize_for_writing+0x78> 400099e8: 80 a6 60 00 cmp %i1, 0 /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 400099ec: 02 80 00 10 be 40009a2c <_CORE_RWLock_Seize_for_writing+0x5c> 400099f0: 82 10 20 01 mov 1, %g1 400099f4: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5 /* * We need to wait to enter this critical section */ executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE; 400099f8: c2 27 60 48 st %g1, [ %i5 + 0x48 ] 400099fc: 03 00 00 04 sethi %hi(0x1000), %g1 40009a00: c2 26 a0 04 st %g1, [ %i2 + 4 ] _Thread_queue_Context_set_thread_state( queue_context, STATES_WAITING_FOR_RWLOCK ); _Thread_queue_Enqueue( 40009a04: 90 06 20 08 add %i0, 8, %o0 40009a08: 96 10 00 1a mov %i2, %o3 40009a0c: 94 10 00 1d mov %i5, %o2 40009a10: 13 10 00 52 sethi %hi(0x40014800), %o1 CORE_RWLOCK_TQ_OPERATIONS, executing, queue_context ); return _Thread_Wait_get_status( executing ); } 40009a14: b0 10 20 00 clr %i0 _Thread_queue_Enqueue( 40009a18: 40 00 11 74 call 4000dfe8 <_Thread_queue_Enqueue> 40009a1c: 92 12 61 54 or %o1, 0x154, %o1 40009a20: f2 07 60 4c ld [ %i5 + 0x4c ], %i1 } 40009a24: 81 c7 e0 08 ret 40009a28: 81 e8 00 00 restore register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40009a2c: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009a30: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40009a34: 01 00 00 00 nop return STATUS_UNAVAILABLE; 40009a38: 33 00 00 04 sethi %hi(0x1000), %i1 40009a3c: b2 16 60 0d or %i1, 0xd, %i1 ! 100d <_Configuration_Interrupt_stack_size+0xd> } 40009a40: 81 c7 e0 08 ret 40009a44: 91 e8 20 00 restore %g0, 0, %o0 the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 40009a48: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 40009a4c: c2 26 20 14 st %g1, [ %i0 + 0x14 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40009a50: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009a54: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40009a58: 01 00 00 00 nop return STATUS_SUCCESSFUL; 40009a5c: b2 10 20 00 clr %i1 ! 0 } 40009a60: 81 c7 e0 08 ret 40009a64: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 40009aec <_CORE_RWLock_Surrender>: Status_Control _CORE_RWLock_Surrender( CORE_RWLock_Control *the_rwlock ) { 40009aec: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40009af0: 91 d0 20 09 ta 9 <== NOT EXECUTED 40009af4: c2 27 bf dc st %g1, [ %fp + -36 ] */ _Thread_queue_Context_initialize( &queue_context ); _CORE_RWLock_Acquire( the_rwlock, &queue_context ); if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 40009af8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40009afc: 80 a0 60 00 cmp %g1, 0 40009b00: 02 80 00 14 be 40009b50 <_CORE_RWLock_Surrender+0x64> 40009b04: 80 a0 60 01 cmp %g1, 1 /* This is an error at the caller site */ _CORE_RWLock_Release( the_rwlock, &queue_context ); return STATUS_SUCCESSFUL; } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 40009b08: 32 80 00 08 bne,a 40009b28 <_CORE_RWLock_Surrender+0x3c> 40009b0c: c0 26 20 14 clr [ %i0 + 0x14 ] the_rwlock->number_of_readers -= 1; 40009b10: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 40009b14: 82 00 7f ff add %g1, -1, %g1 if ( the_rwlock->number_of_readers != 0 ) { 40009b18: 80 a0 60 00 cmp %g1, 0 40009b1c: 12 80 00 0d bne 40009b50 <_CORE_RWLock_Surrender+0x64> 40009b20: c2 26 20 18 st %g1, [ %i0 + 0x18 ] /* * Implicitly transition to "unlocked" and find another thread interested * in obtaining this rwlock. */ the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 40009b24: c0 26 20 14 clr [ %i0 + 0x14 ] _Thread_queue_Flush_critical( 40009b28: 96 07 bf dc add %fp, -36, %o3 40009b2c: 90 06 20 08 add %i0, 8, %o0 40009b30: 15 10 00 26 sethi %hi(0x40009800), %o2 40009b34: 13 10 00 52 sethi %hi(0x40014800), %o1 40009b38: 94 12 a2 68 or %o2, 0x268, %o2 40009b3c: 92 12 61 54 or %o1, 0x154, %o1 40009b40: 40 00 12 2b call 4000e3ec <_Thread_queue_Flush_critical> 40009b44: b0 10 20 00 clr %i0 CORE_RWLOCK_TQ_OPERATIONS, _CORE_RWLock_Flush_filter, &queue_context ); return STATUS_SUCCESSFUL; } 40009b48: 81 c7 e0 08 ret 40009b4c: 93 e8 20 00 restore %g0, 0, %o1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40009b50: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009b54: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40009b58: 01 00 00 00 nop 40009b5c: b0 10 20 00 clr %i0 ! 0 40009b60: 81 c7 e0 08 ret 40009b64: 93 e8 20 00 restore %g0, 0, %o1 =============================================================================== 4000effc <_CORE_barrier_Seize>: CORE_barrier_Control *the_barrier, Thread_Control *executing, bool wait, Thread_queue_Context *queue_context ) { 4000effc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED uint32_t number_of_waiting_threads; _CORE_barrier_Acquire_critical( the_barrier, queue_context ); number_of_waiting_threads = the_barrier->number_of_waiting_threads; 4000f000: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED ++number_of_waiting_threads; if ( 4000f004: c4 06 20 0c ld [ %i0 + 0xc ], %g2 <== NOT EXECUTED 4000f008: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000f00c: 12 80 00 06 bne 4000f024 <_CORE_barrier_Seize+0x28> <== NOT EXECUTED 4000f010: 82 00 60 01 inc %g1 _CORE_barrier_Is_automatic( &the_barrier->Attributes ) && number_of_waiting_threads == the_barrier->Attributes.maximum_count 4000f014: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 4000f018: 80 a0 80 01 cmp %g2, %g1 4000f01c: 02 80 00 0e be 4000f054 <_CORE_barrier_Seize+0x58> 4000f020: 94 10 00 1b mov %i3, %o2 ) { _CORE_barrier_Surrender( the_barrier, queue_context ); return STATUS_BARRIER_AUTOMATICALLY_RELEASED; } else { the_barrier->number_of_waiting_threads = number_of_waiting_threads; 4000f024: c2 26 20 14 st %g1, [ %i0 + 0x14 ] queue_context->thread_state = thread_state; 4000f028: 82 10 28 00 mov 0x800, %g1 4000f02c: c2 26 e0 04 st %g1, [ %i3 + 4 ] _Thread_queue_Context_set_thread_state( queue_context, STATES_WAITING_FOR_BARRIER ); _Thread_queue_Enqueue( 4000f030: 94 10 00 19 mov %i1, %o2 4000f034: 96 10 00 1b mov %i3, %o3 4000f038: 90 10 00 18 mov %i0, %o0 4000f03c: 13 10 00 65 sethi %hi(0x40019400), %o1 4000f040: 7f ff ef 6b call 4000adec <_Thread_queue_Enqueue> 4000f044: 92 12 61 f8 or %o1, 0x1f8, %o1 ! 400195f8 <_Thread_queue_Operations_FIFO> return (Status_Control) the_thread->Wait.return_code; 4000f048: f2 06 60 4c ld [ %i1 + 0x4c ], %i1 executing, queue_context ); return _Thread_Wait_get_status( executing ); } } 4000f04c: 81 c7 e0 08 ret 4000f050: 91 e8 20 00 restore %g0, 0, %o0 4000f054: 90 10 00 18 mov %i0, %o0 4000f058: 13 10 00 3e sethi %hi(0x4000f800), %o1 return STATUS_BARRIER_AUTOMATICALLY_RELEASED; 4000f05c: b2 10 3f 00 mov -256, %i1 4000f060: 7f ff ff df call 4000efdc <_CORE_barrier_Do_flush> 4000f064: 92 12 62 bc or %o1, 0x2bc, %o1 4000f068: 30 bf ff f9 b,a 4000f04c <_CORE_barrier_Seize+0x50> =============================================================================== 40009ed8 <_CORE_message_queue_Broadcast>: const void *buffer, size_t size, uint32_t *count, Thread_queue_Context *queue_context ) { 40009ed8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Thread_Control *the_thread; uint32_t number_broadcasted; if ( size > the_message_queue->maximum_message_size ) { 40009edc: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED 40009ee0: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED 40009ee4: 0a 80 00 2a bcs 40009f8c <_CORE_message_queue_Broadcast+0xb4> <== NOT EXECUTED 40009ee8: 01 00 00 00 nop * * NOTE: This check is critical because threads can block on * send and receive and this ensures that we are broadcasting * the message to threads waiting to receive -- not to send. */ if ( the_message_queue->number_of_pending_messages != 0 ) { 40009eec: e0 06 20 14 ld [ %i0 + 0x14 ], %l0 40009ef0: 80 a4 20 00 cmp %l0, 0 40009ef4: 32 80 00 1f bne,a 40009f70 <_CORE_message_queue_Broadcast+0x98> 40009ef8: a0 10 20 00 clr %l0 40009efc: d0 06 00 00 ld [ %i0 ], %o0 const Thread_queue_Operations *operations ) { Thread_queue_Heads *heads = the_thread_queue->Queue.heads; if ( heads != NULL ) { 40009f00: 80 a2 20 00 cmp %o0, 0 40009f04: 02 80 00 1b be 40009f70 <_CORE_message_queue_Broadcast+0x98> 40009f08: c2 06 20 0c ld [ %i0 + 0xc ], %g1 return ( *operations->first )( heads ); 40009f0c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 40009f10: 9f c0 40 00 call %g1 40009f14: 01 00 00 00 nop memcpy(destination, source, size); 40009f18: 92 10 00 19 mov %i1, %o1 40009f1c: ba 10 00 08 mov %o0, %i5 */ the_thread = _Thread_queue_First_locked( &the_message_queue->Wait_queue, the_message_queue->operations ); if ( the_thread == NULL ) { 40009f20: 80 a2 20 00 cmp %o0, 0 40009f24: 02 80 00 13 be 40009f70 <_CORE_message_queue_Broadcast+0x98> <== NEVER TAKEN 40009f28: 94 10 00 1a mov %i2, %o2 return NULL; } *(size_t *) the_thread->Wait.return_argument = size; 40009f2c: c2 02 20 40 ld [ %o0 + 0x40 ], %g1 40009f30: f4 20 40 00 st %i2, [ %g1 ] 0, queue_context ) ) ) { number_broadcasted += 1; 40009f34: a0 04 20 01 inc %l0 the_thread->Wait.count = (uint32_t) submit_type; 40009f38: c0 22 20 3c clr [ %o0 + 0x3c ] memcpy(destination, source, size); 40009f3c: 40 00 21 6c call 400124ec 40009f40: d0 02 20 44 ld [ %o0 + 0x44 ], %o0 buffer, the_thread->Wait.return_argument_second.mutable_object, size ); _Thread_queue_Extract_critical( 40009f44: d2 06 20 0c ld [ %i0 + 0xc ], %o1 40009f48: 96 10 00 1c mov %i4, %o3 40009f4c: 94 10 00 1d mov %i5, %o2 40009f50: 40 00 11 b9 call 4000e634 <_Thread_queue_Extract_critical> 40009f54: 90 10 00 18 mov %i0, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40009f58: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 40009f5c: c2 27 00 00 st %g1, [ %i4 ] if ( the_message_queue->number_of_pending_messages != 0 ) { 40009f60: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40009f64: 80 a0 60 00 cmp %g1, 0 40009f68: 22 bf ff e6 be,a 40009f00 <_CORE_message_queue_Broadcast+0x28> <== ALWAYS TAKEN 40009f6c: d0 06 00 00 ld [ %i0 ], %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40009f70: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009f74: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40009f78: 01 00 00 00 nop } _CORE_message_queue_Release( the_message_queue, queue_context ); *count = number_broadcasted; return STATUS_SUCCESSFUL; 40009f7c: b0 10 20 00 clr %i0 ! 0 *count = number_broadcasted; 40009f80: e0 26 c0 00 st %l0, [ %i3 ] } 40009f84: 81 c7 e0 08 ret 40009f88: 93 e8 20 00 restore %g0, 0, %o1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40009f8c: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009f90: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40009f94: 01 00 00 00 nop return STATUS_MESSAGE_INVALID_SIZE; 40009f98: 33 00 00 1e sethi %hi(0x7800), %i1 40009f9c: b2 16 62 08 or %i1, 0x208, %i1 ! 7a08 <_Configuration_Interrupt_stack_size+0x6a08> 40009fa0: 81 c7 e0 08 ret 40009fa4: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 40009fdc <_CORE_message_queue_Flush>: uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue, Thread_queue_Context *queue_context ) { 40009fdc: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED * fixed execution time that only deals with pending messages. */ _CORE_message_queue_Acquire_critical( the_message_queue, queue_context ); count = the_message_queue->number_of_pending_messages; 40009fe0: d0 02 20 14 ld [ %o0 + 0x14 ], %o0 <== NOT EXECUTED if ( count != 0 ) { 40009fe4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40009fe8: 02 80 00 0f be 4000a024 <_CORE_message_queue_Flush+0x48> <== NOT EXECUTED 40009fec: 96 00 60 30 add %g1, 0x30, %o3 return _Chain_Immutable_head( the_chain )->next; 40009ff0: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 the_message_queue->number_of_pending_messages = 0; inactive_head = _Chain_Head( &the_message_queue->Inactive_messages ); inactive_first = inactive_head->next; 40009ff4: c6 00 60 30 ld [ %g1 + 0x30 ], %g3 return _Chain_Immutable_tail( the_chain )->previous; 40009ff8: c8 00 60 24 ld [ %g1 + 0x24 ], %g4 the_message_queue->number_of_pending_messages = 0; 40009ffc: c0 20 60 14 clr [ %g1 + 0x14 ] message_queue_first = _Chain_First( &the_message_queue->Pending_messages ); message_queue_last = _Chain_Last( &the_message_queue->Pending_messages ); inactive_head->next = message_queue_first; 4000a000: c4 20 60 30 st %g2, [ %g1 + 0x30 ] <== NOT EXECUTED return &the_chain->Tail.Node; 4000a004: 9a 00 60 1c add %g1, 0x1c, %o5 <== NOT EXECUTED message_queue_last->next = inactive_first; 4000a008: c6 21 00 00 st %g3, [ %g4 ] <== NOT EXECUTED 4000a00c: 98 00 60 20 add %g1, 0x20, %o4 <== NOT EXECUTED inactive_first->previous = message_queue_last; 4000a010: c8 20 e0 04 st %g4, [ %g3 + 4 ] <== NOT EXECUTED message_queue_first->previous = inactive_head; 4000a014: d6 20 a0 04 st %o3, [ %g2 + 4 ] <== NOT EXECUTED head->next = tail; 4000a018: d8 20 60 1c st %o4, [ %g1 + 0x1c ] <== NOT EXECUTED head->previous = NULL; 4000a01c: c0 20 60 20 clr [ %g1 + 0x20 ] <== NOT EXECUTED tail->previous = head; 4000a020: da 20 60 24 st %o5, [ %g1 + 0x24 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000a024: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000a028: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000a02c: 01 00 00 00 nop _Chain_Initialize_empty( &the_message_queue->Pending_messages ); } _CORE_message_queue_Release( the_message_queue, queue_context ); return count; } 4000a030: 81 c3 e0 08 retl 4000a034: 01 00 00 00 nop =============================================================================== 400108f8 <_CORE_message_queue_Initialize>: CORE_message_queue_Control *the_message_queue, CORE_message_queue_Disciplines discipline, uint32_t maximum_pending_messages, size_t maximum_message_size ) { 400108f8: 9d e3 bf a0 save %sp, -96, %sp size_t message_buffering_required = 0; size_t aligned_message_size; size_t align_mask; the_message_queue->maximum_pending_messages = maximum_pending_messages; the_message_queue->number_of_pending_messages = 0; 400108fc: c0 26 20 14 clr [ %i0 + 0x14 ] /* * Align up the maximum message size to be an integral multiple of the * pointer size. */ align_mask = sizeof(uintptr_t) - 1; aligned_message_size = ( maximum_message_size + align_mask ) & ~align_mask; 40010900: 96 06 e0 03 add %i3, 3, %o3 the_message_queue->maximum_pending_messages = maximum_pending_messages; 40010904: f4 26 20 10 st %i2, [ %i0 + 0x10 ] aligned_message_size = ( maximum_message_size + align_mask ) & ~align_mask; 40010908: 96 0a ff fc and %o3, -4, %o3 the_message_queue->maximum_message_size = maximum_message_size; 4001090c: f6 26 20 18 st %i3, [ %i0 + 0x18 ] /* * Check for an integer overflow. It can occur while aligning up the maximum * message size. */ if (aligned_message_size < maximum_message_size) 40010910: 80 a6 c0 0b cmp %i3, %o3 40010914: 18 80 00 08 bgu 40010934 <_CORE_message_queue_Initialize+0x3c> <== NEVER TAKEN 40010918: c0 26 20 2c clr [ %i0 + 0x2c ] /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ if ( !size_t_mult32_with_overflow( 4001091c: ba 02 e0 14 add %o3, 0x14, %i5 long long x = (long long)a*b; 40010920: 86 56 80 1d umul %i2, %i5, %g3 40010924: 85 40 00 00 rd %y, %g2 if ( x > SIZE_MAX ) 40010928: 80 a0 a0 00 cmp %g2, 0 4001092c: 04 80 00 06 ble 40010944 <_CORE_message_queue_Initialize+0x4c> 40010930: 01 00 00 00 nop return false; 40010934: 82 10 20 00 clr %g1 ! 0 } else { the_message_queue->operations = &_Thread_queue_Operations_FIFO; } return true; } 40010938: b0 08 60 01 and %g1, 1, %i0 4001093c: 81 c7 e0 08 ret 40010940: 81 e8 00 00 restore _Workspace_Allocate( message_buffering_required ); 40010944: 40 00 1a 5a call 400172ac <_Workspace_Allocate> 40010948: 90 10 00 03 mov %g3, %o0 if (the_message_queue->message_buffers == 0) 4001094c: 80 a2 20 00 cmp %o0, 0 40010950: 02 bf ff f9 be 40010934 <_CORE_message_queue_Initialize+0x3c> 40010954: d0 26 20 28 st %o0, [ %i0 + 0x28 ] _Chain_Initialize ( 40010958: 92 10 00 08 mov %o0, %o1 4001095c: 96 10 00 1d mov %i5, %o3 40010960: 94 10 00 1a mov %i2, %o2 40010964: 7f ff ff 98 call 400107c4 <_Chain_Initialize> 40010968: 90 06 20 30 add %i0, 0x30, %o0 4001096c: 82 06 20 1c add %i0, 0x1c, %g1 40010970: 84 06 20 20 add %i0, 0x20, %g2 head->previous = NULL; 40010974: c0 26 20 20 clr [ %i0 + 0x20 ] _Thread_queue_Object_initialize( &the_message_queue->Wait_queue ); 40010978: 90 10 00 18 mov %i0, %o0 head->next = tail; 4001097c: c4 26 20 1c st %g2, [ %i0 + 0x1c ] 40010980: 40 00 13 2d call 40015634 <_Thread_queue_Object_initialize> 40010984: c2 26 20 24 st %g1, [ %i0 + 0x24 ] if ( discipline == CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY ) { 40010988: 80 a6 60 01 cmp %i1, 1 4001098c: 02 80 00 07 be 400109a8 <_CORE_message_queue_Initialize+0xb0> 40010990: 05 10 00 6e sethi %hi(0x4001b800), %g2 the_message_queue->operations = &_Thread_queue_Operations_FIFO; 40010994: 03 10 00 6e sethi %hi(0x4001b800), %g1 40010998: 82 10 61 34 or %g1, 0x134, %g1 ! 4001b934 <_Thread_queue_Operations_FIFO> 4001099c: c2 26 20 0c st %g1, [ %i0 + 0xc ] return true; 400109a0: 10 bf ff e6 b 40010938 <_CORE_message_queue_Initialize+0x40> 400109a4: 82 10 20 01 mov 1, %g1 400109a8: 82 10 20 01 mov 1, %g1 the_message_queue->operations = &_Thread_queue_Operations_priority; 400109ac: 84 10 a1 20 or %g2, 0x120, %g2 400109b0: 10 bf ff e2 b 40010938 <_CORE_message_queue_Initialize+0x40> 400109b4: c4 26 20 0c st %g2, [ %i0 + 0xc ] =============================================================================== 400109b8 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Thread_queue_Context *queue_context ) { 400109b8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 400109bc: e0 06 20 1c ld [ %i0 + 0x1c ], %l0 <== NOT EXECUTED return &the_chain->Tail.Node; 400109c0: 82 06 20 20 add %i0, 0x20, %g1 <== NOT EXECUTED if ( !_Chain_Is_empty(the_chain)) 400109c4: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 400109c8: 02 80 00 33 be 40010a94 <_CORE_message_queue_Seize+0xdc> <== NOT EXECUTED 400109cc: 86 06 20 1c add %i0, 0x1c, %g3 new_first = old_first->next; 400109d0: c4 04 00 00 ld [ %l0 ], %g2 head->next = new_first; 400109d4: c4 26 20 1c st %g2, [ %i0 + 0x1c ] const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 400109d8: 92 04 20 10 add %l0, 0x10, %o1 CORE_message_queue_Buffer_control *the_message; the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { the_message_queue->number_of_pending_messages -= 1; 400109dc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 new_first->previous = head; 400109e0: c6 20 a0 04 st %g3, [ %g2 + 4 ] 400109e4: 82 00 7f ff add %g1, -1, %g1 *size_p = the_message->Contents.size; 400109e8: c4 04 20 0c ld [ %l0 + 0xc ], %g2 the_message_queue->number_of_pending_messages -= 1; 400109ec: c2 26 20 14 st %g1, [ %i0 + 0x14 ] 400109f0: 94 10 00 02 mov %g2, %o2 *size_p = the_message->Contents.size; 400109f4: c4 26 c0 00 st %g2, [ %i3 ] 400109f8: 90 10 00 1a mov %i2, %o0 executing->Wait.count = 400109fc: c2 04 20 08 ld [ %l0 + 8 ], %g1 40010a00: 40 00 21 7e call 40018ff8 40010a04: c2 26 60 3c st %g1, [ %i1 + 0x3c ] 40010a08: d0 06 00 00 ld [ %i0 ], %o0 if ( heads != NULL ) { 40010a0c: 80 a2 20 00 cmp %o0, 0 40010a10: 02 80 00 15 be 40010a64 <_CORE_message_queue_Seize+0xac> 40010a14: c2 06 20 0c ld [ %i0 + 0xc ], %g1 return ( *operations->first )( heads ); 40010a18: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 40010a1c: 9f c0 40 00 call %g1 40010a20: 01 00 00 00 nop */ the_thread = _Thread_queue_First_locked( &the_message_queue->Wait_queue, the_message_queue->operations ); if ( the_thread == NULL ) { 40010a24: b8 92 20 00 orcc %o0, 0, %i4 40010a28: 02 80 00 0f be 40010a64 <_CORE_message_queue_Seize+0xac> <== NEVER TAKEN 40010a2c: 92 10 00 10 mov %l0, %o1 /* * There was a thread waiting to send a message. This code * puts the messages in the message queue on behalf of the * waiting task. */ _CORE_message_queue_Insert_message( 40010a30: d8 07 20 3c ld [ %i4 + 0x3c ], %o4 40010a34: d6 07 20 48 ld [ %i4 + 0x48 ], %o3 40010a38: d4 07 20 44 ld [ %i4 + 0x44 ], %o2 40010a3c: 40 00 1f d1 call 40018980 <_CORE_message_queue_Insert_message> 40010a40: 90 10 00 18 mov %i0, %o0 the_message, the_thread->Wait.return_argument_second.immutable_object, (size_t) the_thread->Wait.option, (CORE_message_queue_Submit_types) the_thread->Wait.count ); _Thread_queue_Extract_critical( 40010a44: d2 06 20 0c ld [ %i0 + 0xc ], %o1 40010a48: 90 10 00 18 mov %i0, %o0 40010a4c: 96 10 00 1d mov %i5, %o3 40010a50: 94 10 00 1c mov %i4, %o2 40010a54: 40 00 11 fe call 4001524c <_Thread_queue_Extract_critical> 40010a58: b2 10 20 00 clr %i1 the_message_queue->operations, executing, queue_context ); return _Thread_Wait_get_status( executing ); } 40010a5c: 81 c7 e0 08 ret 40010a60: 91 e8 20 00 restore %g0, 0, %o0 old_last = tail->previous; 40010a64: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 return &the_chain->Tail.Node; 40010a68: 84 06 20 34 add %i0, 0x34, %g2 the_node->next = tail; 40010a6c: c4 24 00 00 st %g2, [ %l0 ] tail->previous = the_node; 40010a70: e0 26 20 38 st %l0, [ %i0 + 0x38 ] old_last->next = the_node; 40010a74: e0 20 40 00 st %l0, [ %g1 ] the_node->previous = old_last; 40010a78: c2 24 20 04 st %g1, [ %l0 + 4 ] register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40010a7c: c2 07 40 00 ld [ %i5 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40010a80: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40010a84: 01 00 00 00 nop return STATUS_SUCCESSFUL; 40010a88: b2 10 20 00 clr %i1 ! 0 } 40010a8c: 81 c7 e0 08 ret 40010a90: 91 e8 20 00 restore %g0, 0, %o0 if ( !wait ) { 40010a94: 80 a7 20 00 cmp %i4, 0 40010a98: 32 80 00 08 bne,a 40010ab8 <_CORE_message_queue_Seize+0x100> 40010a9c: f4 26 60 44 st %i2, [ %i1 + 0x44 ] register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40010aa0: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40010aa4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40010aa8: 01 00 00 00 nop return STATUS_UNSATISFIED; 40010aac: b2 10 2b 0d mov 0xb0d, %i1 ! b0d } 40010ab0: 81 c7 e0 08 ret 40010ab4: 91 e8 20 00 restore %g0, 0, %o0 queue_context->thread_state = thread_state; 40010ab8: 82 10 20 10 mov 0x10, %g1 executing->Wait.return_argument = size_p; 40010abc: f6 26 60 40 st %i3, [ %i1 + 0x40 ] _Thread_queue_Enqueue( 40010ac0: 94 10 00 19 mov %i1, %o2 40010ac4: c2 27 60 04 st %g1, [ %i5 + 4 ] 40010ac8: 90 10 00 18 mov %i0, %o0 40010acc: d2 06 20 0c ld [ %i0 + 0xc ], %o1 40010ad0: 96 10 00 1d mov %i5, %o3 40010ad4: 40 00 11 68 call 40015074 <_Thread_queue_Enqueue> 40010ad8: b0 10 20 00 clr %i0 return (Status_Control) the_thread->Wait.return_code; 40010adc: f2 06 60 4c ld [ %i1 + 0x4c ], %i1 } 40010ae0: 81 c7 e0 08 ret 40010ae4: 81 e8 00 00 restore =============================================================================== 40010ae8 <_CORE_message_queue_Submit>: size_t size, CORE_message_queue_Submit_types submit_type, bool wait, Thread_queue_Context *queue_context ) { 40010ae8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 40010aec: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED 40010af0: 80 a0 40 1b cmp %g1, %i3 <== NOT EXECUTED 40010af4: 0a 80 00 1e bcs 40010b6c <_CORE_message_queue_Submit+0x84> <== NOT EXECUTED 40010af8: 01 00 00 00 nop * * NOTE: This check is critical because threads can block on * send and receive and this ensures that we are broadcasting * the message to threads waiting to receive -- not to send. */ if ( the_message_queue->number_of_pending_messages != 0 ) { 40010afc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40010b00: 80 a0 60 00 cmp %g1, 0 40010b04: 32 80 00 23 bne,a 40010b90 <_CORE_message_queue_Submit+0xa8> 40010b08: d2 06 20 30 ld [ %i0 + 0x30 ], %o1 40010b0c: d0 06 00 00 ld [ %i0 ], %o0 if ( heads != NULL ) { 40010b10: 80 a2 20 00 cmp %o0, 0 40010b14: 02 80 00 1e be 40010b8c <_CORE_message_queue_Submit+0xa4> 40010b18: c2 06 20 0c ld [ %i0 + 0xc ], %g1 return ( *operations->first )( heads ); 40010b1c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 40010b20: 9f c0 40 00 call %g1 40010b24: 01 00 00 00 nop */ the_thread = _Thread_queue_First_locked( &the_message_queue->Wait_queue, the_message_queue->operations ); if ( the_thread == NULL ) { 40010b28: a0 92 20 00 orcc %o0, 0, %l0 40010b2c: 02 80 00 18 be 40010b8c <_CORE_message_queue_Submit+0xa4> <== NEVER TAKEN 40010b30: 92 10 00 1a mov %i2, %o1 return NULL; } *(size_t *) the_thread->Wait.return_argument = size; 40010b34: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 40010b38: f6 20 40 00 st %i3, [ %g1 ] the_thread->Wait.count = (uint32_t) submit_type; 40010b3c: f8 24 20 3c st %i4, [ %l0 + 0x3c ] memcpy(destination, source, size); 40010b40: 94 10 00 1b mov %i3, %o2 40010b44: 40 00 21 2d call 40018ff8 40010b48: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 buffer, the_thread->Wait.return_argument_second.mutable_object, size ); _Thread_queue_Extract_critical( 40010b4c: d6 07 a0 5c ld [ %fp + 0x5c ], %o3 40010b50: d2 06 20 0c ld [ %i0 + 0xc ], %o1 40010b54: 94 10 00 10 mov %l0, %o2 40010b58: 90 10 00 18 mov %i0, %o0 40010b5c: 40 00 11 bc call 4001524c <_Thread_queue_Extract_critical> 40010b60: b2 10 20 00 clr %i1 executing, queue_context ); return _Thread_Wait_get_status( executing ); #endif } 40010b64: 81 c7 e0 08 ret 40010b68: 91 e8 20 00 restore %g0, 0, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40010b6c: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 <== NOT EXECUTED 40010b70: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40010b74: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40010b78: 01 00 00 00 nop return STATUS_MESSAGE_INVALID_SIZE; 40010b7c: 33 00 00 1e sethi %hi(0x7800), %i1 40010b80: b2 16 62 08 or %i1, 0x208, %i1 ! 7a08 <_Configuration_Interrupt_stack_size+0x6a08> } 40010b84: 81 c7 e0 08 ret 40010b88: 91 e8 20 00 restore %g0, 0, %o0 return _Chain_Immutable_head( the_chain )->next; 40010b8c: d2 06 20 30 ld [ %i0 + 0x30 ], %o1 return &the_chain->Tail.Node; 40010b90: 82 06 20 34 add %i0, 0x34, %g1 if ( !_Chain_Is_empty(the_chain)) 40010b94: 80 a2 40 01 cmp %o1, %g1 40010b98: 02 80 00 14 be 40010be8 <_CORE_message_queue_Submit+0x100> 40010b9c: 84 06 20 30 add %i0, 0x30, %g2 new_first = old_first->next; 40010ba0: c2 02 40 00 ld [ %o1 ], %g1 head->next = new_first; 40010ba4: c2 26 20 30 st %g1, [ %i0 + 0x30 ] _CORE_message_queue_Insert_message( 40010ba8: 98 10 00 1c mov %i4, %o4 new_first->previous = head; 40010bac: c4 20 60 04 st %g2, [ %g1 + 4 ] 40010bb0: 96 10 00 1b mov %i3, %o3 40010bb4: 94 10 00 1a mov %i2, %o2 40010bb8: 40 00 1f 72 call 40018980 <_CORE_message_queue_Insert_message> 40010bbc: 90 10 00 18 mov %i0, %o0 if ( 40010bc0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40010bc4: 80 a0 60 01 cmp %g1, 1 40010bc8: 22 80 00 1c be,a 40010c38 <_CORE_message_queue_Submit+0x150> 40010bcc: c2 06 20 2c ld [ %i0 + 0x2c ], %g1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40010bd0: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 <== NOT EXECUTED 40010bd4: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40010bd8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40010bdc: 01 00 00 00 nop return STATUS_SUCCESSFUL; 40010be0: 10 bf ff e1 b 40010b64 <_CORE_message_queue_Submit+0x7c> 40010be4: b2 10 20 00 clr %i1 ! 0 if ( !wait ) { 40010be8: 80 a7 60 00 cmp %i5, 0 40010bec: 02 80 00 0d be 40010c20 <_CORE_message_queue_Submit+0x138> 40010bf0: 01 00 00 00 nop if ( _ISR_Is_in_progress() ) { 40010bf4: 40 00 05 93 call 40012240 <_ISR_Is_in_progress> 40010bf8: 01 00 00 00 nop 40010bfc: 80 a2 20 00 cmp %o0, 0 40010c00: 22 80 00 15 be,a 40010c54 <_CORE_message_queue_Submit+0x16c> 40010c04: f4 26 60 44 st %i2, [ %i1 + 0x44 ] register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40010c08: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 <== NOT EXECUTED 40010c0c: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40010c10: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40010c14: 01 00 00 00 nop return STATUS_MESSAGE_QUEUE_WAIT_IN_ISR; 40010c18: 10 bf ff d3 b 40010b64 <_CORE_message_queue_Submit+0x7c> 40010c1c: b2 10 2c 0d mov 0xc0d, %i1 ! c0d register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40010c20: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 <== NOT EXECUTED 40010c24: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40010c28: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40010c2c: 01 00 00 00 nop return STATUS_TOO_MANY; 40010c30: 10 bf ff cd b 40010b64 <_CORE_message_queue_Submit+0x7c> 40010c34: b2 10 2b 05 mov 0xb05, %i1 ! b05 && the_message_queue->notify_handler != NULL 40010c38: 80 a0 60 00 cmp %g1, 0 40010c3c: 02 bf ff e5 be 40010bd0 <_CORE_message_queue_Submit+0xe8> 40010c40: d2 07 a0 5c ld [ %fp + 0x5c ], %o1 ( *the_message_queue->notify_handler )( 40010c44: 90 10 00 18 mov %i0, %o0 40010c48: 9f c0 40 00 call %g1 40010c4c: b2 10 20 00 clr %i1 40010c50: 30 bf ff c5 b,a 40010b64 <_CORE_message_queue_Submit+0x7c> queue_context->thread_state = thread_state; 40010c54: 82 10 20 10 mov 0x10, %g1 executing->Wait.option = (uint32_t) size; 40010c58: f6 26 60 48 st %i3, [ %i1 + 0x48 ] _Thread_queue_Enqueue( 40010c5c: 94 10 00 19 mov %i1, %o2 executing->Wait.count = submit_type; 40010c60: f8 26 60 3c st %i4, [ %i1 + 0x3c ] _Thread_queue_Enqueue( 40010c64: 90 10 00 18 mov %i0, %o0 40010c68: d6 07 a0 5c ld [ %fp + 0x5c ], %o3 40010c6c: c2 22 e0 04 st %g1, [ %o3 + 4 ] 40010c70: 40 00 11 01 call 40015074 <_Thread_queue_Enqueue> 40010c74: d2 06 20 0c ld [ %i0 + 0xc ], %o1 return _Thread_Wait_get_status( executing ); 40010c78: 10 bf ff bb b 40010b64 <_CORE_message_queue_Submit+0x7c> 40010c7c: f2 06 60 4c ld [ %i1 + 0x4c ], %i1 =============================================================================== 4000cb84 <_CORE_mutex_Seize_slow>: const Thread_queue_Operations *operations, Thread_Control *executing, bool wait, Thread_queue_Context *queue_context ) { 4000cb84: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED if ( wait ) { 4000cb88: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 4000cb8c: 02 80 00 0f be 4000cbc8 <_CORE_mutex_Seize_slow+0x44> <== NOT EXECUTED 4000cb90: 82 10 20 01 mov 1, %g1 4000cb94: c2 27 20 04 st %g1, [ %i4 + 4 ] queue_context->deadlock_callout = deadlock_callout; 4000cb98: 03 10 00 43 sethi %hi(0x40010c00), %g1 4000cb9c: 82 10 62 b8 or %g1, 0x2b8, %g1 ! 40010eb8 <_Thread_queue_Deadlock_status> 4000cba0: c2 27 20 20 st %g1, [ %i4 + 0x20 ] ); _Thread_queue_Context_set_deadlock_callout( queue_context, _Thread_queue_Deadlock_status ); _Thread_queue_Enqueue( 4000cba4: 92 10 00 19 mov %i1, %o1 4000cba8: 90 10 00 18 mov %i0, %o0 4000cbac: 96 10 00 1c mov %i4, %o3 4000cbb0: 94 10 00 1a mov %i2, %o2 4000cbb4: 40 00 10 c9 call 40010ed8 <_Thread_queue_Enqueue> 4000cbb8: b0 10 20 00 clr %i0 return (Status_Control) the_thread->Wait.return_code; 4000cbbc: f2 06 a0 4c ld [ %i2 + 0x4c ], %i1 return _Thread_Wait_get_status( executing ); } else { _CORE_mutex_Release( the_mutex, queue_context ); return STATUS_UNAVAILABLE; } } 4000cbc0: 81 c7 e0 08 ret 4000cbc4: 81 e8 00 00 restore register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000cbc8: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000cbcc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000cbd0: 01 00 00 00 nop return STATUS_UNAVAILABLE; 4000cbd4: 33 00 00 04 sethi %hi(0x1000), %i1 4000cbd8: b2 16 60 0d or %i1, 0xd, %i1 ! 100d <_Configuration_Interrupt_stack_size+0xd> } 4000cbdc: 81 c7 e0 08 ret 4000cbe0: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 4000cbe4 <_CORE_semaphore_Initialize>: void _CORE_semaphore_Initialize( CORE_semaphore_Control *the_semaphore, uint32_t initial_value ) { the_semaphore->count = initial_value; 4000cbe4: d2 22 20 0c st %o1, [ %o0 + 0xc ] <== NOT EXECUTED _Thread_queue_Object_initialize( &the_semaphore->Wait_queue ); 4000cbe8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4000cbec: 40 00 12 2b call 40011498 <_Thread_queue_Object_initialize> <== NOT EXECUTED 4000cbf0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 40009bb0 <_Chain_Node_count_unprotected>: return _Chain_Immutable_head( the_chain )->next; 40009bb0: c2 02 00 00 ld [ %o0 ], %g1 return &the_chain->Tail.Node; 40009bb4: 84 02 20 04 add %o0, 4, %g2 { size_t count = 0; const Chain_Node *tail = _Chain_Immutable_tail( chain ); const Chain_Node *node = _Chain_Immutable_first( chain ); while ( node != tail ) { 40009bb8: 80 a0 80 01 cmp %g2, %g1 40009bbc: 02 80 00 06 be 40009bd4 <_Chain_Node_count_unprotected+0x24> <== NEVER TAKEN 40009bc0: 90 10 20 00 clr %o0 40009bc4: c2 00 40 00 ld [ %g1 ], %g1 40009bc8: 80 a0 80 01 cmp %g2, %g1 40009bcc: 12 bf ff fe bne 40009bc4 <_Chain_Node_count_unprotected+0x14> 40009bd0: 90 02 20 01 inc %o0 40009bd4: 81 c3 e0 08 retl 40009bd8: 01 00 00 00 nop =============================================================================== 40014154 <_Condition_Broadcast>: _Condition_Wake( _condition, 1 ); } void _Condition_Broadcast( struct _Condition_Control *_condition ) { _Condition_Wake( _condition, INT_MAX ); 40014154: 13 1f ff ff sethi %hi(0x7ffffc00), %o1 <== NOT EXECUTED 40014158: 92 12 63 ff or %o1, 0x3ff, %o1 ! 7fffffff <== NOT EXECUTED 4001415c: 82 13 c0 00 mov %o7, %g1 40014160: 7f ff ff d5 call 400140b4 <_Condition_Wake> 40014164: 9e 10 40 00 mov %g1, %o7 =============================================================================== 4001005c <_Condition_Signal>: void _Condition_Signal( struct _Condition_Control *_condition ) { _Condition_Wake( _condition, 1 ); 4001005c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40010060: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 40010064: 7f ff ff b9 call 4000ff48 <_Condition_Wake> <== NOT EXECUTED 40010068: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 40014108 <_Condition_Wait>: { 40014108: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED queue_context->enqueue_callout = enqueue_callout; 4001410c: 03 10 00 50 sethi %hi(0x40014000), %g1 <== NOT EXECUTED context->mutex = _mutex; 40014110: f2 27 bf fc st %i1, [ %fp + -4 ] <== NOT EXECUTED 40014114: 82 10 60 a4 or %g1, 0xa4, %g1 <== NOT EXECUTED 40014118: c2 27 bf e0 st %g1, [ %fp + -32 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4001411c: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( &context->Base.Lock_context.Lock_context ); 40014120: c2 27 bf d8 st %g1, [ %fp + -40 ] queue_context->thread_state = thread_state; 40014124: 82 10 20 20 mov 0x20, %g1 _Thread_queue_Enqueue( 40014128: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2 4001412c: 90 06 20 08 add %i0, 8, %o0 40014130: 96 07 bf d8 add %fp, -40, %o3 40014134: c2 27 bf dc st %g1, [ %fp + -36 ] 40014138: 13 10 00 8d sethi %hi(0x40023400), %o1 4001413c: 7f ff e5 bd call 4000d830 <_Thread_queue_Enqueue> 40014140: 92 12 61 b8 or %o1, 0x1b8, %o1 ! 400235b8 <_Thread_queue_Operations_FIFO> _Mutex_Acquire( _mutex ); 40014144: 7f ff de 0a call 4000b96c <_Mutex_Acquire> 40014148: 90 10 00 19 mov %i1, %o0 } 4001414c: 81 c7 e0 08 ret 40014150: 81 e8 00 00 restore =============================================================================== 400578a4 <_Condition_Wait_recursive>: { 400578a4: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED _Thread_queue_Context_set_enqueue_callout( Thread_queue_Context *queue_context, Thread_queue_Enqueue_callout enqueue_callout ) { queue_context->enqueue_callout = enqueue_callout; 400578a8: 03 10 01 5e sethi %hi(0x40057800), %g1 <== NOT EXECUTED nest_level = _mutex->_nest_level; 400578ac: fa 06 60 14 ld [ %i1 + 0x14 ], %i5 <== NOT EXECUTED 400578b0: 82 10 60 40 or %g1, 0x40, %g1 <== NOT EXECUTED _mutex->_nest_level = 0; 400578b4: c0 26 60 14 clr [ %i1 + 0x14 ] <== NOT EXECUTED 400578b8: c2 27 bf e0 st %g1, [ %fp + -32 ] <== NOT EXECUTED context->mutex = _mutex; 400578bc: f2 27 bf fc st %i1, [ %fp + -4 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400578c0: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( &context->Base.Lock_context.Lock_context ); 400578c4: c2 27 bf d8 st %g1, [ %fp + -40 ] queue_context->thread_state = thread_state; 400578c8: 82 10 20 20 mov 0x20, %g1 _Thread_queue_Enqueue( 400578cc: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2 400578d0: 96 07 bf d8 add %fp, -40, %o3 400578d4: 90 06 20 08 add %i0, 8, %o0 400578d8: c2 27 bf dc st %g1, [ %fp + -36 ] 400578dc: 13 10 02 46 sethi %hi(0x40091800), %o1 400578e0: 40 00 0d e5 call 4005b074 <_Thread_queue_Enqueue> 400578e4: 92 12 63 b8 or %o1, 0x3b8, %o1 ! 40091bb8 <_Thread_queue_Operations_FIFO> _Mutex_recursive_Acquire( _mutex ); 400578e8: 40 00 06 14 call 40059138 <_Mutex_recursive_Acquire> 400578ec: 90 10 00 19 mov %i1, %o0 _mutex->_nest_level = nest_level; 400578f0: fa 26 60 14 st %i5, [ %i1 + 0x14 ] } 400578f4: 81 c7 e0 08 ret 400578f8: 81 e8 00 00 restore =============================================================================== 4000fff4 <_Condition_Wait_recursive_timed>: { 4000fff4: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED queue_context->enqueue_callout = enqueue_callout; 4000fff8: 03 10 00 3f sethi %hi(0x4000fc00), %g1 <== NOT EXECUTED nest_level = _mutex->_nest_level; 4000fffc: f8 06 60 14 ld [ %i1 + 0x14 ], %i4 <== NOT EXECUTED 40010000: 82 10 63 24 or %g1, 0x324, %g1 <== NOT EXECUTED queue_context->Timeout.arg = arg; 40010004: f4 27 bf e4 st %i2, [ %fp + -28 ] <== NOT EXECUTED queue_context->enqueue_callout = enqueue_callout; 40010008: c2 27 bf e0 st %g1, [ %fp + -32 ] <== NOT EXECUTED _mutex->_nest_level = 0; 4001000c: c0 26 60 14 clr [ %i1 + 0x14 ] <== NOT EXECUTED context->mutex = _mutex; 40010010: f2 27 bf fc st %i1, [ %fp + -4 ] <== NOT EXECUTED 40010014: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( &context->Base.Lock_context.Lock_context ); 40010018: c2 27 bf d8 st %g1, [ %fp + -40 ] queue_context->thread_state = thread_state; 4001001c: 82 10 20 20 mov 0x20, %g1 executing = _Thread_Executing; 40010020: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5 _Thread_queue_Enqueue( 40010024: 96 07 bf d8 add %fp, -40, %o3 40010028: 94 10 00 1d mov %i5, %o2 4001002c: 90 06 20 08 add %i0, 8, %o0 40010030: c2 27 bf dc st %g1, [ %fp + -36 ] 40010034: 13 10 00 4a sethi %hi(0x40012800), %o1 40010038: 7f ff ee 7a call 4000ba20 <_Thread_queue_Enqueue> 4001003c: 92 12 63 14 or %o1, 0x314, %o1 ! 40012b14 <_Thread_queue_Operations_FIFO> eno = STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) ); 40010040: f0 07 60 4c ld [ %i5 + 0x4c ], %i0 _Mutex_recursive_Acquire( _mutex ); 40010044: 90 10 00 19 mov %i1, %o0 40010048: 7f ff e5 c3 call 40009754 <_Mutex_recursive_Acquire> 4001004c: b1 3e 20 08 sra %i0, 8, %i0 _mutex->_nest_level = nest_level; 40010050: f8 26 60 14 st %i4, [ %i1 + 0x14 ] } 40010054: 81 c7 e0 08 ret 40010058: 81 e8 00 00 restore =============================================================================== 4000837c <_Condition_Wait_timed>: { 4000837c: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED queue_context->enqueue_callout = enqueue_callout; 40008380: 03 10 00 20 sethi %hi(0x40008000), %g1 <== NOT EXECUTED queue_context->Timeout.arg = arg; 40008384: f4 27 bf e4 st %i2, [ %fp + -28 ] <== NOT EXECUTED queue_context->enqueue_callout = enqueue_callout; 40008388: 82 10 62 b8 or %g1, 0x2b8, %g1 <== NOT EXECUTED context->mutex = _mutex; 4000838c: f2 27 bf fc st %i1, [ %fp + -4 ] <== NOT EXECUTED 40008390: c2 27 bf e0 st %g1, [ %fp + -32 ] <== NOT EXECUTED 40008394: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( &context->Base.Lock_context.Lock_context ); 40008398: c2 27 bf d8 st %g1, [ %fp + -40 ] queue_context->thread_state = thread_state; 4000839c: 82 10 20 20 mov 0x20, %g1 executing = _Thread_Executing; 400083a0: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5 _Thread_queue_Enqueue( 400083a4: 90 06 20 08 add %i0, 8, %o0 400083a8: 96 07 bf d8 add %fp, -40, %o3 400083ac: 94 10 00 1d mov %i5, %o2 400083b0: c2 27 bf dc st %g1, [ %fp + -36 ] 400083b4: 13 10 00 49 sethi %hi(0x40012400), %o1 400083b8: 40 00 10 c4 call 4000c6c8 <_Thread_queue_Enqueue> 400083bc: 92 12 63 10 or %o1, 0x310, %o1 ! 40012710 <_Thread_queue_Operations_FIFO> eno = STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) ); 400083c0: f0 07 60 4c ld [ %i5 + 0x4c ], %i0 400083c4: b1 3e 20 08 sra %i0, 8, %i0 _Mutex_Acquire( _mutex ); 400083c8: 40 00 07 89 call 4000a1ec <_Mutex_Acquire> 400083cc: 90 10 00 19 mov %i1, %o0 } 400083d0: 81 c7 e0 08 ret 400083d4: 81 e8 00 00 restore =============================================================================== 40007168 <_Freechain_Get>: Freechain_Control *freechain, Freechain_Allocator allocator, size_t number_nodes_to_extend, size_t node_size ) { 40007168: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 4000716c: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 40007170: f0 06 00 00 ld [ %i0 ], %i0 return &the_chain->Tail.Node; 40007174: b8 07 60 04 add %i5, 4, %i4 _Assert( node_size >= sizeof( Chain_Node ) ); if ( _Chain_Is_empty( &freechain->Free ) && number_nodes_to_extend > 0 ) { 40007178: 80 a6 00 1c cmp %i0, %i4 4000717c: 12 80 00 04 bne 4000718c <_Freechain_Get+0x24> <== ALWAYS TAKEN 40007180: 80 a6 a0 00 cmp %i2, 0 40007184: 12 80 00 0a bne 400071ac <_Freechain_Get+0x44> 40007188: 01 00 00 00 nop if ( !_Chain_Is_empty(the_chain)) 4000718c: 80 a7 00 18 cmp %i4, %i0 40007190: 02 80 00 12 be 400071d8 <_Freechain_Get+0x70> 40007194: 01 00 00 00 nop new_first = old_first->next; 40007198: c2 06 00 00 ld [ %i0 ], %g1 head->next = new_first; 4000719c: c2 27 40 00 st %g1, [ %i5 ] new_first->previous = head; 400071a0: fa 20 60 04 st %i5, [ %g1 + 4 ] 400071a4: 81 c7 e0 08 ret 400071a8: 81 e8 00 00 restore void *starting_address; starting_address = ( *allocator )( number_nodes_to_extend * node_size ); 400071ac: 9f c6 40 00 call %i1 400071b0: 90 5e 80 1b smul %i2, %i3, %o0 number_nodes_to_extend *= ( starting_address != NULL ); 400071b4: 80 a0 00 08 cmp %g0, %o0 starting_address = ( *allocator )( number_nodes_to_extend * node_size ); 400071b8: 92 10 00 08 mov %o0, %o1 number_nodes_to_extend *= ( starting_address != NULL ); 400071bc: 94 40 20 00 addx %g0, 0, %o2 _Chain_Initialize( 400071c0: 96 10 00 1b mov %i3, %o3 400071c4: 94 5a 80 1a smul %o2, %i2, %o2 400071c8: 7f ff ff c7 call 400070e4 <_Chain_Initialize> 400071cc: 90 10 00 1d mov %i5, %o0 400071d0: 10 bf ff ef b 4000718c <_Freechain_Get+0x24> 400071d4: f0 07 40 00 ld [ %i5 ], %i0 node_size ); } return _Chain_Get_unprotected( &freechain->Free ); } 400071d8: 81 c7 e0 08 ret 400071dc: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 400071e0 <_Freechain_Put>: void _Freechain_Put( Freechain_Control *freechain, void *node ) { if ( node != NULL ) { 400071e0: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED 400071e4: 02 80 00 07 be 40007200 <_Freechain_Put+0x20> <== NOT EXECUTED 400071e8: 01 00 00 00 nop the_node->previous = after_node; 400071ec: d0 22 60 04 st %o0, [ %o1 + 4 ] before_node = after_node->next; 400071f0: c2 02 00 00 ld [ %o0 ], %g1 after_node->next = the_node; 400071f4: d2 22 00 00 st %o1, [ %o0 ] the_node->next = before_node; 400071f8: c2 22 40 00 st %g1, [ %o1 ] before_node->previous = the_node; 400071fc: d2 20 60 04 st %o1, [ %g1 + 4 ] _Chain_Initialize_node( node ); _Chain_Prepend_unprotected( &freechain->Free, node ); } } 40007200: 81 c3 e0 08 retl 40007204: 01 00 00 00 nop =============================================================================== 400085b0 <_Futex_Wait>: { 400085b0: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED 400085b4: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 400085b8: 86 10 00 01 mov %g1, %g3 if ( *uaddr == val ) { 400085bc: c4 06 40 00 ld [ %i1 ], %g2 400085c0: 80 a0 80 1a cmp %g2, %i2 400085c4: 22 80 00 06 be,a 400085dc <_Futex_Wait+0x2c> 400085c8: 82 10 20 40 mov 0x40, %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400085cc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400085d0: 01 00 00 00 nop } 400085d4: 81 c7 e0 08 ret 400085d8: 91 e8 20 0b restore %g0, 0xb, %o0 executing = _Thread_Executing; 400085dc: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2 400085e0: c2 27 bf e0 st %g1, [ %fp + -32 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Context_set_enqueue_do_nothing_extra( Thread_queue_Context *queue_context ) { queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra; 400085e4: 03 10 00 31 sethi %hi(0x4000c400), %g1 400085e8: 82 10 62 b0 or %g1, 0x2b0, %g1 ! 4000c6b0 <_Thread_queue_Enqueue_do_nothing_extra> _Thread_queue_Enqueue( 400085ec: 90 06 20 08 add %i0, 8, %o0 ) { #if defined( RTEMS_SMP ) context->Lock_context.isr_level = level; #else context->isr_level = level; 400085f0: c6 27 bf dc st %g3, [ %fp + -36 ] 400085f4: 96 07 bf dc add %fp, -36, %o3 400085f8: c2 27 bf e4 st %g1, [ %fp + -28 ] 400085fc: 13 10 00 49 sethi %hi(0x40012400), %o1 eno = 0; 40008600: b0 10 20 00 clr %i0 _Thread_queue_Enqueue( 40008604: 40 00 10 31 call 4000c6c8 <_Thread_queue_Enqueue> 40008608: 92 12 63 10 or %o1, 0x310, %o1 4000860c: 81 c7 e0 08 ret 40008610: 81 e8 00 00 restore =============================================================================== 40008614 <_Futex_Wake>: int _Futex_Wake( struct _Futex_Control *_futex, int count ) { 40008614: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40008618: 91 d0 20 09 ta 9 <== NOT EXECUTED /* * For some synchronization objects like barriers the _Futex_Wake() must be * called in the fast path. Normally there are no threads on the queue, so * check this condition early. */ if ( __predict_true( _Thread_queue_Is_empty( &futex->Queue.Queue ) ) ) { 4000861c: c4 06 20 08 ld [ %i0 + 8 ], %g2 40008620: 80 a0 a0 00 cmp %g2, 0 40008624: 32 80 00 06 bne,a 4000863c <_Futex_Wake+0x28> 40008628: f2 27 bf fc st %i1, [ %fp + -4 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000862c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40008630: 01 00 00 00 nop _Futex_Queue_release( futex, level, &context.Base ); return 0; 40008634: 81 c7 e0 08 ret 40008638: 91 e8 20 00 restore %g0, 0, %o0 } context.count = count; _Thread_queue_Context_set_ISR_level( &context.Base, level ); return (int) _Thread_queue_Flush_critical( 4000863c: 96 07 bf d8 add %fp, -40, %o3 40008640: c2 27 bf d8 st %g1, [ %fp + -40 ] 40008644: 90 06 20 08 add %i0, 8, %o0 40008648: 15 10 00 21 sethi %hi(0x40008400), %o2 4000864c: 13 10 00 49 sethi %hi(0x40012400), %o1 40008650: 94 12 a1 90 or %o2, 0x190, %o2 40008654: 40 00 11 1e call 4000cacc <_Thread_queue_Flush_critical> 40008658: 92 12 63 10 or %o1, 0x310, %o1 &futex->Queue.Queue, FUTEX_TQ_OPERATIONS, _Futex_Flush_filter, &context.Base ); } 4000865c: 81 c7 e0 08 ret 40008660: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 40007208 <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 40007208: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 4000720c: 88 06 60 04 add %i1, 4, %g4 Heap_Block *block = NULL; uintptr_t alloc_begin = 0; uint32_t search_count = 0; bool search_again = false; if ( block_size_floor < alloc_size ) { 40007210: 80 a6 7f fc cmp %i1, -4 40007214: 1a 80 00 8a bcc 4000743c <_Heap_Allocate_aligned_with_boundary+0x234> <== NEVER TAKEN 40007218: da 06 20 10 ld [ %i0 + 0x10 ], %o5 /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { 4000721c: 80 a6 e0 00 cmp %i3, 0 40007220: 12 80 00 81 bne 40007424 <_Heap_Allocate_aligned_with_boundary+0x21c> 40007224: 80 a6 40 1b cmp %i1, %i3 return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 40007228: d2 06 20 08 ld [ %i0 + 8 ], %o1 do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 4000722c: 80 a6 00 09 cmp %i0, %o1 40007230: 02 80 00 78 be 40007410 <_Heap_Allocate_aligned_with_boundary+0x208> 40007234: ba 10 20 00 clr %i5 uintptr_t alloc_begin = alloc_end - alloc_size; 40007238: 9e 10 20 04 mov 4, %o7 uintptr_t const alloc_begin_ceiling = block_end - min_block_size 4000723c: 96 03 60 07 add %o5, 7, %o3 uintptr_t alloc_begin = alloc_end - alloc_size; 40007240: 9e 23 c0 19 sub %o7, %i1, %o7 uintptr_t const free_size = alloc_block_begin - block_begin; 40007244: 10 80 00 09 b 40007268 <_Heap_Allocate_aligned_with_boundary+0x60> 40007248: 94 10 3f f8 mov -8, %o2 } /* Statistics */ ++search_count; if ( alloc_begin != 0 ) { 4000724c: 80 a7 20 00 cmp %i4, 0 40007250: 32 80 00 5b bne,a 400073bc <_Heap_Allocate_aligned_with_boundary+0x1b4> <== ALWAYS TAKEN 40007254: 96 10 00 19 mov %i1, %o3 break; } block = block->next; 40007258: d2 02 60 08 ld [ %o1 + 8 ], %o1 while ( block != free_list_tail ) { 4000725c: 80 a6 00 09 cmp %i0, %o1 40007260: 22 80 00 6d be,a 40007414 <_Heap_Allocate_aligned_with_boundary+0x20c> 40007264: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 if ( block->size_and_flag > block_size_floor ) { 40007268: c2 02 60 04 ld [ %o1 + 4 ], %g1 4000726c: 80 a0 40 04 cmp %g1, %g4 40007270: 08 bf ff fa bleu 40007258 <_Heap_Allocate_aligned_with_boundary+0x50> 40007274: ba 07 60 01 inc %i5 if ( alignment == 0 ) { 40007278: 80 a6 a0 00 cmp %i2, 0 4000727c: 02 bf ff f4 be 4000724c <_Heap_Allocate_aligned_with_boundary+0x44> 40007280: b8 02 60 08 add %o1, 8, %i4 40007284: d8 06 20 14 ld [ %i0 + 0x14 ], %o4 - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40007288: 82 08 7f fe and %g1, -2, %g1 uintptr_t const alloc_begin_ceiling = block_end - min_block_size 4000728c: 86 22 c0 0c sub %o3, %o4, %g3 uintptr_t const block_end = block_begin + block_size; 40007290: 82 00 40 09 add %g1, %o1, %g1 uintptr_t const alloc_begin_ceiling = block_end - min_block_size 40007294: 86 00 c0 01 add %g3, %g1, %g3 uintptr_t alloc_begin = alloc_end - alloc_size; 40007298: 82 03 c0 01 add %o7, %g1, %g1 return value - (value % alignment); 4000729c: 81 80 20 00 wr %g0, %y 400072a0: 01 00 00 00 nop 400072a4: 01 00 00 00 nop 400072a8: 01 00 00 00 nop 400072ac: 84 70 40 1a udiv %g1, %i2, %g2 400072b0: 84 58 80 1a smul %g2, %i2, %g2 if ( alloc_begin > alloc_begin_ceiling ) { 400072b4: 80 a0 c0 02 cmp %g3, %g2 400072b8: 1a 80 00 08 bcc 400072d8 <_Heap_Allocate_aligned_with_boundary+0xd0> 400072bc: 80 a6 e0 00 cmp %i3, 0 400072c0: 81 80 20 00 wr %g0, %y 400072c4: 01 00 00 00 nop 400072c8: 01 00 00 00 nop 400072cc: 01 00 00 00 nop 400072d0: 84 70 c0 1a udiv %g3, %i2, %g2 400072d4: 84 58 80 1a smul %g2, %i2, %g2 if ( boundary != 0 ) { 400072d8: 02 80 00 26 be 40007370 <_Heap_Allocate_aligned_with_boundary+0x168> 400072dc: 80 a7 00 02 cmp %i4, %g2 alloc_end = alloc_begin + alloc_size; 400072e0: 86 06 40 02 add %i1, %g2, %g3 400072e4: 81 80 20 00 wr %g0, %y 400072e8: 01 00 00 00 nop 400072ec: 01 00 00 00 nop 400072f0: 01 00 00 00 nop 400072f4: 82 70 c0 1b udiv %g3, %i3, %g1 400072f8: 82 58 40 1b smul %g1, %i3, %g1 while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 400072fc: 80 a0 40 03 cmp %g1, %g3 40007300: 1a 80 00 1b bcc 4000736c <_Heap_Allocate_aligned_with_boundary+0x164> 40007304: 90 06 40 1c add %i1, %i4, %o0 40007308: 80 a0 80 01 cmp %g2, %g1 4000730c: 2a 80 00 06 bcs,a 40007324 <_Heap_Allocate_aligned_with_boundary+0x11c> 40007310: 80 a2 00 01 cmp %o0, %g1 if ( alloc_begin >= alloc_begin_floor ) { 40007314: 10 80 00 17 b 40007370 <_Heap_Allocate_aligned_with_boundary+0x168> 40007318: 80 a7 00 02 cmp %i4, %g2 while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 4000731c: 1a 80 00 14 bcc 4000736c <_Heap_Allocate_aligned_with_boundary+0x164> 40007320: 80 a2 00 01 cmp %o0, %g1 if ( boundary_line < boundary_floor ) { 40007324: 18 bf ff cd bgu 40007258 <_Heap_Allocate_aligned_with_boundary+0x50> 40007328: 82 20 40 19 sub %g1, %i1, %g1 4000732c: 81 80 20 00 wr %g0, %y 40007330: 01 00 00 00 nop 40007334: 01 00 00 00 nop 40007338: 01 00 00 00 nop 4000733c: 84 70 40 1a udiv %g1, %i2, %g2 40007340: 84 58 80 1a smul %g2, %i2, %g2 alloc_end = alloc_begin + alloc_size; 40007344: 86 06 40 02 add %i1, %g2, %g3 40007348: 81 80 20 00 wr %g0, %y 4000734c: 01 00 00 00 nop 40007350: 01 00 00 00 nop 40007354: 01 00 00 00 nop 40007358: 82 70 c0 1b udiv %g3, %i3, %g1 4000735c: 82 58 40 1b smul %g1, %i3, %g1 while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 40007360: 80 a0 80 01 cmp %g2, %g1 40007364: 0a bf ff ee bcs 4000731c <_Heap_Allocate_aligned_with_boundary+0x114> 40007368: 80 a0 40 03 cmp %g1, %g3 if ( alloc_begin >= alloc_begin_floor ) { 4000736c: 80 a7 00 02 cmp %i4, %g2 40007370: 18 bf ff ba bgu 40007258 <_Heap_Allocate_aligned_with_boundary+0x50> 40007374: 82 22 80 09 sub %o2, %o1, %g1 40007378: 81 80 20 00 wr %g0, %y 4000737c: 01 00 00 00 nop 40007380: 01 00 00 00 nop 40007384: 01 00 00 00 nop 40007388: 86 70 80 0d udiv %g2, %o5, %g3 4000738c: 86 58 c0 0d smul %g3, %o5, %g3 uintptr_t const free_size = alloc_block_begin - block_begin; 40007390: 82 00 40 03 add %g1, %g3, %g1 if ( free_size >= min_block_size || free_size == 0 ) { 40007394: 80 a0 40 0c cmp %g1, %o4 40007398: 1a 80 00 04 bcc 400073a8 <_Heap_Allocate_aligned_with_boundary+0x1a0> 4000739c: 80 a0 60 00 cmp %g1, 0 400073a0: 32 bf ff af bne,a 4000725c <_Heap_Allocate_aligned_with_boundary+0x54> 400073a4: d2 02 60 08 ld [ %o1 + 8 ], %o1 400073a8: b8 10 00 02 mov %g2, %i4 if ( alloc_begin != 0 ) { 400073ac: 80 a7 20 00 cmp %i4, 0 400073b0: 22 bf ff ab be,a 4000725c <_Heap_Allocate_aligned_with_boundary+0x54> <== NEVER TAKEN 400073b4: d2 02 60 08 ld [ %o1 + 8 ], %o1 <== NOT EXECUTED search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin ); } while ( search_again ); if ( alloc_begin != 0 ) { block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size ); 400073b8: 96 10 00 19 mov %i1, %o3 400073bc: 94 10 00 1c mov %i4, %o2 400073c0: 40 00 00 d3 call 4000770c <_Heap_Block_allocate> 400073c4: 90 10 00 18 mov %i0, %o0 alignment, boundary ); /* Statistics */ ++stats->allocs; 400073c8: f6 06 20 58 ld [ %i0 + 0x58 ], %i3 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 400073cc: c8 02 20 04 ld [ %o0 + 4 ], %g4 stats->searches += search_count; stats->lifetime_allocated += _Heap_Block_size( block ); 400073d0: c4 1e 20 28 ldd [ %i0 + 0x28 ], %g2 stats->searches += search_count; 400073d4: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 ++stats->allocs; 400073d8: b6 06 e0 01 inc %i3 stats->searches += search_count; 400073dc: 82 00 40 1d add %g1, %i5, %g1 400073e0: 88 09 3f fe and %g4, -2, %g4 ++stats->allocs; 400073e4: f6 26 20 58 st %i3, [ %i0 + 0x58 ] stats->lifetime_allocated += _Heap_Block_size( block ); 400073e8: b6 80 c0 04 addcc %g3, %g4, %i3 stats->searches += search_count; 400073ec: c2 26 20 54 st %g1, [ %i0 + 0x54 ] stats->lifetime_allocated += _Heap_Block_size( block ); 400073f0: b4 40 a0 00 addx %g2, 0, %i2 400073f4: f4 3e 20 28 std %i2, [ %i0 + 0x28 ] /* Statistics */ ++stats->failed_allocs; } /* Statistics */ if ( stats->max_search < search_count ) { 400073f8: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 400073fc: 80 a0 40 1d cmp %g1, %i5 40007400: 2a 80 00 02 bcs,a 40007408 <_Heap_Allocate_aligned_with_boundary+0x200> 40007404: fa 26 20 50 st %i5, [ %i0 + 0x50 ] stats->max_search = search_count; } return (void *) alloc_begin; } 40007408: 81 c7 e0 08 ret 4000740c: 91 e8 00 1c restore %g0, %i4, %o0 ++stats->failed_allocs; 40007410: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 40007414: 82 00 60 01 inc %g1 40007418: b8 10 20 00 clr %i4 4000741c: 10 bf ff f7 b 400073f8 <_Heap_Allocate_aligned_with_boundary+0x1f0> 40007420: c2 26 20 5c st %g1, [ %i0 + 0x5c ] if ( boundary < alloc_size ) { 40007424: 18 80 00 06 bgu 4000743c <_Heap_Allocate_aligned_with_boundary+0x234> 40007428: 80 a6 a0 00 cmp %i2, 0 if ( alignment == 0 ) { 4000742c: 22 bf ff 7f be,a 40007228 <_Heap_Allocate_aligned_with_boundary+0x20> 40007430: b4 10 00 0d mov %o5, %i2 return _Heap_Free_list_head(heap)->next; 40007434: 10 bf ff 7e b 4000722c <_Heap_Allocate_aligned_with_boundary+0x24> 40007438: d2 06 20 08 ld [ %i0 + 8 ], %o1 return NULL; 4000743c: b8 10 20 00 clr %i4 } 40007440: 81 c7 e0 08 ret 40007444: 91 e8 00 1c restore %g0, %i4, %o0 =============================================================================== 4000770c <_Heap_Block_allocate>: Heap_Control *heap, Heap_Block *block, uintptr_t alloc_begin, uintptr_t alloc_size ) { 4000770c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40007710: c2 06 60 04 ld [ %i1 + 4 ], %g1 <== NOT EXECUTED 40007714: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40007718: 84 06 40 01 add %i1, %g1, %g2 <== NOT EXECUTED 4000771c: c4 00 a0 04 ld [ %g2 + 4 ], %g2 40007720: ba 10 00 18 mov %i0, %i5 Heap_Block *free_list_anchor = NULL; _HAssert( alloc_area_begin <= alloc_begin ); if ( _Heap_Is_free( block ) ) { 40007724: 80 88 a0 01 btst 1, %g2 40007728: b0 06 bf f8 add %i2, -8, %i0 return &heap->free_list; 4000772c: 94 10 00 1d mov %i5, %o2 40007730: 12 80 00 0f bne 4000776c <_Heap_Block_allocate+0x60> <== NEVER TAKEN 40007734: 96 26 00 19 sub %i0, %i1, %o3 40007738: c4 06 60 08 ld [ %i1 + 8 ], %g2 free_list_anchor = block->prev; 4000773c: d4 06 60 0c ld [ %i1 + 0xc ], %o2 prev->next = next; 40007740: c4 22 a0 08 st %g2, [ %o2 + 8 ] next->prev = prev; 40007744: d4 20 a0 0c st %o2, [ %g2 + 0xc ] _Heap_Free_list_remove( block ); /* Statistics */ --stats->free_blocks; 40007748: f8 07 60 44 ld [ %i5 + 0x44 ], %i4 ++stats->used_blocks; 4000774c: c8 07 60 4c ld [ %i5 + 0x4c ], %g4 stats->free_size -= _Heap_Block_size( block ); 40007750: c4 07 60 3c ld [ %i5 + 0x3c ], %g2 --stats->free_blocks; 40007754: b8 07 3f ff add %i4, -1, %i4 ++stats->used_blocks; 40007758: 88 01 20 01 inc %g4 stats->free_size -= _Heap_Block_size( block ); 4000775c: 82 20 80 01 sub %g2, %g1, %g1 --stats->free_blocks; 40007760: f8 27 60 44 st %i4, [ %i5 + 0x44 ] ++stats->used_blocks; 40007764: c8 27 60 4c st %g4, [ %i5 + 0x4c ] stats->free_size -= _Heap_Block_size( block ); 40007768: c2 27 60 3c st %g1, [ %i5 + 0x3c ] } else { free_list_anchor = _Heap_Free_list_head( heap ); } if ( alloc_area_offset < heap->page_size ) { 4000776c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2 40007770: 80 a0 80 0b cmp %g2, %o3 40007774: 28 80 00 0e bleu,a 400077ac <_Heap_Block_allocate+0xa0> 40007778: c6 07 60 3c ld [ %i5 + 0x3c ], %g3 _Heap_Block_split( heap, block, free_list_anchor, alloc_size ); 4000777c: 96 02 c0 1b add %o3, %i3, %o3 40007780: 92 10 00 19 mov %i1, %o1 40007784: 90 10 00 1d mov %i5, %o0 40007788: 7f ff ff 30 call 40007448 <_Heap_Block_split> 4000778c: b0 10 00 19 mov %i1, %i0 alloc_size ); } /* Statistics */ if ( stats->min_free_size > stats->free_size ) { 40007790: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 40007794: c4 07 60 40 ld [ %i5 + 0x40 ], %g2 40007798: 80 a0 80 01 cmp %g2, %g1 4000779c: 38 80 00 02 bgu,a 400077a4 <_Heap_Block_allocate+0x98> 400077a0: c2 27 60 40 st %g1, [ %i5 + 0x40 ] } _Heap_Protection_block_initialize( heap, block ); return block; } 400077a4: 81 c7 e0 08 ret 400077a8: 81 e8 00 00 restore return value - (value % alignment); 400077ac: 81 80 20 00 wr %g0, %y 400077b0: 01 00 00 00 nop 400077b4: 01 00 00 00 nop 400077b8: 01 00 00 00 nop 400077bc: 88 76 80 02 udiv %i2, %g2, %g4 400077c0: 84 59 00 02 smul %g4, %g2, %g2 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 400077c4: c2 06 60 04 ld [ %i1 + 4 ], %g1 return value - (value % alignment); 400077c8: b4 26 80 02 sub %i2, %g2, %i2 - HEAP_BLOCK_HEADER_SIZE); 400077cc: b0 26 00 1a sub %i0, %i2, %i0 block_size = block_end - block_begin; 400077d0: 84 26 00 19 sub %i0, %i1, %g2 stats->free_size += block_size; 400077d4: 86 00 c0 02 add %g3, %g2, %g3 400077d8: c6 27 60 3c st %g3, [ %i5 + 0x3c ] return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 400077dc: 82 08 7f fe and %g1, -2, %g1 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 400077e0: c6 06 60 04 ld [ %i1 + 4 ], %g3 uintptr_t block_end = block_begin + block_size; 400077e4: 82 06 40 01 add %i1, %g1, %g1 if ( _Heap_Is_prev_used( block ) ) { 400077e8: 80 88 e0 01 btst 1, %g3 400077ec: 12 80 00 11 bne 40007830 <_Heap_Block_allocate+0x124> 400077f0: 82 20 40 18 sub %g1, %i0, %g1 return (Heap_Block *) ((uintptr_t) block - block->prev_size); 400077f4: c6 06 40 00 ld [ %i1 ], %g3 400077f8: b2 26 40 03 sub %i1, %g3, %i1 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 400077fc: c6 06 60 04 ld [ %i1 + 4 ], %g3 40007800: 86 08 ff fe and %g3, -2, %g3 block_size += prev_block_size; 40007804: 84 00 80 03 add %g2, %g3, %g2 block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; 40007808: 86 10 a0 01 or %g2, 1, %g3 4000780c: c6 26 60 04 st %g3, [ %i1 + 4 ] _Heap_Block_split( heap, new_block, free_list_anchor, alloc_size ); 40007810: 96 10 00 1b mov %i3, %o3 new_block->prev_size = block_size; 40007814: c4 26 00 00 st %g2, [ %i0 ] _Heap_Block_split( heap, new_block, free_list_anchor, alloc_size ); 40007818: 92 10 00 18 mov %i0, %o1 new_block->size_and_flag = new_block_size; 4000781c: c2 26 20 04 st %g1, [ %i0 + 4 ] _Heap_Block_split( heap, new_block, free_list_anchor, alloc_size ); 40007820: 7f ff ff 0a call 40007448 <_Heap_Block_split> 40007824: 90 10 00 1d mov %i5, %o0 if ( stats->min_free_size > stats->free_size ) { 40007828: 10 bf ff db b 40007794 <_Heap_Block_allocate+0x88> 4000782c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 Heap_Block *next = block_before->next; 40007830: c8 02 a0 08 ld [ %o2 + 8 ], %g4 new_block->next = next; 40007834: c8 26 60 08 st %g4, [ %i1 + 8 ] new_block->prev = block_before; 40007838: d4 26 60 0c st %o2, [ %i1 + 0xc ] block_before->next = new_block; 4000783c: f2 22 a0 08 st %i1, [ %o2 + 8 ] ++stats->free_blocks; 40007840: 94 10 00 19 mov %i1, %o2 40007844: c6 07 60 44 ld [ %i5 + 0x44 ], %g3 next->prev = new_block; 40007848: f2 21 20 0c st %i1, [ %g4 + 0xc ] 4000784c: 86 00 e0 01 inc %g3 40007850: 10 bf ff ee b 40007808 <_Heap_Block_allocate+0xfc> 40007854: c6 27 60 44 st %g3, [ %i5 + 0x44 ] =============================================================================== 4000d6bc <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t unused RTEMS_UNUSED ) { 4000d6bc: 9d e3 bf 98 save %sp, -104, %sp Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; 4000d6c0: c0 27 bf f8 clr [ %fp + -8 ] { 4000d6c4: ba 10 00 18 mov %i0, %i5 Heap_Block *extend_last_block = NULL; 4000d6c8: c0 27 bf fc clr [ %fp + -4 ] 4000d6cc: b6 86 40 1a addcc %i1, %i2, %i3 Heap_Block *const first_block = heap->first_block; 4000d6d0: 0a 80 00 83 bcs 4000d8dc <_Heap_Extend+0x220> 4000d6d4: e0 06 20 20 ld [ %i0 + 0x20 ], %l0 uintptr_t const page_size = heap->page_size; 4000d6d8: f8 06 20 10 ld [ %i0 + 0x10 ], %i4 if ( extend_area_end < extend_area_begin ) { return 0; } extend_area_ok = _Heap_Get_first_and_last_block( 4000d6dc: d6 06 20 14 ld [ %i0 + 0x14 ], %o3 4000d6e0: 9a 07 bf fc add %fp, -4, %o5 uintptr_t const free_size = stats->free_size; 4000d6e4: f0 06 20 3c ld [ %i0 + 0x3c ], %i0 extend_area_ok = _Heap_Get_first_and_last_block( 4000d6e8: 98 07 bf f8 add %fp, -8, %o4 4000d6ec: 94 10 00 1c mov %i4, %o2 4000d6f0: 92 10 00 1a mov %i2, %o1 4000d6f4: 7f ff e5 e1 call 40006e78 <_Heap_Get_first_and_last_block> 4000d6f8: 90 10 00 19 mov %i1, %o0 page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 4000d6fc: 80 a2 20 00 cmp %o0, 0 4000d700: 02 80 00 77 be 4000d8dc <_Heap_Extend+0x220> 4000d704: 82 10 00 10 mov %l0, %g1 Heap_Block *link_above_block = NULL; 4000d708: a4 10 20 00 clr %l2 Heap_Block *link_below_block = NULL; 4000d70c: 9e 10 20 00 clr %o7 Heap_Block *merge_above_block = NULL; 4000d710: b4 10 20 00 clr %i2 Heap_Block *merge_below_block = NULL; 4000d714: a2 10 20 00 clr %l1 return 0; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 4000d718: 80 a0 40 10 cmp %g1, %l0 4000d71c: 02 80 00 7f be 4000d918 <_Heap_Extend+0x25c> 4000d720: 88 10 00 01 mov %g1, %g4 uintptr_t const sub_area_end = start_block->prev_size; 4000d724: c6 00 40 00 ld [ %g1 ], %g3 return value - (value % alignment); 4000d728: 81 80 20 00 wr %g0, %y 4000d72c: 01 00 00 00 nop 4000d730: 01 00 00 00 nop 4000d734: 01 00 00 00 nop 4000d738: 84 70 c0 1c udiv %g3, %i4, %g2 Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 4000d73c: 80 a6 40 03 cmp %i1, %g3 4000d740: 84 58 80 1c smul %g2, %i4, %g2 4000d744: 1a 80 00 05 bcc 4000d758 <_Heap_Extend+0x9c> 4000d748: 84 00 bf f8 add %g2, -8, %g2 4000d74c: 80 a1 00 1b cmp %g4, %i3 4000d750: 0a 80 00 63 bcs 4000d8dc <_Heap_Extend+0x220> 4000d754: 01 00 00 00 nop sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return 0; } if ( extend_area_end == sub_area_begin ) { 4000d758: 80 a1 00 1b cmp %g4, %i3 4000d75c: 02 80 00 6d be 4000d910 <_Heap_Extend+0x254> 4000d760: 80 a6 c0 03 cmp %i3, %g3 merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 4000d764: 0a 80 00 60 bcs 4000d8e4 <_Heap_Extend+0x228> 4000d768: 80 a6 40 03 cmp %i1, %g3 link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 4000d76c: 80 a6 40 03 cmp %i1, %g3 4000d770: 22 80 00 60 be,a 4000d8f0 <_Heap_Extend+0x234> 4000d774: f6 20 40 00 st %i3, [ %g1 ] start_block->prev_size = extend_area_end; merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 4000d778: 38 80 00 02 bgu,a 4000d780 <_Heap_Extend+0xc4> 4000d77c: a4 10 00 02 mov %g2, %l2 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000d780: c2 00 a0 04 ld [ %g2 + 4 ], %g1 4000d784: 82 08 7f fe and %g1, -2, %g1 return (Heap_Block *) ((uintptr_t) block + offset); 4000d788: 82 00 40 02 add %g1, %g2, %g1 link_above_block = end_block; } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); 4000d78c: 80 a4 00 01 cmp %l0, %g1 4000d790: 12 bf ff e3 bne 4000d71c <_Heap_Extend+0x60> 4000d794: 80 a0 40 10 cmp %g1, %l0 if ( extend_area_begin < heap->area_begin ) { 4000d798: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 4000d79c: 80 a0 40 19 cmp %g1, %i1 4000d7a0: 38 80 00 06 bgu,a 4000d7b8 <_Heap_Extend+0xfc> 4000d7a4: f2 27 60 18 st %i1, [ %i5 + 0x18 ] heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { 4000d7a8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 4000d7ac: 80 a0 40 1b cmp %g1, %i3 4000d7b0: 2a 80 00 02 bcs,a 4000d7b8 <_Heap_Extend+0xfc> 4000d7b4: f6 27 60 1c st %i3, [ %i5 + 0x1c ] heap->area_end = extend_area_end; } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 4000d7b8: c2 07 bf f8 ld [ %fp + -8 ], %g1 4000d7bc: c4 07 bf fc ld [ %fp + -4 ], %g2 extend_first_block_size = 4000d7c0: 86 20 80 01 sub %g2, %g1, %g3 extend_first_block->prev_size = extend_area_end; 4000d7c4: f6 20 40 00 st %i3, [ %g1 ] extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 4000d7c8: 88 10 e0 01 or %g3, 1, %g4 extend_first_block->size_and_flag = 4000d7cc: c8 20 60 04 st %g4, [ %g1 + 4 ] _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 4000d7d0: c6 20 80 00 st %g3, [ %g2 ] extend_last_block->size_and_flag = 0; 4000d7d4: c0 20 a0 04 clr [ %g2 + 4 ] _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { 4000d7d8: c6 07 60 20 ld [ %i5 + 0x20 ], %g3 4000d7dc: 80 a0 c0 01 cmp %g3, %g1 4000d7e0: 28 80 00 50 bleu,a 4000d920 <_Heap_Extend+0x264> 4000d7e4: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 heap->first_block = extend_first_block; 4000d7e8: c2 27 60 20 st %g1, [ %i5 + 0x20 ] } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { heap->last_block = extend_last_block; } if ( merge_below_block != NULL ) { 4000d7ec: 80 a4 60 00 cmp %l1, 0 4000d7f0: 02 80 00 51 be 4000d934 <_Heap_Extend+0x278> 4000d7f4: b2 06 60 08 add %i1, 8, %i1 uintptr_t const page_size = heap->page_size; 4000d7f8: c4 07 60 10 ld [ %i5 + 0x10 ], %g2 uintptr_t remainder = value % alignment; 4000d7fc: 81 80 20 00 wr %g0, %y 4000d800: 01 00 00 00 nop 4000d804: 01 00 00 00 nop 4000d808: 01 00 00 00 nop 4000d80c: 82 76 40 02 udiv %i1, %g2, %g1 4000d810: 82 58 40 02 smul %g1, %g2, %g1 if ( remainder != 0 ) { 4000d814: 82 a6 40 01 subcc %i1, %g1, %g1 4000d818: 22 80 00 05 be,a 4000d82c <_Heap_Extend+0x170> 4000d81c: c2 04 40 00 ld [ %l1 ], %g1 return value - remainder + alignment; 4000d820: b2 00 80 19 add %g2, %i1, %i1 4000d824: b2 26 40 01 sub %i1, %g1, %i1 new_first_block->prev_size = first_block->prev_size; 4000d828: c2 04 40 00 ld [ %l1 ], %g1 4000d82c: c2 26 7f f8 st %g1, [ %i1 + -8 ] uintptr_t const new_first_block_begin = 4000d830: 92 06 7f f8 add %i1, -8, %o1 uintptr_t const new_first_block_size = 4000d834: 82 24 40 09 sub %l1, %o1, %g1 new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED; 4000d838: 82 10 60 01 or %g1, 1, %g1 4000d83c: c2 22 60 04 st %g1, [ %o1 + 4 ] _Heap_Free_block( heap, new_first_block ); 4000d840: 7f ff ff 89 call 4000d664 <_Heap_Free_block> 4000d844: 90 10 00 1d mov %i5, %o0 link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 4000d848: 80 a6 a0 00 cmp %i2, 0 4000d84c: 02 80 00 40 be 4000d94c <_Heap_Extend+0x290> 4000d850: b6 06 ff f8 add %i3, -8, %i3 return value - (value % alignment); 4000d854: c4 07 60 10 ld [ %i5 + 0x10 ], %g2 (last_block->size_and_flag - last_block_new_size) 4000d858: c6 06 a0 04 ld [ %i2 + 4 ], %g3 uintptr_t const last_block_new_size = _Heap_Align_down( 4000d85c: b6 26 c0 1a sub %i3, %i2, %i3 4000d860: 81 80 20 00 wr %g0, %y 4000d864: 01 00 00 00 nop 4000d868: 01 00 00 00 nop 4000d86c: 01 00 00 00 nop 4000d870: 82 76 c0 02 udiv %i3, %g2, %g1 4000d874: 84 58 40 02 smul %g1, %g2, %g2 new_last_block->size_and_flag = 4000d878: 88 06 80 02 add %i2, %g2, %g4 (last_block->size_and_flag - last_block_new_size) 4000d87c: 82 20 c0 02 sub %g3, %g2, %g1 | HEAP_PREV_BLOCK_USED; 4000d880: 82 10 60 01 or %g1, 1, %g1 new_last_block->size_and_flag = 4000d884: c2 21 20 04 st %g1, [ %g4 + 4 ] _Heap_Free_block( heap, last_block ); 4000d888: 92 10 00 1a mov %i2, %o1 uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000d88c: c2 06 a0 04 ld [ %i2 + 4 ], %g1 4000d890: 82 08 60 01 and %g1, 1, %g1 block->size_and_flag = size | flag; 4000d894: 82 10 40 02 or %g1, %g2, %g1 4000d898: c2 26 a0 04 st %g1, [ %i2 + 4 ] 4000d89c: 7f ff ff 72 call 4000d664 <_Heap_Free_block> 4000d8a0: 90 10 00 1d mov %i5, %o0 4000d8a4: c4 07 60 24 ld [ %i5 + 0x24 ], %g2 uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000d8a8: c6 00 a0 04 ld [ %g2 + 4 ], %g3 _Heap_Block_set_size( 4000d8ac: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 4000d8b0: 82 20 40 02 sub %g1, %g2, %g1 uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000d8b4: 86 08 e0 01 and %g3, 1, %g3 block->size_and_flag = size | flag; 4000d8b8: 82 10 40 03 or %g1, %g3, %g1 4000d8bc: c2 20 a0 04 st %g1, [ %g2 + 4 ] _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; /* Statistics */ stats->size += extended_size; 4000d8c0: c4 07 60 38 ld [ %i5 + 0x38 ], %g2 extended_size = stats->free_size - free_size; 4000d8c4: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 4000d8c8: b0 20 40 18 sub %g1, %i0, %i0 stats->size += extended_size; 4000d8cc: 82 00 80 18 add %g2, %i0, %g1 4000d8d0: c2 27 60 38 st %g1, [ %i5 + 0x38 ] return extended_size; } 4000d8d4: 81 c7 e0 08 ret 4000d8d8: 81 e8 00 00 restore return 0; 4000d8dc: 81 c7 e0 08 ret 4000d8e0: 91 e8 20 00 restore %g0, 0, %o0 if ( sub_area_end == extend_area_begin ) { 4000d8e4: 12 bf ff a5 bne 4000d778 <_Heap_Extend+0xbc> <== ALWAYS TAKEN 4000d8e8: 9e 10 00 01 mov %g1, %o7 start_block->prev_size = extend_area_end; 4000d8ec: f6 20 40 00 st %i3, [ %g1 ] <== NOT EXECUTED return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000d8f0: c2 00 a0 04 ld [ %g2 + 4 ], %g1 4000d8f4: 82 08 7f fe and %g1, -2, %g1 return (Heap_Block *) ((uintptr_t) block + offset); 4000d8f8: 82 00 40 02 add %g1, %g2, %g1 } while ( start_block != first_block ); 4000d8fc: 80 a4 00 01 cmp %l0, %g1 4000d900: 12 bf ff 86 bne 4000d718 <_Heap_Extend+0x5c> <== NEVER TAKEN 4000d904: b4 10 00 02 mov %g2, %i2 if ( extend_area_begin < heap->area_begin ) { 4000d908: 10 bf ff a5 b 4000d79c <_Heap_Extend+0xe0> 4000d90c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 4000d910: 10 bf ff 97 b 4000d76c <_Heap_Extend+0xb0> 4000d914: a2 10 00 01 mov %g1, %l1 4000d918: 10 bf ff 83 b 4000d724 <_Heap_Extend+0x68> 4000d91c: c8 07 60 18 ld [ %i5 + 0x18 ], %g4 } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 4000d920: 80 a0 40 02 cmp %g1, %g2 4000d924: 2a bf ff b2 bcs,a 4000d7ec <_Heap_Extend+0x130> 4000d928: c4 27 60 24 st %g2, [ %i5 + 0x24 ] if ( merge_below_block != NULL ) { 4000d92c: 10 bf ff b1 b 4000d7f0 <_Heap_Extend+0x134> 4000d930: 80 a4 60 00 cmp %l1, 0 } else if ( link_below_block != NULL ) { 4000d934: 80 a3 e0 00 cmp %o7, 0 4000d938: 02 bf ff c4 be 4000d848 <_Heap_Extend+0x18c> 4000d93c: 9e 23 c0 02 sub %o7, %g2, %o7 (link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED; 4000d940: 9e 13 e0 01 or %o7, 1, %o7 last_block->size_and_flag = 4000d944: 10 bf ff c1 b 4000d848 <_Heap_Extend+0x18c> 4000d948: de 20 a0 04 st %o7, [ %g2 + 4 ] } else if ( link_above_block != NULL ) { 4000d94c: 80 a4 a0 00 cmp %l2, 0 4000d950: 02 80 00 0b be 4000d97c <_Heap_Extend+0x2c0> 4000d954: c2 07 bf f8 ld [ %fp + -8 ], %g1 uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000d958: c4 04 a0 04 ld [ %l2 + 4 ], %g2 4000d95c: 84 08 a0 01 and %g2, 1, %g2 _Heap_Block_set_size( link, first_block_begin - link_begin ); 4000d960: 82 20 40 12 sub %g1, %l2, %g1 block->size_and_flag = size | flag; 4000d964: 82 10 40 02 or %g1, %g2, %g1 4000d968: c2 24 a0 04 st %g1, [ %l2 + 4 ] _Heap_Link_above( 4000d96c: c4 07 bf fc ld [ %fp + -4 ], %g2 last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 4000d970: c2 00 a0 04 ld [ %g2 + 4 ], %g1 4000d974: 82 10 60 01 or %g1, 1, %g1 4000d978: c2 20 a0 04 st %g1, [ %g2 + 4 ] if ( merge_below_block == NULL && merge_above_block == NULL ) { 4000d97c: 80 a4 60 00 cmp %l1, 0 4000d980: 12 bf ff c9 bne 4000d8a4 <_Heap_Extend+0x1e8> 4000d984: d2 07 bf f8 ld [ %fp + -8 ], %o1 _Heap_Free_block( heap, extend_first_block ); 4000d988: 7f ff ff 37 call 4000d664 <_Heap_Free_block> 4000d98c: 90 10 00 1d mov %i5, %o0 4000d990: 10 bf ff c6 b 4000d8a8 <_Heap_Extend+0x1ec> 4000d994: c4 07 60 24 ld [ %i5 + 0x24 ], %g2 =============================================================================== 4000dcdc <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 4000dcdc: 9d e3 bf a0 save %sp, -96, %sp /* * If NULL return true so a free on NULL is considered a valid release. This * is a special case that could be handled by the in heap check how-ever that * would result in false being returned which is wrong. */ if ( alloc_begin_ptr == NULL ) { 4000dce0: 80 a6 60 00 cmp %i1, 0 4000dce4: 02 80 00 41 be 4000dde8 <_Heap_Free+0x10c> 4000dce8: 84 10 20 01 mov 1, %g2 return value - (value % alignment); 4000dcec: c8 06 20 10 ld [ %i0 + 0x10 ], %g4 return (uintptr_t) block >= (uintptr_t) heap->first_block 4000dcf0: c6 06 20 20 ld [ %i0 + 0x20 ], %g3 return value - (value % alignment); 4000dcf4: 81 80 20 00 wr %g0, %y 4000dcf8: 01 00 00 00 nop 4000dcfc: 01 00 00 00 nop 4000dd00: 01 00 00 00 nop 4000dd04: 82 76 40 04 udiv %i1, %g4, %g1 4000dd08: 82 58 40 04 smul %g1, %g4, %g1 - HEAP_BLOCK_HEADER_SIZE); 4000dd0c: 82 00 7f f8 add %g1, -8, %g1 && (uintptr_t) block <= (uintptr_t) heap->last_block; 4000dd10: 80 a0 40 03 cmp %g1, %g3 4000dd14: 0a 80 00 35 bcs 4000dde8 <_Heap_Free+0x10c> 4000dd18: 84 10 20 00 clr %g2 4000dd1c: f6 06 20 24 ld [ %i0 + 0x24 ], %i3 4000dd20: 80 a0 40 1b cmp %g1, %i3 4000dd24: 38 80 00 32 bgu,a 4000ddec <_Heap_Free+0x110> 4000dd28: b0 08 a0 ff and %g2, 0xff, %i0 4000dd2c: fa 00 60 04 ld [ %g1 + 4 ], %i5 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000dd30: b8 0f 7f fe and %i5, -2, %i4 return (Heap_Block *) ((uintptr_t) block + offset); 4000dd34: 88 00 40 1c add %g1, %i4, %g4 && (uintptr_t) block <= (uintptr_t) heap->last_block; 4000dd38: 80 a0 c0 04 cmp %g3, %g4 4000dd3c: 38 80 00 2c bgu,a 4000ddec <_Heap_Free+0x110> <== NEVER TAKEN 4000dd40: b0 08 a0 ff and %g2, 0xff, %i0 <== NOT EXECUTED 4000dd44: 80 a6 c0 04 cmp %i3, %g4 4000dd48: 2a 80 00 29 bcs,a 4000ddec <_Heap_Free+0x110> 4000dd4c: b0 08 a0 ff and %g2, 0xff, %i0 4000dd50: f4 01 20 04 ld [ %g4 + 4 ], %i2 return false; } _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_prev_used( next_block ) ) { 4000dd54: 80 8e a0 01 btst 1, %i2 4000dd58: 02 80 00 24 be 4000dde8 <_Heap_Free+0x10c> <== NEVER TAKEN 4000dd5c: b4 0e bf fe and %i2, -2, %i2 return true; } next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 4000dd60: 80 a6 c0 04 cmp %i3, %g4 4000dd64: 02 80 00 24 be 4000ddf4 <_Heap_Free+0x118> 4000dd68: ba 0f 60 01 and %i5, 1, %i5 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000dd6c: 84 01 00 1a add %g4, %i2, %g2 4000dd70: c4 00 a0 04 ld [ %g2 + 4 ], %g2 4000dd74: 80 88 a0 01 btst 1, %g2 4000dd78: 12 80 00 20 bne 4000ddf8 <_Heap_Free+0x11c> 4000dd7c: 80 a7 60 00 cmp %i5, 0 if ( !_Heap_Is_prev_used( block ) ) { 4000dd80: 02 80 00 20 be 4000de00 <_Heap_Free+0x124> 4000dd84: 9e 10 20 01 mov 1, %o7 4000dd88: c6 01 20 08 ld [ %g4 + 8 ], %g3 4000dd8c: c4 01 20 0c ld [ %g4 + 0xc ], %g2 new_block->prev = prev; 4000dd90: c4 20 60 0c st %g2, [ %g1 + 0xc ] prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; next_block->prev_size = size; } } else if ( next_is_free ) { /* coalesce next */ uintptr_t const size = block_size + next_block_size; 4000dd94: b4 07 00 1a add %i4, %i2, %i2 new_block->next = next; 4000dd98: c6 20 60 08 st %g3, [ %g1 + 8 ] _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 4000dd9c: 88 16 a0 01 or %i2, 1, %g4 next->prev = new_block; 4000dda0: c2 20 e0 0c st %g1, [ %g3 + 0xc ] prev->next = new_block; 4000dda4: c2 20 a0 08 st %g1, [ %g2 + 8 ] 4000dda8: c8 20 60 04 st %g4, [ %g1 + 4 ] next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 4000ddac: f4 20 40 1a st %i2, [ %g1 + %i2 ] --stats->used_blocks; ++stats->frees; stats->free_size += block_size; stats->lifetime_freed += block_size; return( true ); 4000ddb0: 84 10 20 01 mov 1, %g2 stats->lifetime_freed += block_size; 4000ddb4: f4 1e 20 30 ldd [ %i0 + 0x30 ], %i2 --stats->used_blocks; 4000ddb8: c8 06 20 4c ld [ %i0 + 0x4c ], %g4 ++stats->frees; 4000ddbc: c6 06 20 60 ld [ %i0 + 0x60 ], %g3 stats->free_size += block_size; 4000ddc0: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 stats->lifetime_freed += block_size; 4000ddc4: 9a 86 c0 1c addcc %i3, %i4, %o5 --stats->used_blocks; 4000ddc8: 88 01 3f ff add %g4, -1, %g4 ++stats->frees; 4000ddcc: 86 00 e0 01 inc %g3 stats->free_size += block_size; 4000ddd0: 82 00 40 1c add %g1, %i4, %g1 stats->lifetime_freed += block_size; 4000ddd4: 98 46 a0 00 addx %i2, 0, %o4 --stats->used_blocks; 4000ddd8: c8 26 20 4c st %g4, [ %i0 + 0x4c ] ++stats->frees; 4000dddc: c6 26 20 60 st %g3, [ %i0 + 0x60 ] stats->free_size += block_size; 4000dde0: c2 26 20 3c st %g1, [ %i0 + 0x3c ] stats->lifetime_freed += block_size; 4000dde4: d8 3e 20 30 std %o4, [ %i0 + 0x30 ] 4000dde8: b0 08 a0 ff and %g2, 0xff, %i0 } 4000ddec: 81 c7 e0 08 ret 4000ddf0: 81 e8 00 00 restore if ( !_Heap_Is_prev_used( block ) ) { 4000ddf4: 80 a7 60 00 cmp %i5, 0 4000ddf8: 12 80 00 1c bne 4000de68 <_Heap_Free+0x18c> 4000ddfc: 9e 10 20 00 clr %o7 uintptr_t const prev_size = block->prev_size; 4000de00: f2 00 40 00 ld [ %g1 ], %i1 4000de04: ba 20 40 19 sub %g1, %i1, %i5 && (uintptr_t) block <= (uintptr_t) heap->last_block; 4000de08: 80 a7 40 03 cmp %i5, %g3 4000de0c: 0a bf ff f7 bcs 4000dde8 <_Heap_Free+0x10c> <== NEVER TAKEN 4000de10: 84 10 20 00 clr %g2 4000de14: 80 a7 40 1b cmp %i5, %i3 4000de18: 38 bf ff f5 bgu,a 4000ddec <_Heap_Free+0x110> <== NEVER TAKEN 4000de1c: b0 08 a0 ff and %g2, 0xff, %i0 <== NOT EXECUTED return block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000de20: c6 07 60 04 ld [ %i5 + 4 ], %g3 if ( !_Heap_Is_prev_used ( prev_block) ) { 4000de24: 80 88 e0 01 btst 1, %g3 4000de28: 02 bf ff f0 be 4000dde8 <_Heap_Free+0x10c> <== NEVER TAKEN 4000de2c: 80 a3 e0 00 cmp %o7, 0 if ( next_is_free ) { /* coalesce both */ 4000de30: 02 80 00 22 be 4000deb8 <_Heap_Free+0x1dc> 4000de34: b2 06 40 1c add %i1, %i4, %i1 4000de38: c4 01 20 08 ld [ %g4 + 8 ], %g2 4000de3c: c6 01 20 0c ld [ %g4 + 0xc ], %g3 prev->next = next; 4000de40: c4 20 e0 08 st %g2, [ %g3 + 8 ] uintptr_t const size = block_size + prev_size + next_block_size; 4000de44: b4 06 80 19 add %i2, %i1, %i2 stats->free_blocks -= 1; 4000de48: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 next->prev = prev; 4000de4c: c6 20 a0 0c st %g3, [ %g2 + 0xc ] 4000de50: 82 00 7f ff add %g1, -1, %g1 4000de54: c2 26 20 44 st %g1, [ %i0 + 0x44 ] prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 4000de58: 82 16 a0 01 or %i2, 1, %g1 4000de5c: c2 27 60 04 st %g1, [ %i5 + 4 ] 4000de60: 10 bf ff d4 b 4000ddb0 <_Heap_Free+0xd4> 4000de64: f4 27 40 1a st %i2, [ %i5 + %i2 ] Heap_Block *next = block_before->next; 4000de68: c6 06 20 08 ld [ %i0 + 8 ], %g3 new_block->next = next; 4000de6c: c6 20 60 08 st %g3, [ %g1 + 8 ] block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; 4000de70: 84 17 20 01 or %i4, 1, %g2 new_block->prev = block_before; 4000de74: f0 20 60 0c st %i0, [ %g1 + 0xc ] block_before->next = new_block; 4000de78: c2 26 20 08 st %g1, [ %i0 + 8 ] next->prev = new_block; 4000de7c: c2 20 e0 0c st %g1, [ %g3 + 0xc ] 4000de80: c4 20 60 04 st %g2, [ %g1 + 4 ] next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 4000de84: c4 01 20 04 ld [ %g4 + 4 ], %g2 4000de88: 84 08 bf fe and %g2, -2, %g2 4000de8c: c4 21 20 04 st %g2, [ %g4 + 4 ] ++stats->free_blocks; 4000de90: c4 06 20 44 ld [ %i0 + 0x44 ], %g2 next_block->prev_size = block_size; 4000de94: f8 20 40 1c st %i4, [ %g1 + %i4 ] ++stats->free_blocks; 4000de98: 82 00 a0 01 add %g2, 1, %g1 4000de9c: c2 26 20 44 st %g1, [ %i0 + 0x44 ] if ( stats->max_free_blocks < stats->free_blocks ) { 4000dea0: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 4000dea4: 80 a0 40 02 cmp %g1, %g2 4000dea8: 38 bf ff c2 bgu,a 4000ddb0 <_Heap_Free+0xd4> 4000deac: c2 26 20 48 st %g1, [ %i0 + 0x48 ] return( true ); 4000deb0: 10 bf ff c1 b 4000ddb4 <_Heap_Free+0xd8> 4000deb4: 84 10 20 01 mov 1, %g2 prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 4000deb8: 84 16 60 01 or %i1, 1, %g2 4000debc: c4 27 60 04 st %g2, [ %i5 + 4 ] next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 4000dec0: c4 01 20 04 ld [ %g4 + 4 ], %g2 4000dec4: 84 08 bf fe and %g2, -2, %g2 4000dec8: c4 21 20 04 st %g2, [ %g4 + 4 ] next_block->prev_size = size; 4000decc: 10 bf ff b9 b 4000ddb0 <_Heap_Free+0xd4> 4000ded0: f2 20 40 1c st %i1, [ %g1 + %i4 ] =============================================================================== 40006e78 <_Heap_Get_first_and_last_block>: _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 40006e78: 84 02 20 08 add %o0, 8, %g2 <== NOT EXECUTED uintptr_t remainder = value % alignment; 40006e7c: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 40006e80: 01 00 00 00 nop <== NOT EXECUTED 40006e84: 01 00 00 00 nop <== NOT EXECUTED 40006e88: 01 00 00 00 nop <== NOT EXECUTED 40006e8c: 82 70 80 0a udiv %g2, %o2, %g1 <== NOT EXECUTED 40006e90: 82 58 40 0a smul %g1, %o2, %g1 <== NOT EXECUTED if ( remainder != 0 ) { 40006e94: 82 a0 80 01 subcc %g2, %g1, %g1 <== NOT EXECUTED 40006e98: 02 80 00 1a be 40006f00 <_Heap_Get_first_and_last_block+0x88> <== NOT EXECUTED 40006e9c: 88 02 00 09 add %o0, %o1, %g4 <== NOT EXECUTED 40006ea0: 86 02 bf f8 add %o2, -8, %g3 <== NOT EXECUTED 40006ea4: 84 00 c0 02 add %g3, %g2, %g2 <== NOT EXECUTED 40006ea8: 82 20 80 01 sub %g2, %g1, %g1 <== NOT EXECUTED 40006eac: 84 20 40 08 sub %g1, %o0, %g2 <== NOT EXECUTED 40006eb0: 84 00 a0 08 add %g2, 8, %g2 <== NOT EXECUTED heap_area_end < heap_area_begin 40006eb4: 80 a1 00 08 cmp %g4, %o0 <== NOT EXECUTED 40006eb8: 88 40 20 00 addx %g0, 0, %g4 <== NOT EXECUTED || heap_area_size <= overhead 40006ebc: 80 a0 80 09 cmp %g2, %o1 <== NOT EXECUTED _Heap_Align_down( heap_area_size - overhead, page_size ); 40006ec0: 92 22 40 02 sub %o1, %g2, %o1 <== NOT EXECUTED || heap_area_size <= overhead 40006ec4: 86 60 3f ff subx %g0, -1, %g3 <== NOT EXECUTED return value - (value % alignment); 40006ec8: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 40006ecc: 01 00 00 00 nop <== NOT EXECUTED 40006ed0: 01 00 00 00 nop <== NOT EXECUTED 40006ed4: 01 00 00 00 nop <== NOT EXECUTED 40006ed8: 84 72 40 0a udiv %o1, %o2, %g2 <== NOT EXECUTED || first_block_size < min_block_size 40006edc: 80 91 00 03 orcc %g4, %g3, %g0 <== NOT EXECUTED 40006ee0: 12 80 00 05 bne 40006ef4 <_Heap_Get_first_and_last_block+0x7c> <== NOT EXECUTED 40006ee4: 94 58 80 0a smul %g2, %o2, %o2 <== NOT EXECUTED 40006ee8: 80 a2 80 0b cmp %o2, %o3 <== NOT EXECUTED 40006eec: 3a 80 00 08 bcc,a 40006f0c <_Heap_Get_first_and_last_block+0x94> <== NOT EXECUTED 40006ef0: c2 23 00 00 st %g1, [ %o4 ] <== NOT EXECUTED return false; 40006ef4: 90 10 20 00 clr %o0 <== NOT EXECUTED } 40006ef8: 81 c3 e0 08 retl <== NOT EXECUTED 40006efc: 90 0a 20 01 and %o0, 1, %o0 <== NOT EXECUTED 40006f00: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED 40006f04: 10 bf ff ec b 40006eb4 <_Heap_Get_first_and_last_block+0x3c> <== NOT EXECUTED 40006f08: 84 10 20 08 mov 8, %g2 <== NOT EXECUTED return (Heap_Block *) ((uintptr_t) block + offset); 40006f0c: 94 02 80 01 add %o2, %g1, %o2 <== NOT EXECUTED return true; 40006f10: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED *last_block_ptr = last_block; 40006f14: d4 23 40 00 st %o2, [ %o5 ] <== NOT EXECUTED } 40006f18: 81 c3 e0 08 retl <== NOT EXECUTED 40006f1c: 90 0a 20 01 and %o0, 1, %o0 <== NOT EXECUTED =============================================================================== 400123c4 <_Heap_Get_free_information>: ) { Heap_Block *the_block; Heap_Block *const tail = _Heap_Free_list_tail(the_heap); info->number = 0; 400123c4: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED info->largest = 0; 400123c8: c0 22 60 04 clr [ %o1 + 4 ] <== NOT EXECUTED info->total = 0; 400123cc: c0 22 60 08 clr [ %o1 + 8 ] <== NOT EXECUTED return _Heap_Free_list_head(heap)->next; 400123d0: c4 02 20 08 ld [ %o0 + 8 ], %g2 <== NOT EXECUTED for(the_block = _Heap_Free_list_first(the_heap); 400123d4: 80 a2 00 02 cmp %o0, %g2 <== NOT EXECUTED 400123d8: 02 80 00 12 be 40012420 <_Heap_Get_free_information+0x5c> <== NOT EXECUTED 400123dc: 88 10 20 01 mov 1, %g4 400123e0: 9a 10 20 00 clr %o5 400123e4: 10 80 00 03 b 400123f0 <_Heap_Get_free_information+0x2c> 400123e8: 86 10 20 00 clr %g3 400123ec: da 02 60 04 ld [ %o1 + 4 ], %o5 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 400123f0: c2 00 a0 04 ld [ %g2 + 4 ], %g1 400123f4: 82 08 7f fe and %g1, -2, %g1 uint32_t const the_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; 400123f8: c8 22 40 00 st %g4, [ %o1 ] info->total += the_size; 400123fc: 86 00 c0 01 add %g3, %g1, %g3 if ( info->largest < the_size ) 40012400: 80 a0 40 0d cmp %g1, %o5 40012404: 08 80 00 03 bleu 40012410 <_Heap_Get_free_information+0x4c> 40012408: c6 22 60 08 st %g3, [ %o1 + 8 ] info->largest = the_size; 4001240c: c2 22 60 04 st %g1, [ %o1 + 4 ] the_block = the_block->next) 40012410: c4 00 a0 08 ld [ %g2 + 8 ], %g2 for(the_block = _Heap_Free_list_first(the_heap); 40012414: 80 a2 00 02 cmp %o0, %g2 40012418: 12 bf ff f5 bne 400123ec <_Heap_Get_free_information+0x28> 4001241c: 88 01 20 01 inc %g4 } } 40012420: 81 c3 e0 08 retl 40012424: 01 00 00 00 nop =============================================================================== 400087fc <_Heap_Greedy_allocate>: Heap_Block *_Heap_Greedy_allocate( Heap_Control *heap, const uintptr_t *block_sizes, size_t block_count ) { 400087fc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Heap_Block *current; size_t i; _Heap_Protection_free_all_delayed_blocks( heap ); for (i = 0; i < block_count; ++i) { 40008800: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 40008804: 02 80 00 3a be 400088ec <_Heap_Greedy_allocate+0xf0> <== NOT EXECUTED 40008808: ba 10 00 18 mov %i0, %i5 4000880c: b5 2e a0 02 sll %i2, 2, %i2 Heap_Block *allocated_blocks = NULL; 40008810: b8 10 20 00 clr %i4 40008814: b4 06 40 1a add %i1, %i2, %i2 return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 40008818: d2 06 40 00 ld [ %i1 ], %o1 4000881c: 96 10 20 00 clr %o3 40008820: 94 10 20 00 clr %o2 40008824: 7f ff ff 47 call 40008540 <_Heap_Allocate_aligned_with_boundary> 40008828: 90 10 00 1d mov %i5, %o0 void *next = _Heap_Allocate( heap, block_sizes [i] ); if ( next != NULL ) { 4000882c: 80 a2 20 00 cmp %o0, 0 40008830: 02 80 00 0c be 40008860 <_Heap_Greedy_allocate+0x64> 40008834: b2 06 60 04 add %i1, 4, %i1 return value - (value % alignment); 40008838: c4 07 60 10 ld [ %i5 + 0x10 ], %g2 4000883c: 81 80 20 00 wr %g0, %y 40008840: 01 00 00 00 nop 40008844: 01 00 00 00 nop 40008848: 01 00 00 00 nop 4000884c: 82 72 00 02 udiv %o0, %g2, %g1 40008850: 82 58 40 02 smul %g1, %g2, %g1 Heap_Block *next_block = _Heap_Block_of_alloc_area( (uintptr_t) next, heap->page_size ); next_block->next = allocated_blocks; 40008854: f8 20 40 00 st %i4, [ %g1 ] - HEAP_BLOCK_HEADER_SIZE); 40008858: 82 00 7f f8 add %g1, -8, %g1 4000885c: b8 10 00 01 mov %g1, %i4 for (i = 0; i < block_count; ++i) { 40008860: 80 a6 80 19 cmp %i2, %i1 40008864: 32 bf ff ee bne,a 4000881c <_Heap_Greedy_allocate+0x20> 40008868: d2 06 40 00 ld [ %i1 ], %o1 return _Heap_Free_list_head(heap)->next; 4000886c: f0 07 60 08 ld [ %i5 + 8 ], %i0 allocated_blocks = next_block; } } while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { 40008870: 80 a7 40 18 cmp %i5, %i0 40008874: 22 80 00 19 be,a 400088d8 <_Heap_Greedy_allocate+0xdc> 40008878: b0 10 20 00 clr %i0 Heap_Block *allocated_blocks = NULL; 4000887c: 10 80 00 03 b 40008888 <_Heap_Greedy_allocate+0x8c> 40008880: b6 10 20 00 clr %i3 40008884: b0 10 00 01 mov %g1, %i0 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40008888: d6 06 20 04 ld [ %i0 + 4 ], %o3 4000888c: 96 0a ff fe and %o3, -2, %o3 _Heap_Block_allocate( 40008890: 94 06 20 08 add %i0, 8, %o2 40008894: 92 10 00 18 mov %i0, %o1 40008898: 96 02 ff f8 add %o3, -8, %o3 4000889c: 40 00 00 f0 call 40008c5c <_Heap_Block_allocate> 400088a0: 90 10 00 1d mov %i5, %o0 current, _Heap_Alloc_area_of_block( current ), _Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE ); current->next = blocks; 400088a4: f6 26 20 08 st %i3, [ %i0 + 8 ] return _Heap_Free_list_head(heap)->next; 400088a8: c2 07 60 08 ld [ %i5 + 8 ], %g1 while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { 400088ac: 80 a7 40 01 cmp %i5, %g1 400088b0: 12 bf ff f5 bne 40008884 <_Heap_Greedy_allocate+0x88> 400088b4: b6 10 00 18 mov %i0, %i3 blocks = current; } while ( allocated_blocks != NULL ) { 400088b8: 80 a7 20 00 cmp %i4, 0 400088bc: 02 80 00 0a be 400088e4 <_Heap_Greedy_allocate+0xe8> 400088c0: 01 00 00 00 nop current = allocated_blocks; allocated_blocks = allocated_blocks->next; 400088c4: f6 07 20 08 ld [ %i4 + 8 ], %i3 _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); 400088c8: 92 07 20 08 add %i4, 8, %o1 400088cc: 90 10 00 1d mov %i5, %o0 400088d0: 40 00 19 eb call 4000f07c <_Heap_Free> 400088d4: b8 10 00 1b mov %i3, %i4 while ( allocated_blocks != NULL ) { 400088d8: 80 a7 20 00 cmp %i4, 0 400088dc: 32 bf ff fb bne,a 400088c8 <_Heap_Greedy_allocate+0xcc> 400088e0: f6 07 20 08 ld [ %i4 + 8 ], %i3 } return blocks; } 400088e4: 81 c7 e0 08 ret 400088e8: 81 e8 00 00 restore 400088ec: f0 06 20 08 ld [ %i0 + 8 ], %i0 while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { 400088f0: 80 a7 40 18 cmp %i5, %i0 400088f4: 12 bf ff e2 bne 4000887c <_Heap_Greedy_allocate+0x80> <== ALWAYS TAKEN 400088f8: b8 10 20 00 clr %i4 Heap_Block *blocks = NULL; 400088fc: 81 c7 e0 08 ret <== NOT EXECUTED 40008900: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED =============================================================================== 40006ab0 <_Heap_Greedy_allocate_all_except_largest>: Heap_Block *_Heap_Greedy_allocate_all_except_largest( Heap_Control *heap, uintptr_t *allocatable_size ) { 40006ab0: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Heap_Information info; _Heap_Get_free_information( heap, &info ); 40006ab4: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED 40006ab8: 40 00 1a 76 call 4000d490 <_Heap_Get_free_information> <== NOT EXECUTED 40006abc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( info.largest > 0 ) { 40006ac0: c2 07 bf f8 ld [ %fp + -8 ], %g1 40006ac4: 80 a0 60 00 cmp %g1, 0 40006ac8: 12 80 00 08 bne 40006ae8 <_Heap_Greedy_allocate_all_except_largest+0x38> <== ALWAYS TAKEN 40006acc: 94 10 20 01 mov 1, %o2 *allocatable_size = info.largest - HEAP_BLOCK_HEADER_SIZE + HEAP_ALLOC_BONUS; } else { *allocatable_size = 0; 40006ad0: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED } return _Heap_Greedy_allocate( heap, allocatable_size, 1 ); 40006ad4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40006ad8: 7f ff ff b4 call 400069a8 <_Heap_Greedy_allocate> <== NOT EXECUTED 40006adc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED } 40006ae0: 81 c7 e0 08 ret <== NOT EXECUTED 40006ae4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED *allocatable_size = info.largest - HEAP_BLOCK_HEADER_SIZE + HEAP_ALLOC_BONUS; 40006ae8: 82 00 7f fc add %g1, -4, %g1 40006aec: c2 26 40 00 st %g1, [ %i1 ] return _Heap_Greedy_allocate( heap, allocatable_size, 1 ); 40006af0: 92 10 00 19 mov %i1, %o1 40006af4: 7f ff ff ad call 400069a8 <_Heap_Greedy_allocate> 40006af8: 90 10 00 18 mov %i0, %o0 } 40006afc: 81 c7 e0 08 ret 40006b00: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 40008904 <_Heap_Greedy_free>: void _Heap_Greedy_free( Heap_Control *heap, Heap_Block *blocks ) { 40008904: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED while ( blocks != NULL ) { 40008908: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4000890c: 02 80 00 09 be 40008930 <_Heap_Greedy_free+0x2c> <== NOT EXECUTED 40008910: 01 00 00 00 nop Heap_Block *current = blocks; blocks = blocks->next; 40008914: fa 06 60 08 ld [ %i1 + 8 ], %i5 _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); 40008918: 92 06 60 08 add %i1, 8, %o1 4000891c: 40 00 19 d8 call 4000f07c <_Heap_Free> 40008920: 90 10 00 18 mov %i0, %o0 while ( blocks != NULL ) { 40008924: b2 97 60 00 orcc %i5, 0, %i1 40008928: 32 bf ff fc bne,a 40008918 <_Heap_Greedy_free+0x14> 4000892c: fa 06 60 08 ld [ %i1 + 8 ], %i5 } } 40008930: 81 c7 e0 08 ret 40008934: 81 e8 00 00 restore =============================================================================== 40007580 <_Heap_Initialize>: { 40007580: 9d e3 bf a0 save %sp, -96, %sp 40007584: a2 86 40 1a addcc %i1, %i2, %l1 40007588: 84 40 20 00 addx %g0, 0, %g2 if ( page_size == 0 ) { 4000758c: 80 a6 e0 00 cmp %i3, 0 40007590: 22 80 00 33 be,a 4000765c <_Heap_Initialize+0xdc> 40007594: b6 10 20 08 mov 8, %i3 if ( remainder != 0 ) { 40007598: 82 8e e0 07 andcc %i3, 7, %g1 4000759c: 02 80 00 05 be 400075b0 <_Heap_Initialize+0x30> 400075a0: 80 a6 e0 07 cmp %i3, 7 return value - remainder + alignment; 400075a4: b6 06 e0 08 add %i3, 8, %i3 400075a8: b6 26 c0 01 sub %i3, %g1, %i3 if ( page_size < CPU_ALIGNMENT ) { 400075ac: 80 a6 e0 07 cmp %i3, 7 400075b0: 08 80 00 29 bleu 40007654 <_Heap_Initialize+0xd4> 400075b4: ba 10 20 00 clr %i5 uintptr_t remainder = value % alignment; 400075b8: 82 10 20 10 mov 0x10, %g1 400075bc: 81 80 20 00 wr %g0, %y 400075c0: 01 00 00 00 nop 400075c4: 01 00 00 00 nop 400075c8: 01 00 00 00 nop 400075cc: 86 70 40 1b udiv %g1, %i3, %g3 400075d0: 86 58 c0 1b smul %g3, %i3, %g3 if ( remainder != 0 ) { 400075d4: 82 a0 40 03 subcc %g1, %g3, %g1 400075d8: 02 80 00 22 be 40007660 <_Heap_Initialize+0xe0> 400075dc: a0 10 20 10 mov 0x10, %l0 _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 400075e0: b8 06 60 08 add %i1, 8, %i4 return value - remainder + alignment; 400075e4: a0 06 e0 10 add %i3, 0x10, %l0 400075e8: a0 24 00 01 sub %l0, %g1, %l0 uintptr_t remainder = value % alignment; 400075ec: 81 80 20 00 wr %g0, %y 400075f0: 01 00 00 00 nop 400075f4: 01 00 00 00 nop 400075f8: 01 00 00 00 nop 400075fc: 82 77 00 1b udiv %i4, %i3, %g1 40007600: 82 58 40 1b smul %g1, %i3, %g1 if ( remainder != 0 ) { 40007604: 82 a7 00 01 subcc %i4, %g1, %g1 40007608: 12 80 00 21 bne 4000768c <_Heap_Initialize+0x10c> <== ALWAYS TAKEN 4000760c: b8 06 40 1b add %i1, %i3, %i4 uintptr_t const heap_area_begin = (uintptr_t) heap_area_begin_ptr; 40007610: b8 10 00 19 mov %i1, %i4 <== NOT EXECUTED 40007614: 82 10 20 08 mov 8, %g1 || heap_area_size <= overhead 40007618: 80 a0 40 1a cmp %g1, %i2 _Heap_Align_down( heap_area_size - overhead, page_size ); 4000761c: b4 26 80 01 sub %i2, %g1, %i2 || heap_area_size <= overhead 40007620: 82 60 3f ff subx %g0, -1, %g1 return value - (value % alignment); 40007624: 81 80 20 00 wr %g0, %y 40007628: 01 00 00 00 nop 4000762c: 01 00 00 00 nop 40007630: 01 00 00 00 nop 40007634: ba 76 80 1b udiv %i2, %i3, %i5 || first_block_size < min_block_size 40007638: 80 90 80 01 orcc %g2, %g1, %g0 4000763c: 12 80 00 05 bne 40007650 <_Heap_Initialize+0xd0> 40007640: ba 5f 40 1b smul %i5, %i3, %i5 40007644: 80 a7 40 10 cmp %i5, %l0 40007648: 1a 80 00 15 bcc 4000769c <_Heap_Initialize+0x11c> 4000764c: 94 10 20 68 mov 0x68, %o2 return 0; 40007650: ba 10 20 00 clr %i5 } 40007654: 81 c7 e0 08 ret 40007658: 91 e8 00 1d restore %g0, %i5, %o0 } else { return value; 4000765c: a0 10 20 10 mov 0x10, %l0 _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 40007660: b8 06 60 08 add %i1, 8, %i4 uintptr_t remainder = value % alignment; 40007664: 81 80 20 00 wr %g0, %y 40007668: 01 00 00 00 nop 4000766c: 01 00 00 00 nop 40007670: 01 00 00 00 nop 40007674: 82 77 00 1b udiv %i4, %i3, %g1 40007678: 82 58 40 1b smul %g1, %i3, %g1 if ( remainder != 0 ) { 4000767c: 82 a7 00 01 subcc %i4, %g1, %g1 40007680: 22 bf ff e5 be,a 40007614 <_Heap_Initialize+0x94> 40007684: b8 10 00 19 mov %i1, %i4 40007688: b8 06 40 1b add %i1, %i3, %i4 4000768c: b8 27 00 01 sub %i4, %g1, %i4 40007690: 82 27 00 19 sub %i4, %i1, %g1 40007694: 10 bf ff e1 b 40007618 <_Heap_Initialize+0x98> 40007698: 82 00 60 08 add %g1, 8, %g1 memset(heap, 0, sizeof(*heap)); 4000769c: 92 10 20 00 clr %o1 400076a0: 40 00 1e d8 call 4000f200 400076a4: 90 10 00 18 mov %i0, %o0 first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED; 400076a8: 82 17 60 01 or %i5, 1, %g1 first_block->next = _Heap_Free_list_tail( heap ); 400076ac: f0 27 20 08 st %i0, [ %i4 + 8 ] return (Heap_Block *) ((uintptr_t) block + offset); 400076b0: 86 07 40 1c add %i5, %i4, %g3 first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED; 400076b4: c2 27 20 04 st %g1, [ %i4 + 4 ] _Heap_Block_set_size( 400076b8: 82 20 00 1d neg %i5, %g1 first_block->prev = _Heap_Free_list_head( heap ); 400076bc: f0 27 20 0c st %i0, [ %i4 + 0xc ] stats->free_blocks = 1; 400076c0: 84 10 20 01 mov 1, %g2 first_block->prev_size = heap_area_end; 400076c4: e2 27 00 00 st %l1, [ %i4 ] heap->page_size = page_size; 400076c8: f6 26 20 10 st %i3, [ %i0 + 0x10 ] heap->min_block_size = min_block_size; 400076cc: e0 26 20 14 st %l0, [ %i0 + 0x14 ] heap->area_begin = heap_area_begin; 400076d0: f2 26 20 18 st %i1, [ %i0 + 0x18 ] heap->area_end = heap_area_end; 400076d4: e2 26 20 1c st %l1, [ %i0 + 0x1c ] heap->first_block = first_block; 400076d8: f8 26 20 20 st %i4, [ %i0 + 0x20 ] heap->last_block = last_block; 400076dc: c6 26 20 24 st %g3, [ %i0 + 0x24 ] _Heap_Free_list_head( heap )->next = first_block; 400076e0: f8 26 20 08 st %i4, [ %i0 + 8 ] _Heap_Free_list_tail( heap )->prev = first_block; 400076e4: f8 26 20 0c st %i4, [ %i0 + 0xc ] last_block->prev_size = first_block_size; 400076e8: fa 27 40 1c st %i5, [ %i5 + %i4 ] block->size_and_flag = size | flag; 400076ec: c2 20 e0 04 st %g1, [ %g3 + 4 ] stats->size = first_block_size; 400076f0: fa 26 20 38 st %i5, [ %i0 + 0x38 ] stats->free_size = first_block_size; 400076f4: fa 26 20 3c st %i5, [ %i0 + 0x3c ] stats->min_free_size = first_block_size; 400076f8: fa 26 20 40 st %i5, [ %i0 + 0x40 ] stats->free_blocks = 1; 400076fc: c4 26 20 44 st %g2, [ %i0 + 0x44 ] stats->max_free_blocks = 1; 40007700: c4 26 20 48 st %g2, [ %i0 + 0x48 ] } 40007704: 81 c7 e0 08 ret 40007708: 91 e8 00 1d restore %g0, %i5, %o0 =============================================================================== 40009fbc <_Heap_Iterate>: void _Heap_Iterate( Heap_Control *heap, Heap_Block_visitor visitor, void *visitor_arg ) { 40009fbc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Heap_Block *current = heap->first_block; 40009fc0: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED Heap_Block *end = heap->last_block; 40009fc4: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 <== NOT EXECUTED bool stop = false; while ( !stop && current != end ) { 40009fc8: 80 a0 40 1c cmp %g1, %i4 <== NOT EXECUTED 40009fcc: 32 80 00 07 bne,a 40009fe8 <_Heap_Iterate+0x2c> <== NOT EXECUTED 40009fd0: d2 00 60 04 ld [ %g1 + 4 ], %o1 40009fd4: 30 80 00 10 b,a 4000a014 <_Heap_Iterate+0x58> <== NOT EXECUTED 40009fd8: 80 a7 00 1d cmp %i4, %i5 40009fdc: 02 80 00 0e be 4000a014 <_Heap_Iterate+0x58> 40009fe0: 01 00 00 00 nop return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40009fe4: d2 00 60 04 ld [ %g1 + 4 ], %o1 40009fe8: 92 0a 7f fe and %o1, -2, %o1 return (Heap_Block *) ((uintptr_t) block + offset); 40009fec: ba 00 40 09 add %g1, %o1, %i5 block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40009ff0: d4 07 60 04 ld [ %i5 + 4 ], %o2 uintptr_t size = _Heap_Block_size( current ); Heap_Block *next = _Heap_Block_at( current, size ); bool used = _Heap_Is_prev_used( next ); stop = (*visitor)( current, size, used, visitor_arg ); 40009ff4: 90 10 00 01 mov %g1, %o0 40009ff8: 96 10 00 1a mov %i2, %o3 40009ffc: 9f c6 40 00 call %i1 4000a000: 94 0a a0 01 and %o2, 1, %o2 while ( !stop && current != end ) { 4000a004: 90 1a 20 01 xor %o0, 1, %o0 4000a008: 80 8a 20 ff btst 0xff, %o0 4000a00c: 12 bf ff f3 bne 40009fd8 <_Heap_Iterate+0x1c> <== ALWAYS TAKEN 4000a010: 82 10 00 1d mov %i5, %g1 current = next; } } 4000a014: 81 c7 e0 08 ret 4000a018: 81 e8 00 00 restore =============================================================================== 4000a600 <_Heap_No_extend>: uintptr_t unused_2 RTEMS_UNUSED, uintptr_t unused_3 RTEMS_UNUSED ) { return 0; } 4000a600: 81 c3 e0 08 retl <== NOT EXECUTED 4000a604: 90 10 20 00 clr %o0 =============================================================================== 40018a28 <_Heap_Resize_block>: void *alloc_begin_ptr, uintptr_t new_alloc_size, uintptr_t *old_size, uintptr_t *new_size ) { 40018a28: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED return value - (value % alignment); 40018a2c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr; Heap_Block *const block = _Heap_Block_of_alloc_area( alloc_begin, page_size ); *old_size = 0; 40018a30: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED 40018a34: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 40018a38: 01 00 00 00 nop <== NOT EXECUTED 40018a3c: 01 00 00 00 nop <== NOT EXECUTED 40018a40: 01 00 00 00 nop <== NOT EXECUTED 40018a44: 92 76 40 01 udiv %i1, %g1, %o1 <== NOT EXECUTED *new_size = 0; 40018a48: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED 40018a4c: 92 5a 40 01 smul %o1, %g1, %o1 <== NOT EXECUTED && (uintptr_t) block <= (uintptr_t) heap->last_block; 40018a50: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED { 40018a54: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED - HEAP_BLOCK_HEADER_SIZE); 40018a58: 92 02 7f f8 add %o1, -8, %o1 <== NOT EXECUTED && (uintptr_t) block <= (uintptr_t) heap->last_block; 40018a5c: 80 a0 40 09 cmp %g1, %o1 <== NOT EXECUTED 40018a60: 18 80 00 3a bgu 40018b48 <_Heap_Resize_block+0x120> <== NOT EXECUTED 40018a64: b0 10 20 02 mov 2, %i0 40018a68: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 40018a6c: 80 a0 40 09 cmp %g1, %o1 40018a70: 0a 80 00 36 bcs 40018b48 <_Heap_Resize_block+0x120> 40018a74: 90 10 20 04 mov 4, %o0 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40018a78: c2 02 60 04 ld [ %o1 + 4 ], %g1 40018a7c: 82 08 7f fe and %g1, -2, %g1 uintptr_t block_end = block_begin + block_size; 40018a80: 86 02 40 01 add %o1, %g1, %g3 40018a84: c4 00 e0 04 ld [ %g3 + 4 ], %g2 40018a88: 84 08 bf fe and %g2, -2, %g2 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40018a8c: b0 00 c0 02 add %g3, %g2, %i0 40018a90: a0 22 00 19 sub %o0, %i1, %l0 40018a94: f0 06 20 04 ld [ %i0 + 4 ], %i0 uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS; 40018a98: 88 00 c0 10 add %g3, %l0, %g4 if ( next_block_is_free ) { 40018a9c: 80 8e 20 01 btst 1, %i0 40018aa0: 12 80 00 27 bne 40018b3c <_Heap_Resize_block+0x114> 40018aa4: c8 26 c0 00 st %g4, [ %i3 ] alloc_size += next_block_size; 40018aa8: 88 01 00 02 add %g4, %g2, %g4 if ( new_alloc_size > alloc_size ) { 40018aac: 80 a6 80 04 cmp %i2, %g4 40018ab0: 18 80 00 26 bgu 40018b48 <_Heap_Resize_block+0x120> 40018ab4: b0 10 20 01 mov 1, %i0 uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 40018ab8: c8 02 60 04 ld [ %o1 + 4 ], %g4 40018abc: f6 00 e0 08 ld [ %g3 + 8 ], %i3 40018ac0: f0 00 e0 0c ld [ %g3 + 0xc ], %i0 block_size += next_block_size; 40018ac4: 82 00 40 02 add %g1, %g2, %g1 40018ac8: 86 09 20 01 and %g4, 1, %g3 block->size_and_flag = size | flag; 40018acc: 86 10 c0 01 or %g3, %g1, %g3 40018ad0: c6 22 60 04 st %g3, [ %o1 + 4 ] return (Heap_Block *) ((uintptr_t) block + offset); 40018ad4: 82 02 40 01 add %o1, %g1, %g1 prev->next = next; 40018ad8: f6 26 20 08 st %i3, [ %i0 + 8 ] next_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 40018adc: c8 00 60 04 ld [ %g1 + 4 ], %g4 next->prev = prev; 40018ae0: f0 26 e0 0c st %i0, [ %i3 + 0xc ] 40018ae4: 88 11 20 01 or %g4, 1, %g4 --stats->free_blocks; 40018ae8: c6 07 60 44 ld [ %i5 + 0x44 ], %g3 next_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 40018aec: c8 20 60 04 st %g4, [ %g1 + 4 ] --stats->free_blocks; 40018af0: 86 00 ff ff add %g3, -1, %g3 stats->free_size -= next_block_size; 40018af4: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 40018af8: 84 20 40 02 sub %g1, %g2, %g2 --stats->free_blocks; 40018afc: c6 27 60 44 st %g3, [ %i5 + 0x44 ] stats->free_size -= next_block_size; 40018b00: c4 27 60 3c st %g2, [ %i5 + 0x3c ] block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size ); 40018b04: 96 10 00 1a mov %i2, %o3 40018b08: 94 10 00 19 mov %i1, %o2 40018b0c: 7f ff bb 00 call 4000770c <_Heap_Block_allocate> 40018b10: 90 10 00 1d mov %i5, %o0 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40018b14: c2 02 20 04 ld [ %o0 + 4 ], %g1 ++stats->resizes; 40018b18: c4 07 60 64 ld [ %i5 + 0x64 ], %g2 40018b1c: 82 08 7f fe and %g1, -2, %g1 *new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS; 40018b20: 90 02 00 10 add %o0, %l0, %o0 40018b24: 90 00 40 08 add %g1, %o0, %o0 40018b28: d0 27 00 00 st %o0, [ %i4 ] ++stats->resizes; 40018b2c: 82 00 a0 01 add %g2, 1, %g1 40018b30: c2 27 60 64 st %g1, [ %i5 + 0x64 ] return HEAP_RESIZE_SUCCESSFUL; 40018b34: 81 c7 e0 08 ret 40018b38: 91 e8 20 00 restore %g0, 0, %o0 if ( new_alloc_size > alloc_size ) { 40018b3c: 80 a6 80 04 cmp %i2, %g4 40018b40: 08 bf ff f1 bleu 40018b04 <_Heap_Resize_block+0xdc> 40018b44: b0 10 20 01 mov 1, %i0 old_size, new_size ); } return HEAP_RESIZE_FATAL_ERROR; } 40018b48: 81 c7 e0 08 ret 40018b4c: 81 e8 00 00 restore =============================================================================== 400085c0 <_Heap_Size_of_alloc_area>: return value - (value % alignment); 400085c0: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 <== NOT EXECUTED return (uintptr_t) block >= (uintptr_t) heap->first_block 400085c4: c8 02 20 20 ld [ %o0 + 0x20 ], %g4 <== NOT EXECUTED return value - (value % alignment); 400085c8: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 400085cc: 01 00 00 00 nop <== NOT EXECUTED 400085d0: 01 00 00 00 nop <== NOT EXECUTED 400085d4: 01 00 00 00 nop <== NOT EXECUTED 400085d8: 82 72 40 02 udiv %o1, %g2, %g1 <== NOT EXECUTED 400085dc: 82 58 40 02 smul %g1, %g2, %g1 <== NOT EXECUTED - HEAP_BLOCK_HEADER_SIZE); 400085e0: 82 00 7f f8 add %g1, -8, %g1 <== NOT EXECUTED && (uintptr_t) block <= (uintptr_t) heap->last_block; 400085e4: 80 a1 00 01 cmp %g4, %g1 <== NOT EXECUTED 400085e8: 18 80 00 15 bgu 4000863c <_Heap_Size_of_alloc_area+0x7c> <== NOT EXECUTED 400085ec: 86 10 20 00 clr %g3 400085f0: da 02 20 24 ld [ %o0 + 0x24 ], %o5 400085f4: 80 a3 40 01 cmp %o5, %g1 400085f8: 0a 80 00 11 bcs 4000863c <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN 400085fc: 01 00 00 00 nop return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40008600: c4 00 60 04 ld [ %g1 + 4 ], %g2 40008604: 84 08 bf fe and %g2, -2, %g2 return (Heap_Block *) ((uintptr_t) block + offset); 40008608: 82 00 80 01 add %g2, %g1, %g1 && (uintptr_t) block <= (uintptr_t) heap->last_block; 4000860c: 80 a1 00 01 cmp %g4, %g1 40008610: 18 80 00 0b bgu 4000863c <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN 40008614: 80 a3 40 01 cmp %o5, %g1 40008618: 0a 80 00 09 bcs 4000863c <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN 4000861c: 01 00 00 00 nop return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40008620: c4 00 60 04 ld [ %g1 + 4 ], %g2 block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) 40008624: 80 88 a0 01 btst 1, %g2 40008628: 02 80 00 05 be 4000863c <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN 4000862c: 82 20 40 09 sub %g1, %o1, %g1 ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 40008630: 82 00 60 04 add %g1, 4, %g1 40008634: c2 22 80 00 st %g1, [ %o2 ] return true; 40008638: 86 10 20 01 mov 1, %g3 } 4000863c: 81 c3 e0 08 retl 40008640: 90 08 e0 ff and %g3, 0xff, %o0 =============================================================================== 4000777c <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 4000777c: 9d e3 bf 78 save %sp, -136, %sp uintptr_t const min_block_size = heap->min_block_size; Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block; Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 40007780: 80 a6 a0 00 cmp %i2, 0 40007784: 02 80 00 0b be 400077b0 <_Heap_Walk+0x34> 40007788: 03 10 00 54 sethi %hi(0x40015000), %g1 if ( !_System_state_Is_up( _System_state_Get() ) ) { 4000778c: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 ! 4001503c <_System_state_Current> _Heap_Walk_print : _Heap_Walk_print_nothing; 40007790: 21 10 00 1d sethi %hi(0x40007400), %l0 if ( !_System_state_Is_up( _System_state_Get() ) ) { 40007794: 80 a0 60 02 cmp %g1, 2 40007798: 02 80 00 0b be 400077c4 <_Heap_Walk+0x48> <== ALWAYS TAKEN 4000779c: a0 14 23 18 or %l0, 0x318, %l0 return true; 400077a0: b4 10 20 01 mov 1, %i2 400077a4: b0 0e a0 ff and %i2, 0xff, %i0 block = next_block; } while ( block != first_block ); return true; } 400077a8: 81 c7 e0 08 ret 400077ac: 81 e8 00 00 restore if ( !_System_state_Is_up( _System_state_Get() ) ) { 400077b0: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 _Heap_Walk_print : _Heap_Walk_print_nothing; 400077b4: 21 10 00 1d sethi %hi(0x40007400), %l0 if ( !_System_state_Is_up( _System_state_Get() ) ) { 400077b8: 80 a0 60 02 cmp %g1, 2 400077bc: 12 bf ff f9 bne 400077a0 <_Heap_Walk+0x24> 400077c0: a0 14 23 10 or %l0, 0x310, %l0 Heap_Block *const first_block = heap->first_block; 400077c4: e4 06 20 20 ld [ %i0 + 0x20 ], %l2 Heap_Block *const last_block = heap->last_block; 400077c8: e2 06 20 24 ld [ %i0 + 0x24 ], %l1 (*printer)( 400077cc: c6 06 20 0c ld [ %i0 + 0xc ], %g3 400077d0: c4 06 20 08 ld [ %i0 + 8 ], %g2 400077d4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 400077d8: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 400077dc: 15 10 00 43 sethi %hi(0x40010c00), %o2 400077e0: c6 23 a0 6c st %g3, [ %sp + 0x6c ] 400077e4: 94 12 a2 60 or %o2, 0x260, %o2 400077e8: c4 23 a0 68 st %g2, [ %sp + 0x68 ] 400077ec: 92 10 20 00 clr %o1 400077f0: e2 23 a0 64 st %l1, [ %sp + 0x64 ] 400077f4: 90 10 00 19 mov %i1, %o0 400077f8: e4 23 a0 60 st %l2, [ %sp + 0x60 ] uintptr_t const page_size = heap->page_size; 400077fc: ec 06 20 10 ld [ %i0 + 0x10 ], %l6 uintptr_t const min_block_size = heap->min_block_size; 40007800: e6 06 20 14 ld [ %i0 + 0x14 ], %l3 (*printer)( 40007804: da 06 20 18 ld [ %i0 + 0x18 ], %o5 40007808: 98 10 00 13 mov %l3, %o4 4000780c: 9f c4 00 00 call %l0 40007810: 96 10 00 16 mov %l6, %o3 if ( page_size == 0 ) { 40007814: 80 a5 a0 00 cmp %l6, 0 40007818: 12 80 00 0a bne 40007840 <_Heap_Walk+0xc4> 4000781c: 92 10 20 01 mov 1, %o1 (*printer)( source, true, "page size is zero\n" ); 40007820: 90 10 00 19 mov %i1, %o0 return false; 40007824: b4 10 20 00 clr %i2 (*printer)( source, true, "page size is zero\n" ); 40007828: 15 10 00 43 sethi %hi(0x40010c00), %o2 4000782c: b0 0e a0 ff and %i2, 0xff, %i0 40007830: 9f c4 00 00 call %l0 40007834: 94 12 a2 f8 or %o2, 0x2f8, %o2 } 40007838: 81 c7 e0 08 ret 4000783c: 81 e8 00 00 restore if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 40007840: 80 8d a0 07 btst 7, %l6 40007844: 02 80 00 0b be 40007870 <_Heap_Walk+0xf4> 40007848: 96 10 00 16 mov %l6, %o3 (*printer)( 4000784c: 92 10 20 01 mov 1, %o1 40007850: 15 10 00 43 sethi %hi(0x40010c00), %o2 40007854: 90 10 00 19 mov %i1, %o0 40007858: 94 12 a3 10 or %o2, 0x310, %o2 4000785c: 9f c4 00 00 call %l0 40007860: b4 10 20 00 clr %i2 40007864: b0 0e a0 ff and %i2, 0xff, %i0 40007868: 81 c7 e0 08 ret 4000786c: 81 e8 00 00 restore return (value % alignment) == 0; 40007870: 81 80 20 00 wr %g0, %y 40007874: 01 00 00 00 nop 40007878: 01 00 00 00 nop 4000787c: 01 00 00 00 nop 40007880: 82 74 c0 16 udiv %l3, %l6, %g1 40007884: 82 58 40 16 smul %g1, %l6, %g1 if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 40007888: 80 a4 c0 01 cmp %l3, %g1 4000788c: 02 80 00 0b be 400078b8 <_Heap_Walk+0x13c> 40007890: 96 10 00 13 mov %l3, %o3 (*printer)( 40007894: 92 10 20 01 mov 1, %o1 40007898: 15 10 00 43 sethi %hi(0x40010c00), %o2 4000789c: 90 10 00 19 mov %i1, %o0 400078a0: 94 12 a3 30 or %o2, 0x330, %o2 400078a4: 9f c4 00 00 call %l0 400078a8: b4 10 20 00 clr %i2 400078ac: b0 0e a0 ff and %i2, 0xff, %i0 400078b0: 81 c7 e0 08 ret 400078b4: 81 e8 00 00 restore return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 400078b8: 86 04 a0 08 add %l2, 8, %g3 return (value % alignment) == 0; 400078bc: 81 80 20 00 wr %g0, %y 400078c0: 01 00 00 00 nop 400078c4: 01 00 00 00 nop 400078c8: 01 00 00 00 nop 400078cc: 82 70 c0 16 udiv %g3, %l6, %g1 400078d0: 82 58 40 16 smul %g1, %l6, %g1 if ( 400078d4: 80 a0 c0 01 cmp %g3, %g1 400078d8: 02 80 00 0b be 40007904 <_Heap_Walk+0x188> 400078dc: 96 10 00 12 mov %l2, %o3 (*printer)( 400078e0: 92 10 20 01 mov 1, %o1 400078e4: 15 10 00 43 sethi %hi(0x40010c00), %o2 400078e8: 90 10 00 19 mov %i1, %o0 400078ec: 94 12 a3 58 or %o2, 0x358, %o2 400078f0: 9f c4 00 00 call %l0 400078f4: b4 10 20 00 clr %i2 400078f8: b0 0e a0 ff and %i2, 0xff, %i0 400078fc: 81 c7 e0 08 ret 40007900: 81 e8 00 00 restore return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40007904: c2 04 a0 04 ld [ %l2 + 4 ], %g1 if ( !_Heap_Is_prev_used( first_block ) ) { 40007908: 80 88 60 01 btst 1, %g1 4000790c: 12 80 00 0a bne 40007934 <_Heap_Walk+0x1b8> 40007910: 92 10 20 01 mov 1, %o1 (*printer)( 40007914: 15 10 00 43 sethi %hi(0x40010c00), %o2 40007918: 90 10 00 19 mov %i1, %o0 4000791c: 94 12 a3 90 or %o2, 0x390, %o2 40007920: 9f c4 00 00 call %l0 40007924: b4 10 20 00 clr %i2 40007928: b0 0e a0 ff and %i2, 0xff, %i0 4000792c: 81 c7 e0 08 ret 40007930: 81 e8 00 00 restore return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40007934: c2 04 60 04 ld [ %l1 + 4 ], %g1 40007938: 82 08 7f fe and %g1, -2, %g1 return (Heap_Block *) ((uintptr_t) block + offset); 4000793c: 82 04 40 01 add %l1, %g1, %g1 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40007940: c6 00 60 04 ld [ %g1 + 4 ], %g3 if ( _Heap_Is_free( last_block ) ) { 40007944: 80 88 e0 01 btst 1, %g3 40007948: 12 80 00 09 bne 4000796c <_Heap_Walk+0x1f0> 4000794c: 15 10 00 43 sethi %hi(0x40010c00), %o2 (*printer)( 40007950: 90 10 00 19 mov %i1, %o0 40007954: 94 12 a3 c0 or %o2, 0x3c0, %o2 40007958: 9f c4 00 00 call %l0 4000795c: b4 10 20 00 clr %i2 40007960: b0 0e a0 ff and %i2, 0xff, %i0 40007964: 81 c7 e0 08 ret 40007968: 81 e8 00 00 restore if ( 4000796c: 80 a4 80 01 cmp %l2, %g1 40007970: 02 80 00 0a be 40007998 <_Heap_Walk+0x21c> 40007974: 92 10 20 01 mov 1, %o1 (*printer)( 40007978: 15 10 00 43 sethi %hi(0x40010c00), %o2 4000797c: 90 10 00 19 mov %i1, %o0 40007980: 94 12 a3 d8 or %o2, 0x3d8, %o2 40007984: 9f c4 00 00 call %l0 40007988: b4 10 20 00 clr %i2 4000798c: b0 0e a0 ff and %i2, 0xff, %i0 40007990: 81 c7 e0 08 ret 40007994: 81 e8 00 00 restore uintptr_t const page_size = heap->page_size; 40007998: fa 06 20 10 ld [ %i0 + 0x10 ], %i5 return _Heap_Free_list_head(heap)->next; 4000799c: e8 06 20 08 ld [ %i0 + 8 ], %l4 400079a0: c6 06 20 20 ld [ %i0 + 0x20 ], %g3 const Heap_Block *prev_block = free_list_tail; 400079a4: 88 10 00 18 mov %i0, %g4 while ( free_block != free_list_tail ) { 400079a8: 80 a6 00 14 cmp %i0, %l4 400079ac: 02 80 00 1f be 40007a28 <_Heap_Walk+0x2ac> 400079b0: 80 a5 00 03 cmp %l4, %g3 && (uintptr_t) block <= (uintptr_t) heap->last_block; 400079b4: 0a 80 00 f9 bcs 40007d98 <_Heap_Walk+0x61c> 400079b8: 96 10 00 14 mov %l4, %o3 400079bc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 400079c0: 80 a0 40 14 cmp %g1, %l4 400079c4: 0a 80 00 f6 bcs 40007d9c <_Heap_Walk+0x620> <== NEVER TAKEN 400079c8: 92 10 20 01 mov 1, %o1 return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 400079cc: b8 05 20 08 add %l4, 8, %i4 return (value % alignment) == 0; 400079d0: 81 80 20 00 wr %g0, %y 400079d4: 01 00 00 00 nop 400079d8: 01 00 00 00 nop 400079dc: 01 00 00 00 nop 400079e0: 82 77 00 1d udiv %i4, %i5, %g1 400079e4: 82 58 40 1d smul %g1, %i5, %g1 if ( 400079e8: 80 a7 00 01 cmp %i4, %g1 400079ec: 12 80 00 e4 bne 40007d7c <_Heap_Walk+0x600> 400079f0: 15 10 00 44 sethi %hi(0x40011000), %o2 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 400079f4: c2 05 20 04 ld [ %l4 + 4 ], %g1 400079f8: 82 08 7f fe and %g1, -2, %g1 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 400079fc: 82 05 00 01 add %l4, %g1, %g1 40007a00: c2 00 60 04 ld [ %g1 + 4 ], %g1 if ( _Heap_Is_used( free_block ) ) { 40007a04: 80 88 60 01 btst 1, %g1 40007a08: 12 80 00 d6 bne 40007d60 <_Heap_Walk+0x5e4> 40007a0c: 15 10 00 44 sethi %hi(0x40011000), %o2 if ( free_block->prev != prev_block ) { 40007a10: d8 05 20 0c ld [ %l4 + 0xc ], %o4 40007a14: 80 a3 00 04 cmp %o4, %g4 40007a18: 12 80 00 c9 bne 40007d3c <_Heap_Walk+0x5c0> 40007a1c: 88 10 00 14 mov %l4, %g4 free_block = free_block->next; 40007a20: 10 bf ff e2 b 400079a8 <_Heap_Walk+0x22c> 40007a24: e8 05 20 08 ld [ %l4 + 8 ], %l4 (*printer)( 40007a28: 2f 10 00 43 sethi %hi(0x40010c00), %l7 40007a2c: 82 15 e2 40 or %l7, 0x240, %g1 ! 40010e40 <_Objects_Information_table+0x60> 40007a30: c2 27 bf fc st %g1, [ %fp + -4 ] : (block->next == free_list_tail ? " (= tail)" : "") 40007a34: 03 10 00 43 sethi %hi(0x40010c00), %g1 40007a38: 82 10 62 50 or %g1, 0x250, %g1 ! 40010e50 <_Objects_Information_table+0x70> 40007a3c: c2 27 bf f4 st %g1, [ %fp + -12 ] (*printer)( 40007a40: 03 10 00 43 sethi %hi(0x40010c00), %g1 40007a44: 82 10 62 20 or %g1, 0x220, %g1 ! 40010e20 <_Objects_Information_table+0x40> 40007a48: c2 27 bf f8 st %g1, [ %fp + -8 ] : (block->prev == free_list_head ? " (= head)" : ""), 40007a4c: 03 10 00 43 sethi %hi(0x40010c00), %g1 40007a50: 82 10 62 30 or %g1, 0x230, %g1 ! 40010e30 <_Objects_Information_table+0x50> 40007a54: c2 27 bf f0 st %g1, [ %fp + -16 ] : (block->next == free_list_tail ? " (= tail)" : "") 40007a58: 2b 10 00 44 sethi %hi(0x40011000), %l5 while ( free_block != free_list_tail ) { 40007a5c: ba 10 00 12 mov %l2, %i5 : (block->next == free_list_tail ? " (= tail)" : "") 40007a60: aa 15 61 98 or %l5, 0x198, %l5 40007a64: c2 07 60 04 ld [ %i5 + 4 ], %g1 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40007a68: b6 08 7f fe and %g1, -2, %i3 return (Heap_Block *) ((uintptr_t) block + offset); 40007a6c: b8 07 40 1b add %i5, %i3, %i4 && (uintptr_t) block <= (uintptr_t) heap->last_block; 40007a70: 80 a0 c0 1c cmp %g3, %i4 40007a74: 18 80 00 06 bgu 40007a8c <_Heap_Walk+0x310> <== NEVER TAKEN 40007a78: ae 08 60 01 and %g1, 1, %l7 40007a7c: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 40007a80: 80 a0 c0 1c cmp %g3, %i4 40007a84: 1a 80 00 0d bcc 40007ab8 <_Heap_Walk+0x33c> 40007a88: 01 00 00 00 nop (*printer)( 40007a8c: 98 10 00 1c mov %i4, %o4 40007a90: 96 10 00 1d mov %i5, %o3 40007a94: 92 10 20 01 mov 1, %o1 40007a98: 90 10 00 19 mov %i1, %o0 return false; 40007a9c: b4 10 20 00 clr %i2 (*printer)( 40007aa0: 15 10 00 44 sethi %hi(0x40011000), %o2 40007aa4: b0 0e a0 ff and %i2, 0xff, %i0 40007aa8: 9f c4 00 00 call %l0 40007aac: 94 12 a2 30 or %o2, 0x230, %o2 } 40007ab0: 81 c7 e0 08 ret 40007ab4: 81 e8 00 00 restore return (value % alignment) == 0; 40007ab8: 81 80 20 00 wr %g0, %y 40007abc: 01 00 00 00 nop 40007ac0: 01 00 00 00 nop 40007ac4: 01 00 00 00 nop 40007ac8: 86 76 c0 16 udiv %i3, %l6, %g3 40007acc: 86 58 c0 16 smul %g3, %l6, %g3 if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 40007ad0: 80 a6 c0 03 cmp %i3, %g3 40007ad4: 02 80 00 17 be 40007b30 <_Heap_Walk+0x3b4> 40007ad8: 86 1f 40 11 xor %i5, %l1, %g3 40007adc: 80 a7 40 11 cmp %i5, %l1 40007ae0: 12 80 00 79 bne 40007cc4 <_Heap_Walk+0x548> 40007ae4: 98 10 00 1b mov %i3, %o4 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40007ae8: c6 07 20 04 ld [ %i4 + 4 ], %g3 if ( !_Heap_Is_prev_used( next_block ) ) { 40007aec: 80 88 e0 01 btst 1, %g3 40007af0: 02 80 00 30 be 40007bb0 <_Heap_Walk+0x434> 40007af4: 80 a5 e0 00 cmp %l7, 0 } else if (prev_used) { 40007af8: 22 80 00 25 be,a 40007b8c <_Heap_Walk+0x410> 40007afc: da 07 40 00 ld [ %i5 ], %o5 (*printer)( 40007b00: 15 10 00 44 sethi %hi(0x40011000), %o2 40007b04: 98 10 00 1b mov %i3, %o4 40007b08: 96 10 00 1d mov %i5, %o3 40007b0c: 94 12 a1 d0 or %o2, 0x1d0, %o2 40007b10: 92 10 20 00 clr %o1 40007b14: 9f c4 00 00 call %l0 40007b18: 90 10 00 19 mov %i1, %o0 } while ( block != first_block ); 40007b1c: 80 a4 80 1c cmp %l2, %i4 40007b20: 02 bf ff 20 be 400077a0 <_Heap_Walk+0x24> 40007b24: ba 10 00 1c mov %i4, %i5 40007b28: 10 bf ff cf b 40007a64 <_Heap_Walk+0x2e8> 40007b2c: c6 06 20 20 ld [ %i0 + 0x20 ], %g3 bool const is_not_last_block = block != last_block; 40007b30: 80 a0 00 03 cmp %g0, %g3 40007b34: 88 40 20 00 addx %g0, 0, %g4 if ( block_size < min_block_size && is_not_last_block ) { 40007b38: 80 a6 c0 13 cmp %i3, %l3 40007b3c: 86 40 20 00 addx %g0, 0, %g3 40007b40: 86 09 00 03 and %g4, %g3, %g3 40007b44: 80 a0 e0 00 cmp %g3, 0 40007b48: 12 80 00 53 bne 40007c94 <_Heap_Walk+0x518> 40007b4c: b4 10 00 03 mov %g3, %i2 if ( next_block_begin <= block_begin && is_not_last_block ) { 40007b50: 80 a7 40 1c cmp %i5, %i4 40007b54: 0a bf ff e5 bcs 40007ae8 <_Heap_Walk+0x36c> 40007b58: 80 a1 20 00 cmp %g4, 0 40007b5c: 22 bf ff e4 be,a 40007aec <_Heap_Walk+0x370> 40007b60: c6 07 20 04 ld [ %i4 + 4 ], %g3 (*printer)( 40007b64: 98 10 00 1c mov %i4, %o4 40007b68: 96 10 00 1d mov %i5, %o3 40007b6c: 15 10 00 44 sethi %hi(0x40011000), %o2 40007b70: 92 10 20 01 mov 1, %o1 40007b74: 94 12 a0 f0 or %o2, 0xf0, %o2 40007b78: 9f c4 00 00 call %l0 40007b7c: 90 10 00 19 mov %i1, %o0 40007b80: b0 0e a0 ff and %i2, 0xff, %i0 40007b84: 81 c7 e0 08 ret 40007b88: 81 e8 00 00 restore (*printer)( 40007b8c: 98 10 00 1b mov %i3, %o4 40007b90: 96 10 00 1d mov %i5, %o3 40007b94: 15 10 00 44 sethi %hi(0x40011000), %o2 40007b98: 92 10 20 00 clr %o1 40007b9c: 94 12 a1 e8 or %o2, 0x1e8, %o2 40007ba0: 9f c4 00 00 call %l0 40007ba4: 90 10 00 19 mov %i1, %o0 } while ( block != first_block ); 40007ba8: 10 bf ff de b 40007b20 <_Heap_Walk+0x3a4> 40007bac: 80 a4 80 1c cmp %l2, %i4 (*printer)( 40007bb0: da 07 60 0c ld [ %i5 + 0xc ], %o5 40007bb4: c6 06 20 08 ld [ %i0 + 8 ], %g3 return _Heap_Free_list_tail(heap)->prev; 40007bb8: de 06 20 0c ld [ %i0 + 0xc ], %o7 40007bbc: 80 a0 c0 0d cmp %g3, %o5 40007bc0: 02 80 00 05 be 40007bd4 <_Heap_Walk+0x458> 40007bc4: c8 07 bf f8 ld [ %fp + -8 ], %g4 : (block->prev == free_list_head ? " (= head)" : ""), 40007bc8: 80 a5 00 0d cmp %l4, %o5 40007bcc: 02 80 00 22 be 40007c54 <_Heap_Walk+0x4d8> 40007bd0: 88 10 00 15 mov %l5, %g4 (*printer)( 40007bd4: c6 07 60 08 ld [ %i5 + 8 ], %g3 40007bd8: 80 a3 c0 03 cmp %o7, %g3 40007bdc: 02 80 00 05 be 40007bf0 <_Heap_Walk+0x474> 40007be0: f4 07 bf fc ld [ %fp + -4 ], %i2 : (block->next == free_list_tail ? " (= tail)" : "") 40007be4: 80 a5 00 03 cmp %l4, %g3 40007be8: 02 80 00 1d be 40007c5c <_Heap_Walk+0x4e0> 40007bec: b4 10 00 15 mov %l5, %i2 (*printer)( 40007bf0: f4 23 a0 64 st %i2, [ %sp + 0x64 ] 40007bf4: 98 10 00 1b mov %i3, %o4 40007bf8: c6 23 a0 60 st %g3, [ %sp + 0x60 ] 40007bfc: 96 10 00 1d mov %i5, %o3 40007c00: c8 23 a0 5c st %g4, [ %sp + 0x5c ] 40007c04: 92 10 20 00 clr %o1 40007c08: 15 10 00 44 sethi %hi(0x40011000), %o2 40007c0c: 90 10 00 19 mov %i1, %o0 40007c10: 9f c4 00 00 call %l0 40007c14: 94 12 a1 28 or %o2, 0x128, %o2 if ( block_size != next_block->prev_size ) { 40007c18: da 07 00 00 ld [ %i4 ], %o5 40007c1c: 80 a6 c0 0d cmp %i3, %o5 40007c20: 02 80 00 11 be 40007c64 <_Heap_Walk+0x4e8> 40007c24: 98 10 00 1b mov %i3, %o4 (*printer)( 40007c28: f8 23 a0 5c st %i4, [ %sp + 0x5c ] 40007c2c: 96 10 00 1d mov %i5, %o3 40007c30: 92 10 20 01 mov 1, %o1 40007c34: 15 10 00 44 sethi %hi(0x40011000), %o2 40007c38: 90 10 00 19 mov %i1, %o0 40007c3c: 94 12 a1 60 or %o2, 0x160, %o2 40007c40: 9f c4 00 00 call %l0 40007c44: b4 10 20 00 clr %i2 40007c48: b0 0e a0 ff and %i2, 0xff, %i0 40007c4c: 81 c7 e0 08 ret 40007c50: 81 e8 00 00 restore : (block->prev == free_list_head ? " (= head)" : ""), 40007c54: 10 bf ff e0 b 40007bd4 <_Heap_Walk+0x458> 40007c58: c8 07 bf f0 ld [ %fp + -16 ], %g4 : (block->next == free_list_tail ? " (= tail)" : "") 40007c5c: 10 bf ff e5 b 40007bf0 <_Heap_Walk+0x474> 40007c60: f4 07 bf f4 ld [ %fp + -12 ], %i2 if ( !prev_used ) { 40007c64: 80 a5 e0 00 cmp %l7, 0 40007c68: 12 80 00 21 bne 40007cec <_Heap_Walk+0x570> 40007c6c: 96 10 00 1d mov %i5, %o3 (*printer)( 40007c70: 92 10 20 01 mov 1, %o1 40007c74: 15 10 00 44 sethi %hi(0x40011000), %o2 40007c78: 90 10 00 19 mov %i1, %o0 40007c7c: 94 12 a1 a0 or %o2, 0x1a0, %o2 40007c80: 9f c4 00 00 call %l0 40007c84: b4 10 20 00 clr %i2 40007c88: b0 0e a0 ff and %i2, 0xff, %i0 40007c8c: 81 c7 e0 08 ret 40007c90: 81 e8 00 00 restore (*printer)( 40007c94: 9a 10 00 13 mov %l3, %o5 40007c98: 98 10 00 1b mov %i3, %o4 40007c9c: 96 10 00 1d mov %i5, %o3 40007ca0: 92 10 20 01 mov 1, %o1 40007ca4: 15 10 00 44 sethi %hi(0x40011000), %o2 40007ca8: 90 10 00 19 mov %i1, %o0 40007cac: 94 12 a0 c0 or %o2, 0xc0, %o2 40007cb0: 9f c4 00 00 call %l0 40007cb4: b4 10 20 00 clr %i2 40007cb8: b0 0e a0 ff and %i2, 0xff, %i0 40007cbc: 81 c7 e0 08 ret 40007cc0: 81 e8 00 00 restore (*printer)( 40007cc4: 96 10 00 1d mov %i5, %o3 40007cc8: 92 10 20 01 mov 1, %o1 40007ccc: 15 10 00 44 sethi %hi(0x40011000), %o2 40007cd0: 90 10 00 19 mov %i1, %o0 40007cd4: 94 12 a0 90 or %o2, 0x90, %o2 40007cd8: 9f c4 00 00 call %l0 40007cdc: b4 10 20 00 clr %i2 40007ce0: b0 0e a0 ff and %i2, 0xff, %i0 40007ce4: 81 c7 e0 08 ret 40007ce8: 81 e8 00 00 restore return _Heap_Free_list_head(heap)->next; 40007cec: c2 06 20 08 ld [ %i0 + 8 ], %g1 while ( free_block != free_list_tail ) { 40007cf0: 80 a5 00 01 cmp %l4, %g1 40007cf4: 02 80 00 09 be 40007d18 <_Heap_Walk+0x59c> <== NEVER TAKEN 40007cf8: 80 a7 40 01 cmp %i5, %g1 if ( free_block == block ) { 40007cfc: 02 bf ff 89 be 40007b20 <_Heap_Walk+0x3a4> 40007d00: 80 a4 80 1c cmp %l2, %i4 free_block = free_block->next; 40007d04: c2 00 60 08 ld [ %g1 + 8 ], %g1 while ( free_block != free_list_tail ) { 40007d08: 80 a5 00 01 cmp %l4, %g1 40007d0c: 12 bf ff fc bne 40007cfc <_Heap_Walk+0x580> 40007d10: 80 a7 40 01 cmp %i5, %g1 (*printer)( 40007d14: 96 10 00 1d mov %i5, %o3 40007d18: 92 10 20 01 mov 1, %o1 40007d1c: 15 10 00 44 sethi %hi(0x40011000), %o2 40007d20: 90 10 00 19 mov %i1, %o0 40007d24: 94 12 a2 60 or %o2, 0x260, %o2 40007d28: 9f c4 00 00 call %l0 40007d2c: b4 10 20 00 clr %i2 40007d30: b0 0e a0 ff and %i2, 0xff, %i0 40007d34: 81 c7 e0 08 ret 40007d38: 81 e8 00 00 restore (*printer)( 40007d3c: 92 10 20 01 mov 1, %o1 40007d40: 15 10 00 44 sethi %hi(0x40011000), %o2 40007d44: 90 10 00 19 mov %i1, %o0 40007d48: 94 12 a0 58 or %o2, 0x58, %o2 40007d4c: 9f c4 00 00 call %l0 40007d50: b4 10 20 00 clr %i2 40007d54: b0 0e a0 ff and %i2, 0xff, %i0 40007d58: 81 c7 e0 08 ret 40007d5c: 81 e8 00 00 restore (*printer)( 40007d60: 90 10 00 19 mov %i1, %o0 40007d64: 94 12 a0 38 or %o2, 0x38, %o2 40007d68: 9f c4 00 00 call %l0 40007d6c: b4 10 20 00 clr %i2 40007d70: b0 0e a0 ff and %i2, 0xff, %i0 40007d74: 81 c7 e0 08 ret 40007d78: 81 e8 00 00 restore (*printer)( 40007d7c: 90 10 00 19 mov %i1, %o0 40007d80: 94 12 a0 08 or %o2, 8, %o2 40007d84: 9f c4 00 00 call %l0 40007d88: b4 10 20 00 clr %i2 40007d8c: b0 0e a0 ff and %i2, 0xff, %i0 40007d90: 81 c7 e0 08 ret 40007d94: 81 e8 00 00 restore (*printer)( 40007d98: 92 10 20 01 mov 1, %o1 40007d9c: 15 10 00 44 sethi %hi(0x40011000), %o2 40007da0: 90 10 00 19 mov %i1, %o0 40007da4: 94 12 a2 10 or %o2, 0x210, %o2 40007da8: 9f c4 00 00 call %l0 40007dac: b4 10 20 00 clr %i2 40007db0: b0 0e a0 ff and %i2, 0xff, %i0 40007db4: 81 c7 e0 08 ret 40007db8: 81 e8 00 00 restore =============================================================================== 4000710c <_IO_Printf>: #endif #include int _IO_Printf( IO_Put_char put_char, void *arg, char const *fmt, ... ) { 4000710c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED va_list ap; int len; va_start( ap, fmt ); 40007110: 82 07 a0 50 add %fp, 0x50, %g1 <== NOT EXECUTED 40007114: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED len = _IO_Vprintf( put_char, arg, fmt, ap ); 40007118: 96 10 00 01 mov %g1, %o3 <== NOT EXECUTED va_start( ap, fmt ); 4000711c: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED len = _IO_Vprintf( put_char, arg, fmt, ap ); 40007120: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED va_start( ap, fmt ); 40007124: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED len = _IO_Vprintf( put_char, arg, fmt, ap ); 40007128: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED va_start( ap, fmt ); 4000712c: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED len = _IO_Vprintf( put_char, arg, fmt, ap ); 40007130: 40 00 00 5c call 400072a0 <_IO_Vprintf> <== NOT EXECUTED 40007134: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED va_end( ap ); return len; } 40007138: 81 c7 e0 08 ret 4000713c: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 40007a18 <_IO_Vprintf>: return (p); } int _IO_Vprintf(IO_Put_char put_char, void *arg, char const *fmt, va_list ap) { 40007a18: 9d e3 bf 50 save %sp, -176, %sp char padc; int stop = 0, retval = 0; num = 0; if (fmt == NULL) 40007a1c: 80 a6 a0 00 cmp %i2, 0 40007a20: 02 80 00 3e be 40007b18 <_IO_Vprintf+0x100> <== NEVER TAKEN 40007a24: b8 10 00 18 mov %i0, %i4 } percent = fmt - 1; lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; sign = 0; dot = 0; dwidth = 0; upper = 0; cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0; reswitch: switch (ch = (u_char)*fmt++) { 40007a28: 31 10 00 1e sethi %hi(0x40007800), %i0 40007a2c: 03 10 00 66 sethi %hi(0x40019800), %g1 40007a30: a8 10 20 00 clr %l4 40007a34: a4 10 20 00 clr %l2 40007a38: b0 16 20 b8 or %i0, 0xb8, %i0 40007a3c: ae 10 60 f7 or %g1, 0xf7, %l7 while ((ch = (u_char)*fmt++) != '%' || stop) { 40007a40: c2 0e 80 00 ldub [ %i2 ], %g1 40007a44: a4 0c a0 01 and %l2, 1, %l2 40007a48: ba 06 a0 01 add %i2, 1, %i5 40007a4c: 90 10 00 01 mov %g1, %o0 40007a50: 80 a0 60 25 cmp %g1, 0x25 40007a54: 12 80 00 05 bne 40007a68 <_IO_Vprintf+0x50> 40007a58: a0 10 00 12 mov %l2, %l0 40007a5c: 80 a4 a0 00 cmp %l2, 0 40007a60: 22 80 00 16 be,a 40007ab8 <_IO_Vprintf+0xa0> <== ALWAYS TAKEN 40007a64: 82 10 00 1d mov %i5, %g1 if (ch == '\0') 40007a68: 80 a0 60 00 cmp %g1, 0 40007a6c: 02 80 00 32 be 40007b34 <_IO_Vprintf+0x11c> 40007a70: b4 25 00 1a sub %l4, %i2, %i2 while ((ch = (u_char)*fmt++) != '%' || stop) { 40007a74: a0 0c 20 ff and %l0, 0xff, %l0 PCHAR(ch); 40007a78: 9f c7 00 00 call %i4 40007a7c: 92 10 00 19 mov %i1, %o1 while ((ch = (u_char)*fmt++) != '%' || stop) { 40007a80: 82 07 60 01 add %i5, 1, %g1 40007a84: d0 08 7f ff ldub [ %g1 + -1 ], %o0 40007a88: 80 a2 20 25 cmp %o0, 0x25 40007a8c: 12 80 00 05 bne 40007aa0 <_IO_Vprintf+0x88> 40007a90: aa 07 40 1a add %i5, %i2, %l5 40007a94: 80 a4 20 00 cmp %l0, 0 40007a98: 02 80 00 0b be 40007ac4 <_IO_Vprintf+0xac> <== ALWAYS TAKEN 40007a9c: 84 10 20 20 mov 0x20, %g2 if (ch == '\0') 40007aa0: 80 a2 20 00 cmp %o0, 0 40007aa4: 12 bf ff f5 bne 40007a78 <_IO_Vprintf+0x60> 40007aa8: ba 10 00 01 mov %g1, %i5 40007aac: ac 10 00 15 mov %l5, %l6 stop = 1; break; } } #undef PCHAR } 40007ab0: 81 c7 e0 08 ret 40007ab4: 91 e8 00 16 restore %g0, %l6, %o0 while ((ch = (u_char)*fmt++) != '%' || stop) { 40007ab8: aa 10 00 14 mov %l4, %l5 40007abc: ba 10 00 1a mov %i2, %i5 padc = ' '; 40007ac0: 84 10 20 20 mov 0x20, %g2 sign = 0; dot = 0; dwidth = 0; upper = 0; 40007ac4: c0 27 bf d0 clr [ %fp + -48 ] cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0; 40007ac8: a8 10 20 00 clr %l4 padc = ' '; 40007acc: c4 2f bf c3 stb %g2, [ %fp + -61 ] cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0; 40007ad0: 9e 10 20 00 clr %o7 lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 40007ad4: c0 27 bf c4 clr [ %fp + -60 ] cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0; 40007ad8: 9a 10 20 00 clr %o5 width = 0; 40007adc: c0 27 bf d4 clr [ %fp + -44 ] sign = 0; dot = 0; dwidth = 0; upper = 0; 40007ae0: 96 10 20 00 clr %o3 40007ae4: d8 08 40 00 ldub [ %g1 ], %o4 lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 40007ae8: a4 10 20 00 clr %l2 cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0; 40007aec: 88 10 20 00 clr %g4 reswitch: switch (ch = (u_char)*fmt++) { 40007af0: 84 03 3f dd add %o4, -35, %g2 40007af4: b4 00 60 01 add %g1, 1, %i2 40007af8: 84 08 a0 ff and %g2, 0xff, %g2 40007afc: 80 a0 a0 57 cmp %g2, 0x57 40007b00: 18 80 01 d9 bgu 40008264 <_IO_Vprintf+0x84c> <== NEVER TAKEN 40007b04: 90 0b 20 ff and %o4, 0xff, %o0 40007b08: 85 28 a0 02 sll %g2, 2, %g2 40007b0c: c4 06 00 02 ld [ %i0 + %g2 ], %g2 40007b10: 81 c0 80 00 jmp %g2 40007b14: 01 00 00 00 nop fmt = "(fmt null)\n"; 40007b18: 35 10 00 66 sethi %hi(0x40019800), %i2 <== NOT EXECUTED 40007b1c: 10 bf ff c3 b 40007a28 <_IO_Vprintf+0x10> <== NOT EXECUTED 40007b20: b4 16 a0 e0 or %i2, 0xe0, %i2 ! 400198e0 <_Objects_Information_table+0x20> <== NOT EXECUTED 40007b24: d8 08 60 01 ldub [ %g1 + 1 ], %o4 zflag = 1; 40007b28: 88 10 20 01 mov 1, %g4 goto reswitch; 40007b2c: 10 bf ff f1 b 40007af0 <_IO_Vprintf+0xd8> 40007b30: 82 10 00 1a mov %i2, %g1 return (retval); 40007b34: 10 bf ff df b 40007ab0 <_IO_Vprintf+0x98> 40007b38: ac 10 00 14 mov %l4, %l6 if (!dot) { 40007b3c: 80 a2 e0 00 cmp %o3, 0 40007b40: 32 80 02 5b bne,a 400084ac <_IO_Vprintf+0xa94> <== NEVER TAKEN 40007b44: c6 48 60 01 ldsb [ %g1 + 1 ], %g3 <== NOT EXECUTED padc = '0'; 40007b48: d8 2f bf c3 stb %o4, [ %fp + -61 ] if (!dot) { 40007b4c: d8 08 60 01 ldub [ %g1 + 1 ], %o4 reswitch: switch (ch = (u_char)*fmt++) { 40007b50: 10 bf ff e8 b 40007af0 <_IO_Vprintf+0xd8> 40007b54: 82 10 00 1a mov %i2, %g1 40007b58: 84 10 20 00 clr %g2 40007b5c: 86 10 20 10 mov 0x10, %g3 base = 16; 40007b60: 82 10 20 10 mov 0x10, %g1 reswitch: switch (ch = (u_char)*fmt++) { 40007b64: c4 3f bf b0 std %g2, [ %fp + -80 ] sign = 0; dot = 0; dwidth = 0; upper = 0; 40007b68: ba 10 20 00 clr %i5 base = 16; 40007b6c: c2 27 bf bc st %g1, [ %fp + -68 ] if (jflag) 40007b70: 80 a5 20 00 cmp %l4, 0 40007b74: 02 80 01 dc be 400082e4 <_IO_Vprintf+0x8cc> 40007b78: 80 a1 20 00 cmp %g4, 0 num = va_arg(ap, uintmax_t); 40007b7c: 92 10 00 1b mov %i3, %o1 40007b80: 94 10 20 08 mov 8, %o2 40007b84: 40 00 1d 63 call 4000f110 40007b88: 90 07 bf d8 add %fp, -40, %o0 40007b8c: c4 1f bf d8 ldd [ %fp + -40 ], %g2 40007b90: c4 3f bf c8 std %g2, [ %fp + -56 ] 40007b94: b6 06 e0 08 add %i3, 8, %i3 lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 40007b98: a8 10 20 00 clr %l4 40007b9c: bb 2f 60 04 sll %i5, 4, %i5 *p = '\0'; 40007ba0: c0 2f bf e8 clrb [ %fp + -24 ] *++p = hex2ascii_data[upper][num % base]; 40007ba4: a2 05 c0 1d add %l7, %i5, %l1 40007ba8: f4 27 a0 4c st %i2, [ %fp + 0x4c ] 40007bac: ac 10 00 1c mov %i4, %l6 *p = '\0'; 40007bb0: c4 1f bf c8 ldd [ %fp + -56 ], %g2 *++p = hex2ascii_data[upper][num % base]; 40007bb4: f8 1f bf b0 ldd [ %fp + -80 ], %i4 40007bb8: f6 27 a0 50 st %i3, [ %fp + 0x50 ] *p = '\0'; 40007bbc: a6 10 00 02 mov %g2, %l3 p = nbuf; 40007bc0: a0 07 bf e8 add %fp, -24, %l0 *++p = hex2ascii_data[upper][num % base]; 40007bc4: b6 10 00 03 mov %g3, %i3 40007bc8: 94 10 00 1c mov %i4, %o2 40007bcc: 96 10 00 1d mov %i5, %o3 40007bd0: 90 10 00 13 mov %l3, %o0 40007bd4: 40 00 41 48 call 400180f4 <__umoddi3> 40007bd8: 92 10 00 1b mov %i3, %o1 40007bdc: f4 0c 40 09 ldub [ %l1 + %o1 ], %i2 40007be0: a0 04 20 01 inc %l0 40007be4: f4 2c 00 00 stb %i2, [ %l0 ] } while (num /= base); 40007be8: 90 10 00 13 mov %l3, %o0 40007bec: 92 10 00 1b mov %i3, %o1 40007bf0: 94 10 00 1c mov %i4, %o2 40007bf4: 40 00 40 c7 call 40017f10 <__udivdi3> 40007bf8: 96 10 00 1d mov %i5, %o3 40007bfc: a6 10 00 08 mov %o0, %l3 40007c00: 80 92 40 13 orcc %o1, %l3, %g0 40007c04: 12 bf ff f1 bne 40007bc8 <_IO_Vprintf+0x1b0> 40007c08: b6 10 00 09 mov %o1, %i3 if (sharpflag && num != 0) { 40007c0c: c4 1f bf c8 ldd [ %fp + -56 ], %g2 40007c10: 82 10 00 02 mov %g2, %g1 40007c14: c4 07 bf c4 ld [ %fp + -60 ], %g2 40007c18: 82 10 40 03 or %g1, %g3, %g1 40007c1c: 80 a0 00 01 cmp %g0, %g1 40007c20: 86 40 20 00 addx %g0, 0, %g3 40007c24: 84 88 c0 02 andcc %g3, %g2, %g2 40007c28: c4 27 bf c4 st %g2, [ %fp + -60 ] *lenp = p - nbuf; 40007c2c: 82 07 bf e8 add %fp, -24, %g1 40007c30: ba 10 00 1a mov %i2, %i5 40007c34: a2 24 00 01 sub %l0, %g1, %l1 40007c38: b8 10 00 16 mov %l6, %i4 40007c3c: f4 07 a0 4c ld [ %fp + 0x4c ], %i2 40007c40: f6 07 a0 50 ld [ %fp + 0x50 ], %i3 if (sharpflag && num != 0) { 40007c44: 02 80 00 0a be 40007c6c <_IO_Vprintf+0x254> 40007c48: 82 10 20 00 clr %g1 if (base == 8) 40007c4c: c4 07 bf bc ld [ %fp + -68 ], %g2 40007c50: 80 a0 a0 08 cmp %g2, 8 40007c54: 02 80 00 06 be 40007c6c <_IO_Vprintf+0x254> <== NEVER TAKEN 40007c58: 82 10 20 01 mov 1, %g1 tmp = 0; 40007c5c: 82 18 a0 10 xor %g2, 0x10, %g1 40007c60: 80 a0 00 01 cmp %g0, %g1 40007c64: 82 60 3f ff subx %g0, -1, %g1 40007c68: 83 28 60 01 sll %g1, 1, %g1 tmp++; 40007c6c: 80 a0 00 14 cmp %g0, %l4 40007c70: 82 40 00 01 addx %g0, %g1, %g1 if (!ladjust && padc == '0') 40007c74: 80 8c a0 01 btst 1, %l2 40007c78: 12 80 01 8d bne 400082ac <_IO_Vprintf+0x894> 40007c7c: c4 0f bf c3 ldub [ %fp + -61 ], %g2 40007c80: 87 28 a0 18 sll %g2, 0x18, %g3 40007c84: 87 38 e0 18 sra %g3, 0x18, %g3 40007c88: 80 a0 e0 30 cmp %g3, 0x30 40007c8c: 12 80 01 88 bne 400082ac <_IO_Vprintf+0x894> 40007c90: c4 07 bf d4 ld [ %fp + -44 ], %g2 dwidth = width - tmp; 40007c94: ac 20 80 01 sub %g2, %g1, %l6 static inline int imax(int a, int b) { return (a > b ? a : b); } 40007c98: 80 a5 80 11 cmp %l6, %l1 40007c9c: 16 80 00 04 bge 40007cac <_IO_Vprintf+0x294> 40007ca0: 86 10 00 16 mov %l6, %g3 40007ca4: 86 10 00 11 mov %l1, %g3 width -= tmp + imax(dwidth, n); 40007ca8: c4 07 bf d4 ld [ %fp + -44 ], %g2 40007cac: 82 00 c0 01 add %g3, %g1, %g1 dwidth -= n; 40007cb0: a2 25 80 11 sub %l6, %l1, %l1 width -= tmp + imax(dwidth, n); 40007cb4: a6 20 80 01 sub %g2, %g1, %l3 while (width-- > 0) 40007cb8: ac 04 ff ff add %l3, -1, %l6 40007cbc: 80 a4 e0 00 cmp %l3, 0 40007cc0: 04 80 00 0b ble 40007cec <_IO_Vprintf+0x2d4> 40007cc4: a6 10 00 16 mov %l6, %l3 PCHAR(' '); 40007cc8: 92 10 00 19 mov %i1, %o1 40007ccc: 9f c7 00 00 call %i4 40007cd0: 90 10 20 20 mov 0x20, %o0 while (width-- > 0) 40007cd4: a6 04 ff ff add %l3, -1, %l3 40007cd8: 80 a4 ff ff cmp %l3, -1 40007cdc: 12 bf ff fc bne 40007ccc <_IO_Vprintf+0x2b4> 40007ce0: 92 10 00 19 mov %i1, %o1 40007ce4: 84 05 60 01 add %l5, 1, %g2 40007ce8: aa 05 80 02 add %l6, %g2, %l5 if (neg) 40007cec: 80 a5 20 00 cmp %l4, 0 40007cf0: 02 80 01 8e be 40008328 <_IO_Vprintf+0x910> 40007cf4: 92 10 00 19 mov %i1, %o1 PCHAR('-'); 40007cf8: 90 10 20 2d mov 0x2d, %o0 40007cfc: 9f c7 00 00 call %i4 40007d00: a8 05 60 01 add %l5, 1, %l4 if (sharpflag && num != 0) { 40007d04: c2 07 bf c4 ld [ %fp + -60 ], %g1 40007d08: 80 a0 60 00 cmp %g1, 0 40007d0c: 02 80 00 0a be 40007d34 <_IO_Vprintf+0x31c> 40007d10: 80 a4 60 00 cmp %l1, 0 if (base == 8) { 40007d14: c2 07 bf bc ld [ %fp + -68 ], %g1 40007d18: 80 a0 60 08 cmp %g1, 8 40007d1c: 12 80 01 92 bne 40008364 <_IO_Vprintf+0x94c> <== ALWAYS TAKEN 40007d20: 92 10 00 19 mov %i1, %o1 PCHAR('0'); 40007d24: 90 10 20 30 mov 0x30, %o0 <== NOT EXECUTED 40007d28: 9f c7 00 00 call %i4 <== NOT EXECUTED 40007d2c: a8 05 20 01 inc %l4 <== NOT EXECUTED while (dwidth-- > 0) 40007d30: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED 40007d34: 04 80 00 0c ble 40007d64 <_IO_Vprintf+0x34c> 40007d38: aa 04 7f ff add %l1, -1, %l5 40007d3c: a2 10 00 15 mov %l5, %l1 PCHAR('0'); 40007d40: 92 10 00 19 mov %i1, %o1 40007d44: 9f c7 00 00 call %i4 40007d48: 90 10 20 30 mov 0x30, %o0 while (dwidth-- > 0) 40007d4c: a2 04 7f ff add %l1, -1, %l1 40007d50: 80 a4 7f ff cmp %l1, -1 40007d54: 12 bf ff fc bne 40007d44 <_IO_Vprintf+0x32c> 40007d58: 92 10 00 19 mov %i1, %o1 40007d5c: a8 05 20 01 inc %l4 40007d60: a8 05 00 15 add %l4, %l5, %l4 while (*p) 40007d64: bb 2f 60 18 sll %i5, 0x18, %i5 40007d68: 80 a7 60 00 cmp %i5, 0 40007d6c: 02 80 00 0c be 40007d9c <_IO_Vprintf+0x384> <== NEVER TAKEN 40007d70: 80 a4 a0 00 cmp %l2, 0 PCHAR(*p--); 40007d74: 91 3f 60 18 sra %i5, 0x18, %o0 40007d78: a0 04 3f ff add %l0, -1, %l0 40007d7c: 9f c7 00 00 call %i4 40007d80: 92 10 00 19 mov %i1, %o1 while (*p) 40007d84: fa 0c 00 00 ldub [ %l0 ], %i5 40007d88: bb 2f 60 18 sll %i5, 0x18, %i5 40007d8c: 80 a7 60 00 cmp %i5, 0 40007d90: 12 bf ff f9 bne 40007d74 <_IO_Vprintf+0x35c> 40007d94: a8 05 20 01 inc %l4 if (ladjust) 40007d98: 80 a4 a0 00 cmp %l2, 0 40007d9c: 22 bf ff 2a be,a 40007a44 <_IO_Vprintf+0x2c> 40007da0: c2 0e 80 00 ldub [ %i2 ], %g1 while (width-- > 0) 40007da4: 80 a4 e0 00 cmp %l3, 0 40007da8: 04 80 01 59 ble 4000830c <_IO_Vprintf+0x8f4> 40007dac: a0 04 ff ff add %l3, -1, %l0 40007db0: ba 10 00 10 mov %l0, %i5 PCHAR(' '); 40007db4: 92 10 00 19 mov %i1, %o1 40007db8: 9f c7 00 00 call %i4 40007dbc: 90 10 20 20 mov 0x20, %o0 while (width-- > 0) 40007dc0: ba 07 7f ff add %i5, -1, %i5 40007dc4: 80 a7 7f ff cmp %i5, -1 40007dc8: 12 bf ff fc bne 40007db8 <_IO_Vprintf+0x3a0> <== NEVER TAKEN 40007dcc: 92 10 00 19 mov %i1, %o1 40007dd0: a8 05 20 01 inc %l4 40007dd4: a4 10 20 00 clr %l2 40007dd8: 10 bf ff 1a b 40007a40 <_IO_Vprintf+0x28> 40007ddc: a8 04 00 14 add %l0, %l4, %l4 reswitch: switch (ch = (u_char)*fmt++) { 40007de0: 84 10 20 00 clr %g2 <== NOT EXECUTED 40007de4: 86 10 20 10 mov 0x10, %g3 <== NOT EXECUTED base = 16; 40007de8: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 40007dec: c4 3f bf b0 std %g2, [ %fp + -80 ] <== NOT EXECUTED base = 16; 40007df0: c2 27 bf bc st %g1, [ %fp + -68 ] <== NOT EXECUTED if (jflag) 40007df4: 80 a5 20 00 cmp %l4, 0 40007df8: 02 80 01 4e be 40008330 <_IO_Vprintf+0x918> 40007dfc: 82 06 e0 04 add %i3, 4, %g1 num = va_arg(ap, intmax_t); 40007e00: 92 10 00 1b mov %i3, %o1 40007e04: 94 10 20 08 mov 8, %o2 40007e08: 40 00 1c c2 call 4000f110 40007e0c: 90 07 bf e0 add %fp, -32, %o0 40007e10: c4 1f bf e0 ldd [ %fp + -32 ], %g2 40007e14: c4 3f bf c8 std %g2, [ %fp + -56 ] 40007e18: b6 06 e0 08 add %i3, 8, %i3 if (sign && (intmax_t)num < 0) { 40007e1c: c4 1f bf c8 ldd [ %fp + -56 ], %g2 40007e20: 82 90 a0 00 orcc %g2, 0, %g1 40007e24: 16 80 01 c8 bge 40008544 <_IO_Vprintf+0xb2c> 40007e28: 9a a0 00 03 subcc %g0, %g3, %o5 num = -(intmax_t)num; 40007e2c: ba 10 20 00 clr %i5 40007e30: 98 60 00 02 subx %g0, %g2, %o4 neg = 1; 40007e34: a8 10 20 01 mov 1, %l4 num = -(intmax_t)num; 40007e38: 10 bf ff 59 b 40007b9c <_IO_Vprintf+0x184> 40007e3c: d8 3f bf c8 std %o4, [ %fp + -56 ] if (!ladjust && width > 0) 40007e40: c2 07 bf d4 ld [ %fp + -44 ], %g1 40007e44: 80 a0 60 01 cmp %g1, 1 40007e48: 14 80 00 03 bg 40007e54 <_IO_Vprintf+0x43c> <== NEVER TAKEN 40007e4c: ba 10 20 01 mov 1, %i5 40007e50: ba 10 20 00 clr %i5 40007e54: a8 05 60 01 add %l5, 1, %l4 40007e58: 80 8c a0 01 btst 1, %l2 40007e5c: 12 80 01 52 bne 400083a4 <_IO_Vprintf+0x98c> <== NEVER TAKEN 40007e60: a0 06 e0 04 add %i3, 4, %l0 40007e64: 80 8f 60 ff btst 0xff, %i5 40007e68: 02 80 01 4f be 400083a4 <_IO_Vprintf+0x98c> <== ALWAYS TAKEN 40007e6c: c2 07 bf d4 ld [ %fp + -44 ], %g1 while (width--) 40007e70: a6 00 7f fe add %g1, -2, %l3 <== NOT EXECUTED 40007e74: c2 0f bf c3 ldub [ %fp + -61 ], %g1 <== NOT EXECUTED 40007e78: a3 28 60 18 sll %g1, 0x18, %l1 <== NOT EXECUTED 40007e7c: ba 10 00 13 mov %l3, %i5 <== NOT EXECUTED 40007e80: a3 3c 60 18 sra %l1, 0x18, %l1 <== NOT EXECUTED PCHAR(padc); 40007e84: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40007e88: 9f c7 00 00 call %i4 <== NOT EXECUTED 40007e8c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED while (width--) 40007e90: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED 40007e94: 80 a7 7f ff cmp %i5, -1 <== NOT EXECUTED 40007e98: 12 bf ff fc bne 40007e88 <_IO_Vprintf+0x470> <== NOT EXECUTED 40007e9c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED PCHAR(va_arg(ap, int)); 40007ea0: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED 40007ea4: a6 05 00 13 add %l4, %l3, %l3 <== NOT EXECUTED 40007ea8: a8 04 e0 01 add %l3, 1, %l4 <== NOT EXECUTED 40007eac: 9f c7 00 00 call %i4 <== NOT EXECUTED 40007eb0: b6 10 00 10 mov %l0, %i3 <== NOT EXECUTED 40007eb4: 10 bf fe e3 b 40007a40 <_IO_Vprintf+0x28> <== NOT EXECUTED 40007eb8: a4 10 20 00 clr %l2 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 40007ebc: 84 10 20 00 clr %g2 40007ec0: 86 10 20 0a mov 0xa, %g3 base = 10; 40007ec4: 82 10 20 0a mov 0xa, %g1 reswitch: switch (ch = (u_char)*fmt++) { 40007ec8: c4 3f bf b0 std %g2, [ %fp + -80 ] base = 10; 40007ecc: 10 bf ff ca b 40007df4 <_IO_Vprintf+0x3dc> 40007ed0: c2 27 bf bc st %g1, [ %fp + -68 ] if (hflag) { 40007ed4: 80 a3 e0 00 cmp %o7, 0 40007ed8: 12 80 01 55 bne 4000842c <_IO_Vprintf+0xa14> 40007edc: d8 08 60 01 ldub [ %g1 + 1 ], %o4 hflag = 1; 40007ee0: 9e 10 20 01 mov 1, %o7 reswitch: switch (ch = (u_char)*fmt++) { 40007ee4: 10 bf ff 03 b 40007af0 <_IO_Vprintf+0xd8> 40007ee8: 82 10 00 1a mov %i2, %g1 40007eec: d8 08 60 01 ldub [ %g1 + 1 ], %o4 jflag = 1; 40007ef0: a8 10 20 01 mov 1, %l4 goto reswitch; 40007ef4: 10 bf fe ff b 40007af0 <_IO_Vprintf+0xd8> 40007ef8: 82 10 00 1a mov %i2, %g1 reswitch: switch (ch = (u_char)*fmt++) { 40007efc: 84 10 20 00 clr %g2 40007f00: 86 10 20 10 mov 0x10, %g3 base = 16; 40007f04: 82 10 20 10 mov 0x10, %g1 reswitch: switch (ch = (u_char)*fmt++) { 40007f08: c4 3f bf b0 std %g2, [ %fp + -80 ] upper = 1; 40007f0c: ba 10 20 01 mov 1, %i5 base = 16; 40007f10: 10 bf ff 18 b 40007b70 <_IO_Vprintf+0x158> 40007f14: c2 27 bf bc st %g1, [ %fp + -68 ] reswitch: switch (ch = (u_char)*fmt++) { 40007f18: 84 10 20 00 clr %g2 40007f1c: 86 10 20 0a mov 0xa, %g3 base = 10; 40007f20: 82 10 20 0a mov 0xa, %g1 reswitch: switch (ch = (u_char)*fmt++) { 40007f24: c4 3f bf b0 std %g2, [ %fp + -80 ] sign = 0; dot = 0; dwidth = 0; upper = 0; 40007f28: ba 10 20 00 clr %i5 base = 10; 40007f2c: 10 bf ff 11 b 40007b70 <_IO_Vprintf+0x158> 40007f30: c2 27 bf bc st %g1, [ %fp + -68 ] 40007f34: d8 08 60 01 ldub [ %g1 + 1 ], %o4 dot = 1; 40007f38: 96 10 20 01 mov 1, %o3 reswitch: switch (ch = (u_char)*fmt++) { 40007f3c: 10 bf fe ed b 40007af0 <_IO_Vprintf+0xd8> 40007f40: 82 10 00 1a mov %i2, %g1 ch = *fmt; 40007f44: c6 48 60 01 ldsb [ %g1 + 1 ], %g3 if (ch < '0' || ch > '9') 40007f48: 84 00 ff d0 add %g3, -48, %g2 n = n * 10 + ch - '0'; 40007f4c: 90 02 3f d0 add %o0, -48, %o0 if (ch < '0' || ch > '9') 40007f50: 80 a0 a0 09 cmp %g2, 9 40007f54: 18 80 00 d4 bgu 400082a4 <_IO_Vprintf+0x88c> 40007f58: d8 08 60 01 ldub [ %g1 + 1 ], %o4 reswitch: switch (ch = (u_char)*fmt++) { 40007f5c: 82 10 00 1a mov %i2, %g1 for (n = 0;; ++fmt) { 40007f60: 82 00 60 01 inc %g1 n = n * 10 + ch - '0'; 40007f64: 85 2a 20 02 sll %o0, 2, %g2 40007f68: 84 00 80 08 add %g2, %o0, %g2 40007f6c: 85 28 a0 01 sll %g2, 1, %g2 40007f70: 84 00 80 03 add %g2, %g3, %g2 ch = *fmt; 40007f74: c6 48 40 00 ldsb [ %g1 ], %g3 if (ch < '0' || ch > '9') 40007f78: b4 00 ff d0 add %g3, -48, %i2 n = n * 10 + ch - '0'; 40007f7c: 90 00 bf d0 add %g2, -48, %o0 if (ch < '0' || ch > '9') 40007f80: 80 a6 a0 09 cmp %i2, 9 40007f84: 08 bf ff f7 bleu 40007f60 <_IO_Vprintf+0x548> <== NEVER TAKEN 40007f88: d8 08 40 00 ldub [ %g1 ], %o4 if (dot) 40007f8c: 80 a2 e0 00 cmp %o3, 0 40007f90: 22 bf fe d8 be,a 40007af0 <_IO_Vprintf+0xd8> 40007f94: d0 27 bf d4 st %o0, [ %fp + -44 ] 40007f98: 10 bf fe d6 b 40007af0 <_IO_Vprintf+0xd8> 40007f9c: d0 27 bf d0 st %o0, [ %fp + -48 ] if (!width) 40007fa0: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED up = va_arg(ap, u_char *); 40007fa4: e0 06 c0 00 ld [ %i3 ], %l0 <== NOT EXECUTED p = va_arg(ap, char *); 40007fa8: e2 06 e0 04 ld [ %i3 + 4 ], %l1 <== NOT EXECUTED if (!width) 40007fac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40007fb0: 12 80 00 04 bne 40007fc0 <_IO_Vprintf+0x5a8> <== NOT EXECUTED 40007fb4: b6 06 e0 08 add %i3, 8, %i3 <== NOT EXECUTED width = 16; 40007fb8: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED 40007fbc: c2 27 bf d4 st %g1, [ %fp + -44 ] <== NOT EXECUTED 40007fc0: 82 04 3f ff add %l0, -1, %g1 <== NOT EXECUTED 40007fc4: c4 07 bf d4 ld [ %fp + -44 ], %g2 <== NOT EXECUTED for (q=p;*q;q++) 40007fc8: a8 10 00 15 mov %l5, %l4 <== NOT EXECUTED 40007fcc: a4 04 00 02 add %l0, %g2, %l2 <== NOT EXECUTED 40007fd0: a6 00 40 02 add %g1, %g2, %l3 <== NOT EXECUTED while(width--) { 40007fd4: 80 a4 80 10 cmp %l2, %l0 <== NOT EXECUTED 40007fd8: 22 bf fe 9a be,a 40007a40 <_IO_Vprintf+0x28> <== NOT EXECUTED 40007fdc: a4 10 20 00 clr %l2 <== NOT EXECUTED PCHAR(hex2ascii(*up >> 4)); 40007fe0: c2 0c 00 00 ldub [ %l0 ], %g1 <== NOT EXECUTED 40007fe4: 83 30 60 04 srl %g1, 4, %g1 <== NOT EXECUTED 40007fe8: d0 4d c0 01 ldsb [ %l7 + %g1 ], %o0 <== NOT EXECUTED 40007fec: 9f c7 00 00 call %i4 <== NOT EXECUTED 40007ff0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED PCHAR(hex2ascii(*up & 0x0f)); 40007ff4: c2 0c 00 00 ldub [ %l0 ], %g1 <== NOT EXECUTED 40007ff8: 82 08 60 0f and %g1, 0xf, %g1 <== NOT EXECUTED 40007ffc: d0 4d c0 01 ldsb [ %l7 + %g1 ], %o0 <== NOT EXECUTED 40008000: 9f c7 00 00 call %i4 <== NOT EXECUTED 40008004: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED if (width) 40008008: 80 a4 c0 10 cmp %l3, %l0 <== NOT EXECUTED 4000800c: 02 80 00 c0 be 4000830c <_IO_Vprintf+0x8f4> <== NOT EXECUTED 40008010: a8 05 20 02 add %l4, 2, %l4 <== NOT EXECUTED for (q=p;*q;q++) 40008014: d0 0c 40 00 ldub [ %l1 ], %o0 <== NOT EXECUTED 40008018: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED 4000801c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40008020: 22 bf ff ed be,a 40007fd4 <_IO_Vprintf+0x5bc> <== NOT EXECUTED 40008024: a0 04 20 01 inc %l0 <== NOT EXECUTED 40008028: ba 10 00 11 mov %l1, %i5 <== NOT EXECUTED PCHAR(*q); 4000802c: 91 3a 20 18 sra %o0, 0x18, %o0 <== NOT EXECUTED 40008030: 9f c7 00 00 call %i4 <== NOT EXECUTED 40008034: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED for (q=p;*q;q++) 40008038: ba 07 60 01 inc %i5 <== NOT EXECUTED 4000803c: d0 0f 40 00 ldub [ %i5 ], %o0 <== NOT EXECUTED 40008040: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED 40008044: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40008048: 12 bf ff f9 bne 4000802c <_IO_Vprintf+0x614> <== NOT EXECUTED 4000804c: a8 05 20 01 inc %l4 <== NOT EXECUTED 40008050: 10 bf ff e1 b 40007fd4 <_IO_Vprintf+0x5bc> <== NOT EXECUTED 40008054: a0 04 20 01 inc %l0 <== NOT EXECUTED if (lflag) { 40008058: 80 a1 20 00 cmp %g4, 0 4000805c: 02 bf fe b3 be 40007b28 <_IO_Vprintf+0x110> 40008060: d8 08 60 01 ldub [ %g1 + 1 ], %o4 jflag = 1; 40008064: a8 10 00 04 mov %g4, %l4 reswitch: switch (ch = (u_char)*fmt++) { 40008068: 10 bf fe a2 b 40007af0 <_IO_Vprintf+0xd8> 4000806c: 82 10 00 1a mov %i2, %g1 40008070: 84 10 20 00 clr %g2 40008074: 86 10 20 08 mov 8, %g3 base = 8; 40008078: 82 10 20 08 mov 8, %g1 reswitch: switch (ch = (u_char)*fmt++) { 4000807c: c4 3f bf b0 std %g2, [ %fp + -80 ] sign = 0; dot = 0; dwidth = 0; upper = 0; 40008080: ba 10 20 00 clr %i5 base = 8; 40008084: 10 bf fe bb b 40007b70 <_IO_Vprintf+0x158> 40008088: c2 27 bf bc st %g1, [ %fp + -68 ] sharpflag = (width == 0); 4000808c: c4 07 bf d4 ld [ %fp + -44 ], %g2 num = (uintptr_t)va_arg(ap, void *); 40008090: c2 06 c0 00 ld [ %i3 ], %g1 sharpflag = (width == 0); 40008094: 80 a0 00 02 cmp %g0, %g2 40008098: 84 60 3f ff subx %g0, -1, %g2 num = (uintptr_t)va_arg(ap, void *); 4000809c: 86 10 00 01 mov %g1, %g3 sharpflag = (width == 0); 400080a0: c4 27 bf c4 st %g2, [ %fp + -60 ] num = (uintptr_t)va_arg(ap, void *); 400080a4: 84 10 20 00 clr %g2 base = 16; 400080a8: 82 10 20 10 mov 0x10, %g1 num = (uintptr_t)va_arg(ap, void *); 400080ac: c4 3f bf c8 std %g2, [ %fp + -56 ] 400080b0: b6 06 e0 04 add %i3, 4, %i3 goto number; 400080b4: 84 10 20 00 clr %g2 400080b8: 86 10 20 10 mov 0x10, %g3 sign = 0; dot = 0; dwidth = 0; upper = 0; 400080bc: ba 10 20 00 clr %i5 goto number; 400080c0: c4 3f bf b0 std %g2, [ %fp + -80 ] lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 400080c4: a8 10 20 00 clr %l4 goto number; 400080c8: 10 bf fe b5 b 40007b9c <_IO_Vprintf+0x184> 400080cc: c2 27 bf bc st %g1, [ %fp + -68 ] p = va_arg(ap, char *); 400080d0: fa 06 c0 00 ld [ %i3 ], %i5 if (p == NULL) 400080d4: 80 a7 60 00 cmp %i5, 0 400080d8: 02 80 00 fd be 400084cc <_IO_Vprintf+0xab4> 400080dc: b6 06 e0 04 add %i3, 4, %i3 if (!dot) 400080e0: 80 a2 e0 00 cmp %o3, 0 400080e4: 12 80 00 db bne 40008450 <_IO_Vprintf+0xa38> <== NEVER TAKEN 400080e8: c2 07 bf d0 ld [ %fp + -48 ], %g1 n = strlen (p); 400080ec: 40 00 1d 76 call 4000f6c4 400080f0: 90 10 00 1d mov %i5, %o0 400080f4: a2 10 00 08 mov %o0, %l1 width -= n; 400080f8: c2 07 bf d4 ld [ %fp + -44 ], %g1 400080fc: 84 20 40 11 sub %g1, %l1, %g2 40008100: c4 27 bf d4 st %g2, [ %fp + -44 ] if (!ladjust && width > 0) 40008104: a1 38 a0 1f sra %g2, 0x1f, %l0 40008108: 82 0c a0 01 and %l2, 1, %g1 4000810c: a0 24 00 02 sub %l0, %g2, %l0 40008110: a8 04 7f ff add %l1, -1, %l4 40008114: 80 8c a0 01 btst 1, %l2 40008118: 12 80 00 c9 bne 4000843c <_IO_Vprintf+0xa24> 4000811c: a1 34 20 1f srl %l0, 0x1f, %l0 40008120: 80 a4 20 00 cmp %l0, 0 40008124: 02 80 00 c7 be 40008440 <_IO_Vprintf+0xa28> 40008128: 80 a4 60 00 cmp %l1, 0 while (width--) 4000812c: c2 07 bf d4 ld [ %fp + -44 ], %g1 40008130: a6 00 7f ff add %g1, -1, %l3 40008134: c2 0f bf c3 ldub [ %fp + -61 ], %g1 40008138: a5 28 60 18 sll %g1, 0x18, %l2 4000813c: a0 10 00 13 mov %l3, %l0 40008140: a5 3c a0 18 sra %l2, 0x18, %l2 PCHAR(padc); 40008144: 92 10 00 19 mov %i1, %o1 40008148: 9f c7 00 00 call %i4 4000814c: 90 10 00 12 mov %l2, %o0 while (width--) 40008150: a0 04 3f ff add %l0, -1, %l0 40008154: 80 a4 3f ff cmp %l0, -1 40008158: 12 bf ff fc bne 40008148 <_IO_Vprintf+0x730> 4000815c: 92 10 00 19 mov %i1, %o1 40008160: 84 05 60 01 add %l5, 1, %g2 while (n--) 40008164: 80 a4 60 00 cmp %l1, 0 40008168: 02 80 00 fa be 40008550 <_IO_Vprintf+0xb38> <== NEVER TAKEN 4000816c: aa 00 80 13 add %g2, %l3, %l5 40008170: 82 10 3f ff mov -1, %g1 40008174: c2 27 bf d4 st %g1, [ %fp + -44 ] 40008178: a0 10 20 00 clr %l0 4000817c: a2 05 20 01 add %l4, 1, %l1 40008180: a2 07 40 11 add %i5, %l1, %l1 PCHAR(*p++); 40008184: ba 07 60 01 inc %i5 40008188: d0 4f 7f ff ldsb [ %i5 + -1 ], %o0 4000818c: 9f c7 00 00 call %i4 40008190: 92 10 00 19 mov %i1, %o1 while (n--) 40008194: 80 a7 40 11 cmp %i5, %l1 40008198: 32 bf ff fc bne,a 40008188 <_IO_Vprintf+0x770> 4000819c: ba 07 60 01 inc %i5 400081a0: 84 05 60 01 add %l5, 1, %g2 400081a4: a8 05 00 02 add %l4, %g2, %l4 if (ladjust && width > 0) 400081a8: 80 8c 20 ff btst 0xff, %l0 400081ac: 02 bf fe 25 be 40007a40 <_IO_Vprintf+0x28> 400081b0: a4 10 20 00 clr %l2 while (width--) 400081b4: c2 07 bf d4 ld [ %fp + -44 ], %g1 400081b8: 80 a0 60 00 cmp %g1, 0 400081bc: 02 bf fe 21 be 40007a40 <_IO_Vprintf+0x28> <== NEVER TAKEN 400081c0: a2 00 7f ff add %g1, -1, %l1 400081c4: c2 0f bf c3 ldub [ %fp + -61 ], %g1 400081c8: a1 28 60 18 sll %g1, 0x18, %l0 400081cc: ba 10 00 11 mov %l1, %i5 400081d0: a1 3c 20 18 sra %l0, 0x18, %l0 PCHAR(padc); 400081d4: 92 10 00 19 mov %i1, %o1 400081d8: 9f c7 00 00 call %i4 400081dc: 90 10 00 10 mov %l0, %o0 while (width--) 400081e0: ba 07 7f ff add %i5, -1, %i5 400081e4: 80 a7 7f ff cmp %i5, -1 400081e8: 12 bf ff fc bne 400081d8 <_IO_Vprintf+0x7c0> 400081ec: 92 10 00 19 mov %i1, %o1 400081f0: a8 05 20 01 inc %l4 400081f4: a4 10 20 00 clr %l2 400081f8: 10 bf fe 12 b 40007a40 <_IO_Vprintf+0x28> 400081fc: a8 04 40 14 add %l1, %l4, %l4 40008200: d8 08 60 01 ldub [ %g1 + 1 ], %o4 <== NOT EXECUTED sharpflag = 1; 40008204: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40008208: c2 27 bf c4 st %g1, [ %fp + -60 ] <== NOT EXECUTED goto reswitch; 4000820c: 10 bf fe 39 b 40007af0 <_IO_Vprintf+0xd8> <== NOT EXECUTED 40008210: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED PCHAR(ch); 40008214: 92 10 00 19 mov %i1, %o1 40008218: 9f c7 00 00 call %i4 4000821c: a8 05 60 01 add %l5, 1, %l4 break; 40008220: 10 bf fe 08 b 40007a40 <_IO_Vprintf+0x28> 40008224: a4 10 20 00 clr %l2 40008228: 84 06 e0 04 add %i3, 4, %g2 <== NOT EXECUTED if (!dot) { 4000822c: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED 40008230: 12 80 00 76 bne 40008408 <_IO_Vprintf+0x9f0> <== NOT EXECUTED 40008234: c6 06 c0 00 ld [ %i3 ], %g3 <== NOT EXECUTED if (width < 0) { 40008238: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 4000823c: 06 80 00 af bl 400084f8 <_IO_Vprintf+0xae0> <== NOT EXECUTED 40008240: c6 27 bf d4 st %g3, [ %fp + -44 ] <== NOT EXECUTED 40008244: d8 08 60 01 ldub [ %g1 + 1 ], %o4 <== NOT EXECUTED dwidth = va_arg(ap, int); 40008248: b6 10 00 02 mov %g2, %i3 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 4000824c: 10 bf fe 29 b 40007af0 <_IO_Vprintf+0xd8> <== NOT EXECUTED 40008250: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED 40008254: d8 08 60 01 ldub [ %g1 + 1 ], %o4 ladjust = 1; 40008258: a4 10 20 01 mov 1, %l2 goto reswitch; 4000825c: 10 bf fe 25 b 40007af0 <_IO_Vprintf+0xd8> 40008260: 82 10 00 1a mov %i2, %g1 while (percent < fmt) 40008264: a0 10 00 1d mov %i5, %l0 40008268: a8 10 00 15 mov %l5, %l4 4000826c: 80 a6 80 1d cmp %i2, %i5 40008270: 08 bf fd f4 bleu 40007a40 <_IO_Vprintf+0x28> <== NEVER TAKEN 40008274: a4 10 20 01 mov 1, %l2 PCHAR(*percent++); 40008278: a0 04 20 01 inc %l0 4000827c: d0 4c 3f ff ldsb [ %l0 + -1 ], %o0 40008280: 9f c7 00 00 call %i4 40008284: 92 10 00 19 mov %i1, %o1 while (percent < fmt) 40008288: 80 a6 80 10 cmp %i2, %l0 4000828c: 32 bf ff fc bne,a 4000827c <_IO_Vprintf+0x864> 40008290: a0 04 20 01 inc %l0 40008294: 84 25 40 1d sub %l5, %i5, %g2 stop = 1; 40008298: a4 10 20 01 mov 1, %l2 4000829c: 10 bf fd e9 b 40007a40 <_IO_Vprintf+0x28> 400082a0: a8 06 80 02 add %i2, %g2, %l4 reswitch: switch (ch = (u_char)*fmt++) { 400082a4: 10 bf ff 3a b 40007f8c <_IO_Vprintf+0x574> 400082a8: 82 10 00 1a mov %i2, %g1 static inline int imax(int a, int b) { return (a > b ? a : b); } 400082ac: c4 07 bf d0 ld [ %fp + -48 ], %g2 400082b0: 80 a0 80 11 cmp %g2, %l1 400082b4: 16 80 00 04 bge 400082c4 <_IO_Vprintf+0x8ac> 400082b8: 86 10 00 02 mov %g2, %g3 400082bc: 86 10 00 11 mov %l1, %g3 dwidth -= n; 400082c0: c4 07 bf d0 ld [ %fp + -48 ], %g2 400082c4: a2 20 80 11 sub %g2, %l1, %l1 width -= tmp + imax(dwidth, n); 400082c8: c4 07 bf d4 ld [ %fp + -44 ], %g2 400082cc: 82 00 c0 01 add %g3, %g1, %g1 if (!ladjust) 400082d0: 80 a4 a0 00 cmp %l2, 0 400082d4: 12 bf fe 86 bne 40007cec <_IO_Vprintf+0x2d4> 400082d8: a6 20 80 01 sub %g2, %g1, %l3 while (width-- > 0) 400082dc: 10 bf fe 78 b 40007cbc <_IO_Vprintf+0x2a4> 400082e0: ac 04 ff ff add %l3, -1, %l6 else if (lflag) 400082e4: 12 80 00 0c bne 40008314 <_IO_Vprintf+0x8fc> 400082e8: 82 06 e0 04 add %i3, 4, %g1 else if (hflag) 400082ec: 80 a3 e0 00 cmp %o7, 0 400082f0: 02 80 00 48 be 40008410 <_IO_Vprintf+0x9f8> <== ALWAYS TAKEN 400082f4: 80 a3 60 00 cmp %o5, 0 num = (u_short)va_arg(ap, int); 400082f8: c6 16 e0 02 lduh [ %i3 + 2 ], %g3 <== NOT EXECUTED 400082fc: 84 10 20 00 clr %g2 <== NOT EXECUTED 40008300: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED 40008304: 10 bf fe 26 b 40007b9c <_IO_Vprintf+0x184> <== NOT EXECUTED 40008308: c4 3f bf c8 std %g2, [ %fp + -56 ] <== NOT EXECUTED while (width-- > 0) 4000830c: 10 bf fd cd b 40007a40 <_IO_Vprintf+0x28> 40008310: a4 10 20 00 clr %l2 num = va_arg(ap, u_int); 40008314: c6 06 c0 00 ld [ %i3 ], %g3 40008318: 84 10 20 00 clr %g2 4000831c: b6 10 00 01 mov %g1, %i3 40008320: 10 bf fe 1f b 40007b9c <_IO_Vprintf+0x184> 40008324: c4 3f bf c8 std %g2, [ %fp + -56 ] 40008328: 10 bf fe 77 b 40007d04 <_IO_Vprintf+0x2ec> 4000832c: a8 10 00 15 mov %l5, %l4 else if (tflag) 40008330: 80 a1 20 00 cmp %g4, 0 40008334: 12 80 00 17 bne 40008390 <_IO_Vprintf+0x978> 40008338: c6 06 c0 00 ld [ %i3 ], %g3 else if (hflag) 4000833c: 80 a3 e0 00 cmp %o7, 0 40008340: 02 80 00 66 be 400084d8 <_IO_Vprintf+0xac0> <== ALWAYS TAKEN 40008344: 80 a3 60 00 cmp %o5, 0 num = (short)va_arg(ap, int); 40008348: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED 4000834c: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED 40008350: 83 38 e0 10 sra %g3, 0x10, %g1 <== NOT EXECUTED 40008354: c2 27 bf cc st %g1, [ %fp + -52 ] <== NOT EXECUTED 40008358: 83 38 e0 1f sra %g3, 0x1f, %g1 <== NOT EXECUTED 4000835c: 10 bf fe b0 b 40007e1c <_IO_Vprintf+0x404> <== NOT EXECUTED 40008360: c2 27 bf c8 st %g1, [ %fp + -56 ] <== NOT EXECUTED } else if (base == 16) { 40008364: 80 a0 60 10 cmp %g1, 0x10 40008368: 32 bf fe 73 bne,a 40007d34 <_IO_Vprintf+0x31c> <== NEVER TAKEN 4000836c: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED PCHAR('0'); 40008370: 9f c7 00 00 call %i4 40008374: 90 10 20 30 mov 0x30, %o0 PCHAR('x'); 40008378: 92 10 00 19 mov %i1, %o1 4000837c: 90 10 20 78 mov 0x78, %o0 40008380: 9f c7 00 00 call %i4 40008384: a8 05 20 02 add %l4, 2, %l4 while (dwidth-- > 0) 40008388: 10 bf fe 6b b 40007d34 <_IO_Vprintf+0x31c> 4000838c: 80 a4 60 00 cmp %l1, 0 num = va_arg(ap, int); 40008390: b6 10 00 01 mov %g1, %i3 40008394: c6 27 bf cc st %g3, [ %fp + -52 ] 40008398: 83 38 e0 1f sra %g3, 0x1f, %g1 4000839c: 10 bf fe a0 b 40007e1c <_IO_Vprintf+0x404> 400083a0: c2 27 bf c8 st %g1, [ %fp + -56 ] PCHAR(va_arg(ap, int)); 400083a4: d0 06 c0 00 ld [ %i3 ], %o0 400083a8: 9f c7 00 00 call %i4 400083ac: 92 10 00 19 mov %i1, %o1 if (ladjust && width > 0) 400083b0: 80 8c a0 01 btst 1, %l2 400083b4: 02 80 00 3b be 400084a0 <_IO_Vprintf+0xa88> <== ALWAYS TAKEN 400083b8: 80 8f 60 ff btst 0xff, %i5 400083bc: 02 80 00 39 be 400084a0 <_IO_Vprintf+0xa88> <== NOT EXECUTED 400083c0: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED while (width--) 400083c4: a8 00 7f fe add %g1, -2, %l4 <== NOT EXECUTED 400083c8: c2 0f bf c3 ldub [ %fp + -61 ], %g1 <== NOT EXECUTED 400083cc: b7 28 60 18 sll %g1, 0x18, %i3 <== NOT EXECUTED 400083d0: ba 10 00 14 mov %l4, %i5 <== NOT EXECUTED 400083d4: b7 3e e0 18 sra %i3, 0x18, %i3 <== NOT EXECUTED PCHAR(padc); 400083d8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 400083dc: 9f c7 00 00 call %i4 <== NOT EXECUTED 400083e0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED while (width--) 400083e4: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED 400083e8: 80 a7 7f ff cmp %i5, -1 <== NOT EXECUTED 400083ec: 12 bf ff fc bne 400083dc <_IO_Vprintf+0x9c4> <== NOT EXECUTED 400083f0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 400083f4: 84 05 60 02 add %l5, 2, %g2 <== NOT EXECUTED PCHAR(va_arg(ap, int)); 400083f8: b6 10 00 10 mov %l0, %i3 <== NOT EXECUTED 400083fc: a8 05 00 02 add %l4, %g2, %l4 <== NOT EXECUTED while (width--) 40008400: 10 bf fd 90 b 40007a40 <_IO_Vprintf+0x28> <== NOT EXECUTED 40008404: a4 10 20 00 clr %l2 <== NOT EXECUTED dwidth = va_arg(ap, int); 40008408: 10 bf ff 8f b 40008244 <_IO_Vprintf+0x82c> <== NOT EXECUTED 4000840c: c6 27 bf d0 st %g3, [ %fp + -48 ] <== NOT EXECUTED else if (cflag) 40008410: 22 bf ff c2 be,a 40008318 <_IO_Vprintf+0x900> 40008414: c6 06 c0 00 ld [ %i3 ], %g3 num = (u_char)va_arg(ap, int); 40008418: c6 0e e0 03 ldub [ %i3 + 3 ], %g3 4000841c: 84 10 20 00 clr %g2 40008420: b6 10 00 01 mov %g1, %i3 40008424: 10 bf fd de b 40007b9c <_IO_Vprintf+0x184> 40008428: c4 3f bf c8 std %g2, [ %fp + -56 ] cflag = 1; 4000842c: 9a 10 00 0f mov %o7, %o5 reswitch: switch (ch = (u_char)*fmt++) { 40008430: 82 10 00 1a mov %i2, %g1 hflag = 0; 40008434: 10 bf fd af b 40007af0 <_IO_Vprintf+0xd8> 40008438: 9e 10 20 00 clr %o7 while (n--) 4000843c: 80 a4 60 00 cmp %l1, 0 40008440: 12 bf ff 4f bne 4000817c <_IO_Vprintf+0x764> 40008444: a0 0c 00 01 and %l0, %g1, %l0 40008448: 10 bf ff 58 b 400081a8 <_IO_Vprintf+0x790> 4000844c: a8 10 00 15 mov %l5, %l4 for (n = 0; n < dwidth && p[n]; n++) 40008450: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008454: 04 80 00 06 ble 4000846c <_IO_Vprintf+0xa54> <== NOT EXECUTED 40008458: c4 07 bf d4 ld [ %fp + -44 ], %g2 <== NOT EXECUTED 4000845c: c2 4f 40 00 ldsb [ %i5 ], %g1 <== NOT EXECUTED 40008460: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008464: 12 80 00 2d bne 40008518 <_IO_Vprintf+0xb00> <== NOT EXECUTED 40008468: a2 10 20 00 clr %l1 <== NOT EXECUTED if (!ladjust && width > 0) 4000846c: a1 38 a0 1f sra %g2, 0x1f, %l0 <== NOT EXECUTED 40008470: 82 0c a0 01 and %l2, 1, %g1 <== NOT EXECUTED 40008474: a0 24 00 02 sub %l0, %g2, %l0 <== NOT EXECUTED 40008478: 80 8c a0 01 btst 1, %l2 <== NOT EXECUTED 4000847c: 12 80 00 06 bne 40008494 <_IO_Vprintf+0xa7c> <== NOT EXECUTED 40008480: a1 34 20 1f srl %l0, 0x1f, %l0 <== NOT EXECUTED 40008484: a8 10 3f ff mov -1, %l4 <== NOT EXECUTED 40008488: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 4000848c: 12 bf ff 28 bne 4000812c <_IO_Vprintf+0x714> <== NOT EXECUTED 40008490: a2 10 20 00 clr %l1 <== NOT EXECUTED 40008494: a0 0c 00 01 and %l0, %g1, %l0 <== NOT EXECUTED 40008498: 10 bf ff 44 b 400081a8 <_IO_Vprintf+0x790> <== NOT EXECUTED 4000849c: a8 10 00 15 mov %l5, %l4 <== NOT EXECUTED PCHAR(va_arg(ap, int)); 400084a0: b6 10 00 10 mov %l0, %i3 400084a4: 10 bf fd 67 b 40007a40 <_IO_Vprintf+0x28> 400084a8: a4 10 20 00 clr %l2 if (ch < '0' || ch > '9') 400084ac: 84 00 ff d0 add %g3, -48, %g2 <== NOT EXECUTED n = n * 10 + ch - '0'; 400084b0: 90 02 3f d0 add %o0, -48, %o0 <== NOT EXECUTED if (ch < '0' || ch > '9') 400084b4: 80 a0 a0 09 cmp %g2, 9 <== NOT EXECUTED 400084b8: 08 bf fe a9 bleu 40007f5c <_IO_Vprintf+0x544> <== NOT EXECUTED 400084bc: d8 08 60 01 ldub [ %g1 + 1 ], %o4 <== NOT EXECUTED n = n * 10 + ch - '0'; 400084c0: d0 27 bf d0 st %o0, [ %fp + -48 ] <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 400084c4: 10 bf fd 8b b 40007af0 <_IO_Vprintf+0xd8> <== NOT EXECUTED 400084c8: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED p = "(null)"; 400084cc: 3b 10 00 66 sethi %hi(0x40019800), %i5 400084d0: 10 bf ff 04 b 400080e0 <_IO_Vprintf+0x6c8> 400084d4: ba 17 60 f0 or %i5, 0xf0, %i5 ! 400198f0 <_Objects_Information_table+0x30> else if (cflag) 400084d8: 02 bf ff af be 40008394 <_IO_Vprintf+0x97c> <== ALWAYS TAKEN 400084dc: b6 10 00 01 mov %g1, %i3 num = (char)va_arg(ap, int); 400084e0: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED 400084e4: 83 38 e0 18 sra %g3, 0x18, %g1 <== NOT EXECUTED 400084e8: c2 27 bf cc st %g1, [ %fp + -52 ] <== NOT EXECUTED 400084ec: 83 38 e0 1f sra %g3, 0x1f, %g1 <== NOT EXECUTED 400084f0: 10 bf fe 4b b 40007e1c <_IO_Vprintf+0x404> <== NOT EXECUTED 400084f4: c2 27 bf c8 st %g1, [ %fp + -56 ] <== NOT EXECUTED 400084f8: d8 08 60 01 ldub [ %g1 + 1 ], %o4 <== NOT EXECUTED width = -width; 400084fc: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED 40008500: 82 20 00 01 neg %g1 <== NOT EXECUTED 40008504: a4 1c a0 01 xor %l2, 1, %l2 <== NOT EXECUTED 40008508: c2 27 bf d4 st %g1, [ %fp + -44 ] <== NOT EXECUTED width = va_arg(ap, int); 4000850c: b6 10 00 02 mov %g2, %i3 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 40008510: 10 bf fd 78 b 40007af0 <_IO_Vprintf+0xd8> <== NOT EXECUTED 40008514: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED for (n = 0; n < dwidth && p[n]; n++) 40008518: c2 07 bf d0 ld [ %fp + -48 ], %g1 <== NOT EXECUTED 4000851c: a2 04 60 01 inc %l1 <== NOT EXECUTED 40008520: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 40008524: 02 bf fe f6 be 400080fc <_IO_Vprintf+0x6e4> <== NOT EXECUTED 40008528: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED 4000852c: c2 4f 40 11 ldsb [ %i5 + %l1 ], %g1 <== NOT EXECUTED 40008530: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008534: 22 bf fe f2 be,a 400080fc <_IO_Vprintf+0x6e4> <== NOT EXECUTED 40008538: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED 4000853c: 10 bf ff f8 b 4000851c <_IO_Vprintf+0xb04> <== NOT EXECUTED 40008540: c2 07 bf d0 ld [ %fp + -48 ], %g1 <== NOT EXECUTED 40008544: ba 10 20 00 clr %i5 lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 40008548: 10 bf fd 95 b 40007b9c <_IO_Vprintf+0x184> 4000854c: a8 10 20 00 clr %l4 while (n--) 40008550: a8 10 00 15 mov %l5, %l4 <== NOT EXECUTED 40008554: 10 bf fd 3b b 40007a40 <_IO_Vprintf+0x28> <== NOT EXECUTED 40008558: a4 10 20 00 clr %l2 <== NOT EXECUTED =============================================================================== 4000856c <_ISR_Handler_initialization>: #elif defined(CPU_INTERRUPT_MAXIMUM_VECTOR_NUMBER) #error "CPU_INTERRUPT_MAXIMUM_VECTOR_NUMBER is defined for non-simple vectored interrupts" #endif void _ISR_Handler_initialization( void ) { 4000856c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED uint32_t cpu_max; uint32_t cpu_index; size_t stack_size; char *stack_low; _ISR_Nest_level = 0; 40008570: c0 21 a0 10 clr [ %g6 + 0x10 ] * * @return This method returns the minimum stack size; */ RTEMS_INLINE_ROUTINE uint32_t _Stack_Minimum (void) { return rtems_minimum_stack_size; 40008574: 03 10 00 6c sethi %hi(0x4001b000), %g1 _CPU_Initialize_vectors(); #endif stack_size = rtems_configuration_get_interrupt_stack_size(); if ( !_Stack_Is_enough( stack_size ) ) 40008578: c4 00 63 40 ld [ %g1 + 0x340 ], %g2 ! 4001b340 <_data_load_start> stack_size = rtems_configuration_get_interrupt_stack_size(); 4000857c: 03 00 00 04 sethi %hi(0x1000), %g1 40008580: 82 10 60 00 mov %g1, %g1 ! 1000 <_Configuration_Interrupt_stack_size> if ( !_Stack_Is_enough( stack_size ) ) 40008584: 80 a0 40 02 cmp %g1, %g2 40008588: 0a 80 00 0a bcs 400085b0 <_ISR_Handler_initialization+0x44> <== NEVER TAKEN 4000858c: 05 10 00 7e sethi %hi(0x4001f800), %g2 char *stack_high; cpu = _Per_CPU_Get_by_index( cpu_index ); stack_high = _Addresses_Add_offset( stack_low, stack_size ); cpu->interrupt_stack_low = stack_low; 40008590: 07 10 00 68 sethi %hi(0x4001a000), %g3 40008594: 84 10 a1 40 or %g2, 0x140, %g2 40008598: 86 10 e3 40 or %g3, 0x340, %g3 RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( const void *base, uintptr_t offset ) { return (void *)((uintptr_t)base + offset); 4000859c: 82 00 40 03 add %g1, %g3, %g1 400085a0: c6 20 a0 08 st %g3, [ %g2 + 8 ] cpu->interrupt_stack_high = stack_high; 400085a4: c2 20 a0 0c st %g1, [ %g2 + 0xc ] ); #endif stack_low = stack_high; } } 400085a8: 81 c7 e0 08 ret 400085ac: 81 e8 00 00 restore _Internal_error( INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); 400085b0: 7f ff fc bd call 400078a4 <_Internal_error> <== NOT EXECUTED 400085b4: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED 400085b8: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 4000855c <_ISR_Is_in_progress>: #if defined( RTEMS_SMP ) _ISR_Local_enable( level ); #endif return isr_nest_level != 0; 4000855c: c2 01 a0 10 ld [ %g6 + 0x10 ], %g1 <== NOT EXECUTED } 40008560: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 40008564: 81 c3 e0 08 retl <== NOT EXECUTED 40008568: 90 40 20 00 addx %g0, 0, %o0 =============================================================================== 400078a4 <_Internal_error>: /* will not return from this routine */ while (true); } void _Internal_error( Internal_errors_Core_list core_error ) { 400078a4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED _Terminate( INTERNAL_ERROR_CORE, core_error ); 400078a8: 90 10 20 00 clr %o0 <== NOT EXECUTED 400078ac: 7f ff ff eb call 40007858 <_Terminate> <== NOT EXECUTED 400078b0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 400078b4: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 4000b96c <_Mutex_Acquire>: ); } } void _Mutex_Acquire( struct _Mutex_Control *_mutex ) { 4000b96c: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b970: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000b974: 86 10 00 01 mov %g1, %g3 _Thread_queue_Context_ISR_disable( &queue_context, level ); executing = _Mutex_Queue_acquire_critical( mutex, &queue_context ); owner = mutex->Queue.Queue.owner; if ( __predict_true( owner == NULL ) ) { 4000b978: c4 06 20 0c ld [ %i0 + 0xc ], %g2 4000b97c: 80 a0 a0 00 cmp %g2, 0 4000b980: 12 80 00 07 bne 4000b99c <_Mutex_Acquire+0x30> 4000b984: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2 mutex->Queue.Queue.owner = executing; 4000b988: d4 26 20 0c st %o2, [ %i0 + 0xc ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b98c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b990: 01 00 00 00 nop 4000b994: 81 c7 e0 08 ret 4000b998: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _Thread_queue_Context_set_enqueue_do_nothing_extra( Thread_queue_Context *queue_context ) { queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra; 4000b99c: 03 10 00 36 sethi %hi(0x4000d800), %g1 4000b9a0: 82 10 60 18 or %g1, 0x18, %g1 ! 4000d818 <_Thread_queue_Enqueue_do_nothing_extra> 4000b9a4: c2 27 bf e4 st %g1, [ %fp + -28 ] queue_context->thread_state = thread_state; 4000b9a8: 82 10 20 01 mov 1, %g1 4000b9ac: c2 27 bf e0 st %g1, [ %fp + -32 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Context_set_deadlock_callout( Thread_queue_Context *queue_context, Thread_queue_Deadlock_callout deadlock_callout ) { queue_context->deadlock_callout = deadlock_callout; 4000b9b0: 03 10 00 36 sethi %hi(0x4000d800), %g1 4000b9b4: 82 10 60 20 or %g1, 0x20, %g1 ! 4000d820 <_Thread_queue_Deadlock_fatal> _Thread_queue_Enqueue( 4000b9b8: 96 07 bf dc add %fp, -36, %o3 4000b9bc: c2 27 bf fc st %g1, [ %fp + -4 ] 4000b9c0: 13 10 00 8d sethi %hi(0x40023400), %o1 ) { #if defined( RTEMS_SMP ) context->Lock_context.isr_level = level; #else context->isr_level = level; 4000b9c4: c6 27 bf dc st %g3, [ %fp + -36 ] 4000b9c8: 92 12 61 90 or %o1, 0x190, %o1 4000b9cc: 40 00 07 99 call 4000d830 <_Thread_queue_Enqueue> 4000b9d0: 90 06 20 08 add %i0, 8, %o0 _Mutex_Queue_release( mutex, level, &queue_context ); } else { _Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context ); _Mutex_Acquire_slow( mutex, owner, executing, level, &queue_context ); } } 4000b9d4: 81 c7 e0 08 ret 4000b9d8: 81 e8 00 00 restore =============================================================================== 4000a25c <_Mutex_Acquire_timed>: int _Mutex_Acquire_timed( struct _Mutex_Control *_mutex, const struct timespec *abstime ) { 4000a25c: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000a260: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000a264: 86 10 00 01 mov %g1, %g3 _Thread_queue_Context_ISR_disable( &queue_context, level ); executing = _Mutex_Queue_acquire_critical( mutex, &queue_context ); owner = mutex->Queue.Queue.owner; if ( __predict_true( owner == NULL ) ) { 4000a268: c4 06 20 0c ld [ %i0 + 0xc ], %g2 4000a26c: 80 a0 a0 00 cmp %g2, 0 4000a270: 12 80 00 07 bne 4000a28c <_Mutex_Acquire_timed+0x30> 4000a274: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5 mutex->Queue.Queue.owner = executing; 4000a278: fa 26 20 0c st %i5, [ %i0 + 0xc ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000a27c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000a280: 01 00 00 00 nop _Thread_Resource_count_increment( executing ); _Mutex_Queue_release( mutex, level, &queue_context ); return 0; 4000a284: 81 c7 e0 08 ret 4000a288: 91 e8 20 00 restore %g0, 0, %o0 queue_context->thread_state = thread_state; 4000a28c: 82 10 20 01 mov 1, %g1 4000a290: c2 27 bf e0 st %g1, [ %fp + -32 ] queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec; 4000a294: 03 10 00 35 sethi %hi(0x4000d400), %g1 4000a298: 82 10 62 b0 or %g1, 0x2b0, %g1 ! 4000d6b0 <_Thread_queue_Add_timeout_realtime_timespec> 4000a29c: c2 27 bf e4 st %g1, [ %fp + -28 ] queue_context->deadlock_callout = deadlock_callout; 4000a2a0: 03 10 00 31 sethi %hi(0x4000c400), %g1 4000a2a4: 82 10 62 b8 or %g1, 0x2b8, %g1 ! 4000c6b8 <_Thread_queue_Deadlock_fatal> _Thread_queue_Enqueue( 4000a2a8: 90 06 20 08 add %i0, 8, %o0 queue_context->Timeout.arg = abstime; 4000a2ac: f2 27 bf e8 st %i1, [ %fp + -24 ] 4000a2b0: 96 07 bf dc add %fp, -36, %o3 4000a2b4: c6 27 bf dc st %g3, [ %fp + -36 ] 4000a2b8: 94 10 00 1d mov %i5, %o2 queue_context->deadlock_callout = deadlock_callout; 4000a2bc: c2 27 bf fc st %g1, [ %fp + -4 ] 4000a2c0: 13 10 00 49 sethi %hi(0x40012400), %o1 4000a2c4: 40 00 09 01 call 4000c6c8 <_Thread_queue_Enqueue> 4000a2c8: 92 12 62 e8 or %o1, 0x2e8, %o1 ! 400126e8 <_Thread_queue_Operations_priority_inherit> &queue_context, abstime ); _Mutex_Acquire_slow( mutex, owner, executing, level, &queue_context ); return STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) ); 4000a2cc: f0 07 60 4c ld [ %i5 + 0x4c ], %i0 4000a2d0: b1 3e 20 08 sra %i0, 8, %i0 } } 4000a2d4: 81 c7 e0 08 ret 4000a2d8: 81 e8 00 00 restore =============================================================================== 4000b9dc <_Mutex_Release>: return eno; } void _Mutex_Release( struct _Mutex_Control *_mutex ) { 4000b9dc: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b9e0: 91 d0 20 09 ta 9 <== NOT EXECUTED executing = _Thread_Executing; 4000b9e4: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2 mutex->Queue.Queue.owner = NULL; 4000b9e8: c0 26 20 0c clr [ %i0 + 0xc ] heads = mutex->Queue.Queue.heads; 4000b9ec: d2 06 20 08 ld [ %i0 + 8 ], %o1 if ( __predict_true( heads == NULL ) ) { 4000b9f0: 80 a2 60 00 cmp %o1, 0 4000b9f4: 32 80 00 06 bne,a 4000ba0c <_Mutex_Release+0x30> 4000b9f8: c2 27 bf dc st %g1, [ %fp + -36 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b9fc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ba00: 01 00 00 00 nop 4000ba04: 81 c7 e0 08 ret 4000ba08: 81 e8 00 00 restore _Thread_queue_Surrender( 4000ba0c: 19 10 00 8d sethi %hi(0x40023400), %o4 4000ba10: 96 07 bf dc add %fp, -36, %o3 4000ba14: 98 13 21 90 or %o4, 0x190, %o4 4000ba18: 40 00 08 23 call 4000daa4 <_Thread_queue_Surrender> 4000ba1c: 90 06 20 08 add %i0, 8, %o0 executing = _Mutex_Queue_acquire_critical( mutex, &queue_context ); _Assert( mutex->Queue.Queue.owner == executing ); _Mutex_Release_critical( mutex, executing, level, &queue_context ); } 4000ba20: 81 c7 e0 08 ret 4000ba24: 81 e8 00 00 restore =============================================================================== 4000a2dc <_Mutex_Try_acquire>: __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000a2dc: 91 d0 20 09 ta 9 <== NOT EXECUTED _Thread_queue_Context_ISR_disable( &queue_context, level ); executing = _Mutex_Queue_acquire_critical( mutex, &queue_context ); owner = mutex->Queue.Queue.owner; if ( __predict_true( owner == NULL ) ) { 4000a2e0: c4 02 20 0c ld [ %o0 + 0xc ], %g2 4000a2e4: 80 a0 a0 00 cmp %g2, 0 4000a2e8: 12 80 00 08 bne 4000a308 <_Mutex_Try_acquire+0x2c> 4000a2ec: c6 01 a0 20 ld [ %g6 + 0x20 ], %g3 mutex->Queue.Queue.owner = executing; 4000a2f0: c6 22 20 0c st %g3, [ %o0 + 0xc ] <== NOT EXECUTED _Thread_Resource_count_increment( executing ); eno = 0; 4000a2f4: 90 10 20 00 clr %o0 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000a2f8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000a2fc: 01 00 00 00 nop } _Mutex_Queue_release( mutex, level, &queue_context ); return eno; } 4000a300: 81 c3 e0 08 retl 4000a304: 01 00 00 00 nop eno = EBUSY; 4000a308: 90 10 20 10 mov 0x10, %o0 ! 10 <_TLS_Alignment+0xf> <== NOT EXECUTED 4000a30c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000a310: 01 00 00 00 nop } 4000a314: 81 c3 e0 08 retl 4000a318: 01 00 00 00 nop =============================================================================== 40008c70 <_Mutex_recursive_Acquire>: { return (Mutex_recursive_Control *) _mutex; } void _Mutex_recursive_Acquire( struct _Mutex_recursive_Control *_mutex ) { 40008c70: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40008c74: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 40008c78: 86 10 00 01 mov %g1, %g3 mutex = _Mutex_recursive_Get( _mutex ); _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_ISR_disable( &queue_context, level ); executing = _Mutex_Queue_acquire_critical( &mutex->Mutex, &queue_context ); owner = mutex->Mutex.Queue.Queue.owner; 40008c7c: c4 06 20 0c ld [ %i0 + 0xc ], %g2 if ( __predict_true( owner == NULL ) ) { 40008c80: 80 a0 a0 00 cmp %g2, 0 40008c84: 12 80 00 07 bne 40008ca0 <_Mutex_recursive_Acquire+0x30> 40008c88: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2 mutex->Mutex.Queue.Queue.owner = executing; 40008c8c: d4 26 20 0c st %o2, [ %i0 + 0xc ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40008c90: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40008c94: 01 00 00 00 nop 40008c98: 81 c7 e0 08 ret 40008c9c: 81 e8 00 00 restore _Thread_Resource_count_increment( executing ); _Mutex_Queue_release( &mutex->Mutex, level, &queue_context ); } else if ( owner == executing ) { 40008ca0: 80 a2 80 02 cmp %o2, %g2 40008ca4: 02 80 00 11 be 40008ce8 <_Mutex_recursive_Acquire+0x78> 40008ca8: 96 07 bf dc add %fp, -36, %o3 RTEMS_INLINE_ROUTINE void _Thread_queue_Context_set_enqueue_do_nothing_extra( Thread_queue_Context *queue_context ) { queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra; 40008cac: 03 10 00 2a sethi %hi(0x4000a800), %g1 40008cb0: 82 10 61 9c or %g1, 0x19c, %g1 ! 4000a99c <_Thread_queue_Enqueue_do_nothing_extra> 40008cb4: c2 27 bf e4 st %g1, [ %fp + -28 ] queue_context->thread_state = thread_state; 40008cb8: 82 10 20 01 mov 1, %g1 40008cbc: c2 27 bf e0 st %g1, [ %fp + -32 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Context_set_deadlock_callout( Thread_queue_Context *queue_context, Thread_queue_Deadlock_callout deadlock_callout ) { queue_context->deadlock_callout = deadlock_callout; 40008cc0: 03 10 00 2a sethi %hi(0x4000a800), %g1 40008cc4: 82 10 61 a4 or %g1, 0x1a4, %g1 ! 4000a9a4 <_Thread_queue_Deadlock_fatal> 40008cc8: c2 27 bf fc st %g1, [ %fp + -4 ] _Thread_queue_Enqueue( 40008ccc: 13 10 00 66 sethi %hi(0x40019800), %o1 ) { #if defined( RTEMS_SMP ) context->Lock_context.isr_level = level; #else context->isr_level = level; 40008cd0: c6 27 bf dc st %g3, [ %fp + -36 ] 40008cd4: 92 12 61 28 or %o1, 0x128, %o1 40008cd8: 40 00 07 37 call 4000a9b4 <_Thread_queue_Enqueue> 40008cdc: 90 06 20 08 add %i0, 8, %o0 _Mutex_Queue_release( &mutex->Mutex, level, &queue_context ); } else { _Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context ); _Mutex_Acquire_slow( &mutex->Mutex, owner, executing, level, &queue_context ); } } 40008ce0: 81 c7 e0 08 ret 40008ce4: 81 e8 00 00 restore ++mutex->nest_level; 40008ce8: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED 40008cec: 84 00 a0 01 inc %g2 <== NOT EXECUTED 40008cf0: c4 26 20 14 st %g2, [ %i0 + 0x14 ] <== NOT EXECUTED 40008cf4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40008cf8: 01 00 00 00 nop 40008cfc: 81 c7 e0 08 ret 40008d00: 81 e8 00 00 restore =============================================================================== 400097e8 <_Mutex_recursive_Acquire_timed>: int _Mutex_recursive_Acquire_timed( struct _Mutex_recursive_Control *_mutex, const struct timespec *abstime ) { 400097e8: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400097ec: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 400097f0: 86 10 00 01 mov %g1, %g3 mutex = _Mutex_recursive_Get( _mutex ); _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_ISR_disable( &queue_context, level ); executing = _Mutex_Queue_acquire_critical( &mutex->Mutex, &queue_context ); owner = mutex->Mutex.Queue.Queue.owner; 400097f4: c4 06 20 0c ld [ %i0 + 0xc ], %g2 if ( __predict_true( owner == NULL ) ) { 400097f8: 80 a0 a0 00 cmp %g2, 0 400097fc: 12 80 00 07 bne 40009818 <_Mutex_recursive_Acquire_timed+0x30> 40009800: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5 mutex->Mutex.Queue.Queue.owner = executing; 40009804: fa 26 20 0c st %i5, [ %i0 + 0xc ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009808: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000980c: 01 00 00 00 nop _Thread_Resource_count_increment( executing ); _Mutex_Queue_release( &mutex->Mutex, level, &queue_context ); return 0; 40009810: 81 c7 e0 08 ret 40009814: 91 e8 20 00 restore %g0, 0, %o0 } else if ( owner == executing ) { 40009818: 80 a0 80 1d cmp %g2, %i5 4000981c: 02 80 00 15 be 40009870 <_Mutex_recursive_Acquire_timed+0x88> 40009820: 90 06 20 08 add %i0, 8, %o0 queue_context->thread_state = thread_state; 40009824: 82 10 20 01 mov 1, %g1 40009828: c2 27 bf e0 st %g1, [ %fp + -32 ] queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec; 4000982c: 03 10 00 32 sethi %hi(0x4000c800), %g1 40009830: 82 10 60 10 or %g1, 0x10, %g1 ! 4000c810 <_Thread_queue_Add_timeout_realtime_timespec> 40009834: c2 27 bf e4 st %g1, [ %fp + -28 ] queue_context->deadlock_callout = deadlock_callout; 40009838: 03 10 00 2e sethi %hi(0x4000b800), %g1 4000983c: 82 10 62 10 or %g1, 0x210, %g1 ! 4000ba10 <_Thread_queue_Deadlock_fatal> queue_context->Timeout.arg = abstime; 40009840: f2 27 bf e8 st %i1, [ %fp + -24 ] _Thread_queue_Enqueue( 40009844: 96 07 bf dc add %fp, -36, %o3 40009848: c6 27 bf dc st %g3, [ %fp + -36 ] 4000984c: 94 10 00 1d mov %i5, %o2 queue_context->deadlock_callout = deadlock_callout; 40009850: c2 27 bf fc st %g1, [ %fp + -4 ] 40009854: 13 10 00 4a sethi %hi(0x40012800), %o1 40009858: 40 00 08 72 call 4000ba20 <_Thread_queue_Enqueue> 4000985c: 92 12 62 ec or %o1, 0x2ec, %o1 ! 40012aec <_Thread_queue_Operations_priority_inherit> &queue_context, abstime ); _Mutex_Acquire_slow( &mutex->Mutex, owner, executing, level, &queue_context ); return STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) ); 40009860: f0 07 60 4c ld [ %i5 + 0x4c ], %i0 40009864: b1 3e 20 08 sra %i0, 8, %i0 } } 40009868: 81 c7 e0 08 ret 4000986c: 81 e8 00 00 restore ++mutex->nest_level; 40009870: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED 40009874: 84 00 a0 01 inc %g2 <== NOT EXECUTED 40009878: c4 26 20 14 st %g2, [ %i0 + 0x14 ] <== NOT EXECUTED 4000987c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40009880: 01 00 00 00 nop return 0; 40009884: 81 c7 e0 08 ret 40009888: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 40008d04 <_Mutex_recursive_Release>: return eno; } void _Mutex_recursive_Release( struct _Mutex_recursive_Control *_mutex ) { 40008d04: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40008d08: 91 d0 20 09 ta 9 <== NOT EXECUTED _Thread_queue_Context_ISR_disable( &queue_context, level ); executing = _Mutex_Queue_acquire_critical( &mutex->Mutex, &queue_context ); _Assert( mutex->Mutex.Queue.Queue.owner == executing ); nest_level = mutex->nest_level; 40008d0c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 if ( __predict_true( nest_level == 0 ) ) { 40008d10: 80 a0 a0 00 cmp %g2, 0 40008d14: 12 80 00 0b bne 40008d40 <_Mutex_recursive_Release+0x3c> 40008d18: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2 mutex->Queue.Queue.owner = NULL; 40008d1c: c0 26 20 0c clr [ %i0 + 0xc ] heads = mutex->Queue.Queue.heads; 40008d20: d2 06 20 08 ld [ %i0 + 8 ], %o1 if ( __predict_true( heads == NULL ) ) { 40008d24: 80 a2 60 00 cmp %o1, 0 40008d28: 32 80 00 0c bne,a 40008d58 <_Mutex_recursive_Release+0x54> 40008d2c: c2 27 bf dc st %g1, [ %fp + -36 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40008d30: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40008d34: 01 00 00 00 nop } else { mutex->nest_level = nest_level - 1; _Mutex_Queue_release( &mutex->Mutex, level, &queue_context ); } } 40008d38: 81 c7 e0 08 ret 40008d3c: 81 e8 00 00 restore mutex->nest_level = nest_level - 1; 40008d40: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 40008d44: c4 26 20 14 st %g2, [ %i0 + 0x14 ] <== NOT EXECUTED 40008d48: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40008d4c: 01 00 00 00 nop } 40008d50: 81 c7 e0 08 ret 40008d54: 81 e8 00 00 restore _Thread_queue_Surrender( 40008d58: 19 10 00 66 sethi %hi(0x40019800), %o4 40008d5c: 96 07 bf dc add %fp, -36, %o3 40008d60: 98 13 21 28 or %o4, 0x128, %o4 40008d64: 40 00 07 b1 call 4000ac28 <_Thread_queue_Surrender> 40008d68: 90 06 20 08 add %i0, 8, %o0 40008d6c: 81 c7 e0 08 ret 40008d70: 81 e8 00 00 restore =============================================================================== 4000988c <_Mutex_recursive_Try_acquire>: int _Mutex_recursive_Try_acquire( struct _Mutex_recursive_Control *_mutex ) { 4000988c: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40009890: 91 d0 20 09 ta 9 <== NOT EXECUTED mutex = _Mutex_recursive_Get( _mutex ); _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_ISR_disable( &queue_context, level ); executing = _Mutex_Queue_acquire_critical( &mutex->Mutex, &queue_context ); owner = mutex->Mutex.Queue.Queue.owner; 40009894: c6 02 20 0c ld [ %o0 + 0xc ], %g3 if ( __predict_true( owner == NULL ) ) { 40009898: 80 a0 e0 00 cmp %g3, 0 4000989c: 12 80 00 08 bne 400098bc <_Mutex_recursive_Try_acquire+0x30> 400098a0: c8 01 a0 20 ld [ %g6 + 0x20 ], %g4 mutex->Mutex.Queue.Queue.owner = executing; 400098a4: c8 22 20 0c st %g4, [ %o0 + 0xc ] <== NOT EXECUTED _Thread_Resource_count_increment( executing ); eno = 0; 400098a8: 90 10 20 00 clr %o0 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400098ac: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400098b0: 01 00 00 00 nop } _Mutex_Queue_release( &mutex->Mutex, level, &queue_context ); return eno; } 400098b4: 81 c3 e0 08 retl 400098b8: 01 00 00 00 nop } else if ( owner == executing ) { 400098bc: 80 a1 00 03 cmp %g4, %g3 400098c0: 12 bf ff fb bne 400098ac <_Mutex_recursive_Try_acquire+0x20> 400098c4: 90 10 20 10 mov 0x10, %o0 ++mutex->nest_level; 400098c8: c6 00 a0 14 ld [ %g2 + 0x14 ], %g3 400098cc: 86 00 e0 01 inc %g3 eno = 0; 400098d0: 90 10 20 00 clr %o0 400098d4: 10 bf ff f6 b 400098ac <_Mutex_recursive_Try_acquire+0x20> 400098d8: c6 20 a0 14 st %g3, [ %g2 + 0x14 ] =============================================================================== 4000eae0 <_Objects_API_maximum_class>: #include unsigned int _Objects_API_maximum_class( uint32_t api ) { 4000eae0: 82 02 3f ff add %o0, -1, %g1 4000eae4: 80 a0 60 02 cmp %g1, 2 4000eae8: 18 80 00 06 bgu 4000eb00 <_Objects_API_maximum_class+0x20> <== NEVER TAKEN 4000eaec: 90 10 20 00 clr %o0 4000eaf0: 83 28 60 02 sll %g1, 2, %g1 4000eaf4: 05 10 00 67 sethi %hi(0x40019c00), %g2 4000eaf8: 84 10 a0 84 or %g2, 0x84, %g2 ! 40019c84 4000eafc: d0 00 80 01 ld [ %g2 + %g1 ], %o0 case OBJECTS_NO_API: default: break; } return 0; } 4000eb00: 81 c3 e0 08 retl 4000eb04: 01 00 00 00 nop =============================================================================== 4000bb2c <_Objects_Active_count>: #include Objects_Maximum _Objects_Active_count( const Objects_Information *information ) { 4000bb2c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED size_t inactive; size_t maximum; _Assert( _Objects_Allocator_is_owner() ); inactive = _Chain_Node_count_unprotected( &information->Inactive ); 4000bb30: 7f ff f8 20 call 40009bb0 <_Chain_Node_count_unprotected> <== NOT EXECUTED 4000bb34: 90 06 20 20 add %i0, 0x20, %o0 <== NOT EXECUTED maximum = information->maximum; return (Objects_Maximum) ( maximum - inactive ); 4000bb38: f0 16 20 10 lduh [ %i0 + 0x10 ], %i0 4000bb3c: b0 26 00 08 sub %i0, %o0, %i0 4000bb40: b1 2e 20 10 sll %i0, 0x10, %i0 } 4000bb44: b1 36 20 10 srl %i0, 0x10, %i0 4000bb48: 81 c7 e0 08 ret 4000bb4c: 81 e8 00 00 restore =============================================================================== 40008e4c <_Objects_Allocate>: Objects_Control *_Objects_Allocate( Objects_Information *information ) { 40008e4c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED _RTEMS_Lock_allocator(); 40008e50: 7f ff f8 83 call 4000705c <_RTEMS_Lock_allocator> <== NOT EXECUTED 40008e54: 01 00 00 00 nop <== NOT EXECUTED return _Objects_Allocate_unprotected( information ); 40008e58: 7f ff ff c7 call 40008d74 <_Objects_Allocate_unprotected> 40008e5c: 81 e8 00 00 restore =============================================================================== 40008d74 <_Objects_Allocate_unprotected>: } Objects_Control *_Objects_Allocate_unprotected( Objects_Information *information ) { 40008d74: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED * If the application is using the optional manager stubs and * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 ) 40008d78: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED 40008d7c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008d80: 02 80 00 31 be 40008e44 <_Objects_Allocate_unprotected+0xd0> <== NOT EXECUTED 40008d84: ba 10 00 18 mov %i0, %i5 return _Chain_Immutable_head( the_chain )->next; 40008d88: f0 06 20 20 ld [ %i0 + 0x20 ], %i0 return &the_chain->Tail.Node; 40008d8c: b8 07 60 24 add %i5, 0x24, %i4 40008d90: b6 07 60 20 add %i5, 0x20, %i3 if ( !_Chain_Is_empty(the_chain)) 40008d94: 80 a7 00 18 cmp %i4, %i0 40008d98: 02 80 00 1e be 40008e10 <_Objects_Allocate_unprotected+0x9c> 40008d9c: c4 0f 60 12 ldub [ %i5 + 0x12 ], %g2 new_first = old_first->next; 40008da0: c2 06 00 00 ld [ %i0 ], %g1 head->next = new_first; 40008da4: c2 27 60 20 st %g1, [ %i5 + 0x20 ] * OK. The manager should be initialized and configured to have objects. * With any luck, it is safe to attempt to allocate an object. */ the_object = _Objects_Get_inactive( information ); if ( information->auto_extend ) { 40008da8: 80 88 a0 ff btst 0xff, %g2 40008dac: 02 80 00 17 be 40008e08 <_Objects_Allocate_unprotected+0x94> 40008db0: f6 20 60 04 st %i3, [ %g1 + 4 ] } if ( the_object ) { uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 40008db4: c2 06 20 08 ld [ %i0 + 8 ], %g1 40008db8: c6 07 60 08 ld [ %i5 + 8 ], %g3 40008dbc: 05 00 00 3f sethi %hi(0xfc00), %g2 40008dc0: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <_Configuration_Interrupt_stack_size+0xefff> 40008dc4: 82 08 40 02 and %g1, %g2, %g1 40008dc8: 84 08 c0 02 and %g3, %g2, %g2 _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 40008dcc: c8 07 60 30 ld [ %i5 + 0x30 ], %g4 block = (uint32_t) _Objects_Get_index( the_object->id ) - 40008dd0: 82 20 40 02 sub %g1, %g2, %g1 block /= information->allocation_size; 40008dd4: c4 17 60 14 lduh [ %i5 + 0x14 ], %g2 40008dd8: 81 80 20 00 wr %g0, %y 40008ddc: 01 00 00 00 nop 40008de0: 01 00 00 00 nop 40008de4: 01 00 00 00 nop 40008de8: 84 70 40 02 udiv %g1, %g2, %g2 information->inactive_per_block[ block ]--; 40008dec: 83 28 a0 02 sll %g2, 2, %g1 40008df0: c6 01 00 01 ld [ %g4 + %g1 ], %g3 information->inactive--; 40008df4: c4 17 60 2c lduh [ %i5 + 0x2c ], %g2 information->inactive_per_block[ block ]--; 40008df8: 86 00 ff ff add %g3, -1, %g3 40008dfc: c6 21 00 01 st %g3, [ %g4 + %g1 ] information->inactive--; 40008e00: 82 00 bf ff add %g2, -1, %g1 40008e04: c2 37 60 2c sth %g1, [ %i5 + 0x2c ] ); } #endif return the_object; } 40008e08: 81 c7 e0 08 ret 40008e0c: 81 e8 00 00 restore if ( information->auto_extend ) { 40008e10: 80 88 a0 ff btst 0xff, %g2 40008e14: 02 80 00 0c be 40008e44 <_Objects_Allocate_unprotected+0xd0> 40008e18: 01 00 00 00 nop _Objects_Extend_information( information ); 40008e1c: 40 00 00 11 call 40008e60 <_Objects_Extend_information> 40008e20: 90 10 00 1d mov %i5, %o0 return _Chain_Immutable_head( the_chain )->next; 40008e24: f0 07 60 20 ld [ %i5 + 0x20 ], %i0 if ( !_Chain_Is_empty(the_chain)) 40008e28: 80 a7 00 18 cmp %i4, %i0 40008e2c: 02 80 00 06 be 40008e44 <_Objects_Allocate_unprotected+0xd0> 40008e30: 01 00 00 00 nop new_first = old_first->next; 40008e34: c2 06 00 00 ld [ %i0 ], %g1 head->next = new_first; 40008e38: c2 27 60 20 st %g1, [ %i5 + 0x20 ] new_first->previous = head; 40008e3c: 10 bf ff de b 40008db4 <_Objects_Allocate_unprotected+0x40> 40008e40: f6 20 60 04 st %i3, [ %g1 + 4 ] return NULL; 40008e44: 81 c7 e0 08 ret 40008e48: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 4000ded4 <_Objects_Close>: information->local_table[ index ] = the_object; 4000ded4: c2 12 60 0a lduh [ %o1 + 0xa ], %g1 <== NOT EXECUTED 4000ded8: c4 02 20 1c ld [ %o0 + 0x1c ], %g2 <== NOT EXECUTED 4000dedc: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 4000dee0: c0 20 80 01 clr [ %g2 + %g1 ] <== NOT EXECUTED Objects_Control *the_object ) { _Objects_Invalidate_Id( information, the_object ); _Objects_Namespace_remove( information, the_object ); 4000dee4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4000dee8: 40 00 00 69 call 4000e08c <_Objects_Namespace_remove> <== NOT EXECUTED 4000deec: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 400091a8 <_Objects_Do_initialize_information>: #if defined(RTEMS_MULTIPROCESSING) , Objects_Thread_queue_Extract_callout extract #endif ) { 400091a8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED information->maximum = 0; /* * Register this Object Class in the Object Information Table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 400091ac: 05 10 00 66 sethi %hi(0x40019800), %g2 information->size = size; 400091b0: f8 26 20 18 st %i4, [ %i0 + 0x18 ] _Objects_Information_table[ the_api ][ the_class ] = information; 400091b4: 84 10 a0 c0 or %g2, 0xc0, %g2 information->the_api = the_api; 400091b8: f2 26 00 00 st %i1, [ %i0 ] _Objects_Information_table[ the_api ][ the_class ] = information; 400091bc: b9 2e 60 02 sll %i1, 2, %i4 information->the_class = the_class; 400091c0: f4 36 20 04 sth %i2, [ %i0 + 4 ] _Objects_Information_table[ the_api ][ the_class ] = information; 400091c4: 89 2e a0 02 sll %i2, 2, %g4 information->local_table = 0; 400091c8: c0 26 20 1c clr [ %i0 + 0x1c ] * @retval true Unlimited objects are available. * @retval false The object count is fixed. */ RTEMS_INLINE_ROUTINE bool _Objects_Is_unlimited( uint32_t maximum ) { return (maximum & OBJECTS_UNLIMITED_OBJECTS) != 0; 400091cc: 87 36 e0 1f srl %i3, 0x1f, %g3 information->inactive_per_block = 0; 400091d0: c0 26 20 30 clr [ %i0 + 0x30 ] maximum_per_allocation = _Objects_Maximum_per_allocation( maximum ); /* * Unlimited and maximum of zero is illogical. */ if ( information->auto_extend && maximum_per_allocation == 0) { 400091d4: 83 2e e0 10 sll %i3, 0x10, %g1 information->object_blocks = 0; 400091d8: c0 26 20 34 clr [ %i0 + 0x34 ] if ( information->auto_extend && maximum_per_allocation == 0) { 400091dc: 80 a0 60 00 cmp %g1, 0 information->inactive = 0; 400091e0: c0 36 20 2c clrh [ %i0 + 0x2c ] information->is_string = is_string; 400091e4: fa 2e 20 38 stb %i5, [ %i0 + 0x38 ] information->maximum = 0; 400091e8: c0 36 20 10 clrh [ %i0 + 0x10 ] _Objects_Information_table[ the_api ][ the_class ] = information; 400091ec: c4 00 80 1c ld [ %g2 + %i4 ], %g2 400091f0: f0 20 80 04 st %i0, [ %g2 + %g4 ] information->auto_extend = _Objects_Is_unlimited( maximum ); 400091f4: c6 2e 20 12 stb %g3, [ %i0 + 0x12 ] if ( information->auto_extend && maximum_per_allocation == 0) { 400091f8: 12 80 00 05 bne 4000920c <_Objects_Do_initialize_information+0x64> 400091fc: c8 07 a0 5c ld [ %fp + 0x5c ], %g4 40009200: 80 a0 e0 00 cmp %g3, 0 40009204: 12 80 00 1c bne 40009274 <_Objects_Do_initialize_information+0xcc> 40009208: 01 00 00 00 nop (( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) | 4000920c: 05 00 00 40 sethi %hi(0x10000), %g2 information->local_table = &null_local_table; /* * Calculate minimum and maximum Id's */ minimum_index = (maximum_per_allocation == 0) ? 0 : 1; 40009210: 87 30 60 10 srl %g1, 0x10, %g3 40009214: 80 a0 00 03 cmp %g0, %g3 40009218: 82 40 20 00 addx %g0, 0, %g1 4000921c: 82 10 40 02 or %g1, %g2, %g1 (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 40009220: 85 2e a0 1b sll %i2, 0x1b, %g2 return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 40009224: b3 2e 60 18 sll %i1, 0x18, %i1 return &the_chain->Tail.Node; 40009228: ba 06 20 20 add %i0, 0x20, %i5 (( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) | 4000922c: b4 10 40 19 or %g1, %i1, %i2 information->allocation_size = maximum_per_allocation; 40009230: f6 36 20 14 sth %i3, [ %i0 + 0x14 ] 40009234: b4 16 80 02 or %i2, %g2, %i2 information->local_table = &null_local_table; 40009238: 03 10 00 71 sethi %hi(0x4001c400), %g1 4000923c: 84 06 20 24 add %i0, 0x24, %g2 40009240: 82 10 63 58 or %g1, 0x358, %g1 information->minimum_id = 40009244: f4 26 20 08 st %i2, [ %i0 + 8 ] _Chain_Initialize_empty( &information->Inactive ); /* * Initialize objects .. if there are any */ if ( maximum_per_allocation ) { 40009248: 80 a0 e0 00 cmp %g3, 0 information->local_table = &null_local_table; 4000924c: c2 26 20 1c st %g1, [ %i0 + 0x1c ] information->name_length = maximum_name_length; 40009250: c8 36 20 3a sth %g4, [ %i0 + 0x3a ] head->next = tail; 40009254: c4 26 20 20 st %g2, [ %i0 + 0x20 ] head->previous = NULL; 40009258: c0 26 20 24 clr [ %i0 + 0x24 ] if ( maximum_per_allocation ) { 4000925c: 12 80 00 04 bne 4000926c <_Objects_Do_initialize_information+0xc4> 40009260: fa 26 20 28 st %i5, [ %i0 + 0x28 ] #if defined(RTEMS_MULTIPROCESSING) information->extract = extract; _RBTree_Initialize_empty( &information->Global_by_id ); _RBTree_Initialize_empty( &information->Global_by_name ); #endif } 40009264: 81 c7 e0 08 ret 40009268: 81 e8 00 00 restore _Objects_Extend_information( information ); 4000926c: 7f ff fe fd call 40008e60 <_Objects_Extend_information> 40009270: 81 e8 00 00 restore _Internal_error( INTERNAL_ERROR_UNLIMITED_AND_MAXIMUM_IS_0 ); 40009274: 7f ff f9 8c call 400078a4 <_Internal_error> 40009278: 90 10 20 13 mov 0x13, %o0 4000927c: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40008e60 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 40008e60: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) 40008e64: c4 06 20 34 ld [ %i0 + 0x34 ], %g2 <== NOT EXECUTED 40008e68: e2 16 20 14 lduh [ %i0 + 0x14 ], %l1 <== NOT EXECUTED 40008e6c: e4 16 20 0a lduh [ %i0 + 0xa ], %l2 40008e70: e0 16 20 10 lduh [ %i0 + 0x10 ], %l0 40008e74: 80 a0 a0 00 cmp %g2, 0 40008e78: 02 80 00 95 be 400090cc <_Objects_Extend_information+0x26c> <== ALWAYS TAKEN 40008e7c: b6 10 00 11 mov %l1, %i3 block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 40008e80: 81 80 20 00 wr %g0, %y 40008e84: 01 00 00 00 nop 40008e88: 01 00 00 00 nop 40008e8c: 01 00 00 00 nop 40008e90: b2 f4 00 11 udivcc %l0, %l1, %i1 40008e94: 02 80 00 b1 be 40009158 <_Objects_Extend_information+0x2f8> <== NEVER TAKEN 40008e98: b5 2c 20 10 sll %l0, 0x10, %i2 if ( information->object_blocks[ block ] == NULL ) { 40008e9c: c2 00 80 00 ld [ %g2 ], %g1 40008ea0: 80 a0 60 00 cmp %g1, 0 40008ea4: 02 80 00 b1 be 40009168 <_Objects_Extend_information+0x308> <== NEVER TAKEN 40008ea8: ba 10 00 12 mov %l2, %i5 block = 0; 40008eac: 10 80 00 06 b 40008ec4 <_Objects_Extend_information+0x64> 40008eb0: b8 10 20 00 clr %i4 if ( information->object_blocks[ block ] == NULL ) { 40008eb4: c2 00 80 01 ld [ %g2 + %g1 ], %g1 40008eb8: 80 a0 60 00 cmp %g1, 0 40008ebc: 02 80 00 08 be 40008edc <_Objects_Extend_information+0x7c> 40008ec0: a8 10 20 00 clr %l4 for ( ; block < block_count; block++ ) { 40008ec4: b8 07 20 01 inc %i4 do_extend = false; break; } else index_base += information->allocation_size; 40008ec8: ba 07 40 1b add %i5, %i3, %i5 for ( ; block < block_count; block++ ) { 40008ecc: 80 a6 40 1c cmp %i1, %i4 40008ed0: 12 bf ff f9 bne 40008eb4 <_Objects_Extend_information+0x54> 40008ed4: 83 2f 20 02 sll %i4, 2, %g1 do_extend = true; 40008ed8: a8 10 20 01 mov 1, %l4 } } index_end = index_base + information->allocation_size; maximum = (uint32_t) information->maximum + information->allocation_size; 40008edc: b5 36 a0 10 srl %i2, 0x10, %i2 /* * We need to limit the number of objects to the maximum number * representable in the index portion of the object Id. In the * case of 16-bit Ids, this is only 256 object instances. */ if ( maximum > OBJECTS_ID_FINAL_INDEX ) { 40008ee0: 03 00 00 3f sethi %hi(0xfc00), %g1 maximum = (uint32_t) information->maximum + information->allocation_size; 40008ee4: b4 06 80 1b add %i2, %i3, %i2 if ( maximum > OBJECTS_ID_FINAL_INDEX ) { 40008ee8: 82 10 63 ff or %g1, 0x3ff, %g1 40008eec: 80 a6 80 01 cmp %i2, %g1 40008ef0: 18 80 00 88 bgu 40009110 <_Objects_Extend_information+0x2b0> 40008ef4: 01 00 00 00 nop /* * Allocate the name table, and the objects and if it fails either return or * generate a fatal error depending on auto-extending being active. */ block_size = information->allocation_size * information->size; 40008ef8: d0 06 20 18 ld [ %i0 + 0x18 ], %o0 if ( information->auto_extend ) { 40008efc: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1 40008f00: 80 a0 60 00 cmp %g1, 0 40008f04: 02 80 00 78 be 400090e4 <_Objects_Extend_information+0x284> 40008f08: 90 5e c0 08 smul %i3, %o0, %o0 new_object_block = _Workspace_Allocate( block_size ); 40008f0c: 40 00 0d 2b call 4000c3b8 <_Workspace_Allocate> 40008f10: 01 00 00 00 nop if ( !new_object_block ) 40008f14: a6 92 20 00 orcc %o0, 0, %l3 40008f18: 02 80 00 6b be 400090c4 <_Objects_Extend_information+0x264> <== NEVER TAKEN 40008f1c: b6 07 40 1b add %i5, %i3, %i3 } /* * Do we need to grow the tables? */ if ( do_extend ) { 40008f20: 80 8d 20 ff btst 0xff, %l4 40008f24: 22 80 00 45 be,a 40009038 <_Objects_Extend_information+0x1d8> 40008f28: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 (void*)(block_count * sizeof(uint32_t)), CPU_ALIGNMENT ); block_size = object_blocks_size + inactive_per_block_size + ((maximum + minimum_index) * sizeof(Objects_Control *)); if ( information->auto_extend ) { 40008f2c: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1 block_count++; 40008f30: b2 06 60 01 inc %i1 ((maximum + minimum_index) * sizeof(Objects_Control *)); 40008f34: 90 04 80 1a add %l2, %i2, %o0 if ( information->auto_extend ) { 40008f38: 80 a0 60 00 cmp %g1, 0 (void*)(block_count * sizeof(void*)), 40008f3c: b5 2e 60 02 sll %i1, 2, %i2 ((maximum + minimum_index) * sizeof(Objects_Control *)); 40008f40: 91 2a 20 02 sll %o0, 2, %o0 void *address, size_t alignment ) { uintptr_t mask = alignment - (uintptr_t)1; return (void*)(((uintptr_t)address + mask) & ~mask); 40008f44: b2 06 a0 07 add %i2, 7, %i1 40008f48: b2 0e 7f f8 and %i1, -8, %i1 block_size = object_blocks_size + inactive_per_block_size + 40008f4c: 83 2e 60 01 sll %i1, 1, %g1 if ( information->auto_extend ) { 40008f50: 12 80 00 69 bne 400090f4 <_Objects_Extend_information+0x294> 40008f54: 90 02 00 01 add %o0, %g1, %o0 if ( !object_blocks ) { _Workspace_Free( new_object_block ); return; } } else { object_blocks = _Workspace_Allocate_or_fatal_error( block_size ); 40008f58: 40 00 0d 2e call 4000c410 <_Workspace_Allocate_or_fatal_error> 40008f5c: 01 00 00 00 nop 40008f60: aa 10 00 08 mov %o0, %l5 * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 40008f64: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 return (void *)((uintptr_t)base + offset); 40008f68: a8 05 40 19 add %l5, %i1, %l4 40008f6c: b4 06 bf fc add %i2, -4, %i2 40008f70: 80 a0 40 12 cmp %g1, %l2 40008f74: 18 80 00 69 bgu 40009118 <_Objects_Extend_information+0x2b8> 40008f78: b2 06 40 14 add %i1, %l4, %i1 } else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 40008f7c: 80 a4 a0 00 cmp %l2, 0 40008f80: 22 80 00 0b be,a 40008fac <_Objects_Extend_information+0x14c> <== NEVER TAKEN 40008f84: c0 25 40 1a clr [ %l5 + %i2 ] <== NOT EXECUTED 40008f88: a5 2c a0 02 sll %l2, 2, %l2 40008f8c: 82 10 00 19 mov %i1, %g1 40008f90: a4 04 80 19 add %l2, %i1, %l2 local_table[ index ] = NULL; 40008f94: c0 20 40 00 clr [ %g1 ] 40008f98: 82 00 60 04 add %g1, 4, %g1 for ( index = 0; index < minimum_index; index++ ) { 40008f9c: 80 a4 80 01 cmp %l2, %g1 40008fa0: 32 bf ff fe bne,a 40008f98 <_Objects_Extend_information+0x138> <== NEVER TAKEN 40008fa4: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED } /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 40008fa8: c0 25 40 1a clr [ %l5 + %i2 ] inactive_per_block[block_count] = 0; for ( index = index_base ; index < index_end ; ++index ) { 40008fac: 80 a7 40 1b cmp %i5, %i3 40008fb0: 1a 80 00 0b bcc 40008fdc <_Objects_Extend_information+0x17c> <== NEVER TAKEN 40008fb4: c0 25 00 1a clr [ %l4 + %i2 ] 40008fb8: 83 2f 60 02 sll %i5, 2, %g1 40008fbc: 85 2e e0 02 sll %i3, 2, %g2 40008fc0: 82 00 40 19 add %g1, %i1, %g1 40008fc4: 84 00 80 19 add %g2, %i1, %g2 local_table[ index ] = NULL; 40008fc8: c0 20 40 00 clr [ %g1 ] 40008fcc: 82 00 60 04 add %g1, 4, %g1 for ( index = index_base ; index < index_end ; ++index ) { 40008fd0: 80 a0 80 01 cmp %g2, %g1 40008fd4: 32 bf ff fe bne,a 40008fcc <_Objects_Extend_information+0x16c> 40008fd8: c0 20 40 00 clr [ %g1 ] __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40008fdc: 91 d0 20 09 ta 9 <== NOT EXECUTED uint8_t node, uint16_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 40008fe0: 07 00 00 40 sethi %hi(0x10000), %g3 return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 40008fe4: c4 06 00 00 ld [ %i0 ], %g2 (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 40008fe8: c8 16 20 04 lduh [ %i0 + 4 ], %g4 old_tables = information->object_blocks; information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->local_table = local_table; information->maximum = (Objects_Maximum) maximum; 40008fec: a0 04 00 11 add %l0, %l1, %l0 old_tables = information->object_blocks; 40008ff0: d0 06 20 34 ld [ %i0 + 0x34 ], %o0 40008ff4: 89 29 20 1b sll %g4, 0x1b, %g4 return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 40008ff8: 85 28 a0 18 sll %g2, 0x18, %g2 information->object_blocks = object_blocks; 40008ffc: ea 26 20 34 st %l5, [ %i0 + 0x34 ] (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 40009000: 84 10 80 03 or %g2, %g3, %g2 information->inactive_per_block = inactive_per_block; 40009004: e8 26 20 30 st %l4, [ %i0 + 0x30 ] #if !defined(RTEMS_USE_16_BIT_OBJECT) (( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) | 40009008: 87 2c 20 10 sll %l0, 0x10, %g3 (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 4000900c: 84 10 80 04 or %g2, %g4, %g2 (( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) | 40009010: 87 30 e0 10 srl %g3, 0x10, %g3 information->local_table = local_table; 40009014: f2 26 20 1c st %i1, [ %i0 + 0x1c ] 40009018: 84 10 80 03 or %g2, %g3, %g2 information->maximum = (Objects_Maximum) maximum; 4000901c: e0 36 20 10 sth %l0, [ %i0 + 0x10 ] information->maximum_id = _Objects_Build_id( 40009020: c4 26 20 0c st %g2, [ %i0 + 0xc ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009024: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40009028: 01 00 00 00 nop information->maximum ); _ISR_lock_ISR_enable( &lock_context ); _Workspace_Free( old_tables ); 4000902c: 40 00 0c f3 call 4000c3f8 <_Workspace_Free> 40009030: 01 00 00 00 nop } /* * Assign the new object block to the object block table. */ information->object_blocks[ block ] = new_object_block; 40009034: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 40009038: b9 2f 20 02 sll %i4, 2, %i4 4000903c: e6 20 40 1c st %l3, [ %g1 + %i4 ] /* * Append to inactive chain. */ the_object = information->object_blocks[ block ]; for ( index = index_base ; index < index_end ; ++index ) { 40009040: 80 a7 40 1b cmp %i5, %i3 the_object = information->object_blocks[ block ]; 40009044: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 for ( index = index_base ; index < index_end ; ++index ) { 40009048: 1a 80 00 19 bcc 400090ac <_Objects_Extend_information+0x24c> <== NEVER TAKEN 4000904c: c2 00 40 1c ld [ %g1 + %i4 ], %g1 return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 40009050: c8 06 00 00 ld [ %i0 ], %g4 (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 40009054: c4 16 20 04 lduh [ %i0 + 4 ], %g2 _Chain_Initialize_node( &the_object->Node ); _Chain_Append_unprotected( &information->Inactive, &the_object->Node ); the_object = (Objects_Control *) ( (char *) the_object + information->size ); 40009058: de 06 20 18 ld [ %i0 + 0x18 ], %o7 return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 4000905c: 89 29 20 18 sll %g4, 0x18, %g4 (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 40009060: 85 28 a0 1b sll %g2, 0x1b, %g2 40009064: 07 00 00 40 sethi %hi(0x10000), %g3 (( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) | 40009068: 35 00 00 3f sethi %hi(0xfc00), %i2 (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 4000906c: 88 11 00 03 or %g4, %g3, %g4 40009070: b2 06 20 24 add %i0, 0x24, %i1 40009074: 88 11 00 02 or %g4, %g2, %g4 (( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) | 40009078: b4 16 a3 ff or %i2, 0x3ff, %i2 old_last = tail->previous; 4000907c: c6 06 20 28 ld [ %i0 + 0x28 ], %g3 40009080: 84 0f 40 1a and %i5, %i2, %g2 the_node->next = tail; 40009084: f2 20 40 00 st %i1, [ %g1 ] 40009088: 84 10 80 04 or %g2, %g4, %g2 the_object->id = _Objects_Build_id( 4000908c: c4 20 60 08 st %g2, [ %g1 + 8 ] for ( index = index_base ; index < index_end ; ++index ) { 40009090: ba 07 60 01 inc %i5 tail->previous = the_node; 40009094: c2 26 20 28 st %g1, [ %i0 + 0x28 ] 40009098: 80 a6 c0 1d cmp %i3, %i5 old_last->next = the_node; 4000909c: c2 20 c0 00 st %g1, [ %g3 ] the_node->previous = old_last; 400090a0: c6 20 60 04 st %g3, [ %g1 + 4 ] 400090a4: 12 bf ff f6 bne 4000907c <_Objects_Extend_information+0x21c> 400090a8: 82 00 40 0f add %g1, %o7, %g1 } information->inactive_per_block[ block ] = information->allocation_size; 400090ac: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2 400090b0: c6 06 20 30 ld [ %i0 + 0x30 ], %g3 information->inactive = (Objects_Maximum)(information->inactive + information->allocation_size); 400090b4: c2 16 20 2c lduh [ %i0 + 0x2c ], %g1 information->inactive_per_block[ block ] = information->allocation_size; 400090b8: c4 20 c0 1c st %g2, [ %g3 + %i4 ] (Objects_Maximum)(information->inactive + information->allocation_size); 400090bc: 82 00 40 02 add %g1, %g2, %g1 information->inactive = 400090c0: c2 36 20 2c sth %g1, [ %i0 + 0x2c ] } 400090c4: 81 c7 e0 08 ret 400090c8: 81 e8 00 00 restore 400090cc: ba 10 00 12 mov %l2, %i5 do_extend = true; 400090d0: a8 10 20 01 mov 1, %l4 block = 0; 400090d4: b8 10 20 00 clr %i4 block_count = 0; 400090d8: b2 10 20 00 clr %i1 400090dc: 10 bf ff 80 b 40008edc <_Objects_Extend_information+0x7c> 400090e0: b5 2c 20 10 sll %l0, 0x10, %i2 new_object_block = _Workspace_Allocate_or_fatal_error( block_size ); 400090e4: 40 00 0c cb call 4000c410 <_Workspace_Allocate_or_fatal_error> 400090e8: b6 07 40 1b add %i5, %i3, %i3 400090ec: 10 bf ff 8d b 40008f20 <_Objects_Extend_information+0xc0> 400090f0: a6 10 00 08 mov %o0, %l3 object_blocks = _Workspace_Allocate( block_size ); 400090f4: 40 00 0c b1 call 4000c3b8 <_Workspace_Allocate> 400090f8: 01 00 00 00 nop if ( !object_blocks ) { 400090fc: aa 92 20 00 orcc %o0, 0, %l5 40009100: 32 bf ff 9a bne,a 40008f68 <_Objects_Extend_information+0x108> <== ALWAYS TAKEN 40009104: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 _Workspace_Free( new_object_block ); 40009108: 40 00 0c bc call 4000c3f8 <_Workspace_Free> <== NOT EXECUTED 4000910c: 91 e8 00 13 restore %g0, %l3, %o0 <== NOT EXECUTED 40009110: 81 c7 e0 08 ret 40009114: 81 e8 00 00 restore memcpy( object_blocks, 40009118: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 4000911c: 94 10 00 1a mov %i2, %o2 40009120: 40 00 17 fc call 4000f110 40009124: 90 10 00 15 mov %l5, %o0 memcpy( inactive_per_block, 40009128: d2 06 20 30 ld [ %i0 + 0x30 ], %o1 4000912c: 94 10 00 1a mov %i2, %o2 40009130: 40 00 17 f8 call 4000f110 40009134: 90 10 00 14 mov %l4, %o0 (information->maximum + minimum_index) * sizeof(Objects_Control *) ); 40009138: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2 memcpy( local_table, 4000913c: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 (information->maximum + minimum_index) * sizeof(Objects_Control *) ); 40009140: 94 02 80 12 add %o2, %l2, %o2 memcpy( local_table, 40009144: 90 10 00 19 mov %i1, %o0 40009148: 40 00 17 f2 call 4000f110 4000914c: 95 2a a0 02 sll %o2, 2, %o2 40009150: 10 bf ff 97 b 40008fac <_Objects_Extend_information+0x14c> 40009154: c0 25 40 1a clr [ %l5 + %i2 ] for ( ; block < block_count; block++ ) { 40009158: ba 10 00 12 mov %l2, %i5 <== NOT EXECUTED do_extend = true; 4000915c: a8 10 20 01 mov 1, %l4 <== NOT EXECUTED block = 0; 40009160: 10 bf ff 5f b 40008edc <_Objects_Extend_information+0x7c> <== NOT EXECUTED 40009164: b8 10 20 00 clr %i4 <== NOT EXECUTED do_extend = false; 40009168: a8 10 20 00 clr %l4 <== NOT EXECUTED block = 0; 4000916c: 10 bf ff 5c b 40008edc <_Objects_Extend_information+0x7c> <== NOT EXECUTED 40009170: b8 10 20 00 clr %i4 <== NOT EXECUTED =============================================================================== 4000def0 <_Objects_Free>: old_last = tail->previous; 4000def0: c6 02 20 28 ld [ %o0 + 0x28 ], %g3 <== NOT EXECUTED void _Objects_Free( Objects_Information *information, Objects_Control *the_object ) { uint32_t allocation_size = information->allocation_size; 4000def4: c4 12 20 14 lduh [ %o0 + 0x14 ], %g2 return &the_chain->Tail.Node; 4000def8: 88 02 20 24 add %o0, 0x24, %g4 the_node->next = tail; 4000defc: c8 22 40 00 st %g4, [ %o1 ] tail->previous = the_node; 4000df00: d2 22 20 28 st %o1, [ %o0 + 0x28 ] old_last->next = the_node; 4000df04: d2 20 c0 00 st %o1, [ %g3 ] the_node->previous = old_last; 4000df08: c6 22 60 04 st %g3, [ %o1 + 4 ] _Assert( _Objects_Allocator_is_owner() ); _Chain_Append_unprotected( &information->Inactive, &the_object->Node ); if ( information->auto_extend ) { 4000df0c: c6 0a 20 12 ldub [ %o0 + 0x12 ], %g3 4000df10: 80 a0 e0 00 cmp %g3, 0 4000df14: 02 80 00 1e be 4000df8c <_Objects_Free+0x9c> <== ALWAYS TAKEN 4000df18: 09 00 00 3f sethi %hi(0xfc00), %g4 uint32_t block; block = (uint32_t) (_Objects_Get_index( the_object->id ) - 4000df1c: c6 02 60 08 ld [ %o1 + 8 ], %g3 _Objects_Get_index( information->minimum_id )); 4000df20: da 02 20 08 ld [ %o0 + 8 ], %o5 block /= information->allocation_size; information->inactive_per_block[ block ]++; 4000df24: d6 02 20 30 ld [ %o0 + 0x30 ], %o3 block = (uint32_t) (_Objects_Get_index( the_object->id ) - 4000df28: 88 11 23 ff or %g4, 0x3ff, %g4 4000df2c: 86 08 c0 04 and %g3, %g4, %g3 _Objects_Get_index( information->minimum_id )); 4000df30: 88 0b 40 04 and %o5, %g4, %g4 uint32_t allocation_size = information->allocation_size; 4000df34: 85 28 a0 10 sll %g2, 0x10, %g2 block = (uint32_t) (_Objects_Get_index( the_object->id ) - 4000df38: 86 20 c0 04 sub %g3, %g4, %g3 uint32_t allocation_size = information->allocation_size; 4000df3c: 99 30 a0 10 srl %g2, 0x10, %o4 block /= information->allocation_size; 4000df40: 81 80 20 00 wr %g0, %y 4000df44: 01 00 00 00 nop 4000df48: 01 00 00 00 nop 4000df4c: 01 00 00 00 nop 4000df50: 88 70 c0 0c udiv %g3, %o4, %g4 information->inactive_per_block[ block ]++; 4000df54: 89 29 20 02 sll %g4, 2, %g4 4000df58: da 02 c0 04 ld [ %o3 + %g4 ], %o5 information->inactive++; 4000df5c: c6 12 20 2c lduh [ %o0 + 0x2c ], %g3 information->inactive_per_block[ block ]++; 4000df60: 9a 03 60 01 inc %o5 4000df64: da 22 c0 04 st %o5, [ %o3 + %g4 ] information->inactive++; 4000df68: 86 00 e0 01 inc %g3 4000df6c: c6 32 20 2c sth %g3, [ %o0 + 0x2c ] /* * Check if the threshold level has been met of * 1.5 x allocation_size are free. */ if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) { 4000df70: 85 30 a0 11 srl %g2, 0x11, %g2 4000df74: 87 28 e0 10 sll %g3, 0x10, %g3 4000df78: 84 00 80 0c add %g2, %o4, %g2 4000df7c: 87 30 e0 10 srl %g3, 0x10, %g3 4000df80: 80 a0 c0 02 cmp %g3, %g2 4000df84: 18 80 00 04 bgu 4000df94 <_Objects_Free+0xa4> 4000df88: 01 00 00 00 nop _Objects_Shrink_information( information ); } } } 4000df8c: 81 c3 e0 08 retl 4000df90: 01 00 00 00 nop _Objects_Shrink_information( information ); 4000df94: 82 13 c0 00 mov %o7, %g1 4000df98: 40 00 00 47 call 4000e0b4 <_Objects_Shrink_information> 4000df9c: 9e 10 40 00 mov %g1, %o7 =============================================================================== 4000e02c <_Objects_Get>: const Objects_Information *information ) { uint32_t index; index = id - information->minimum_id + 1; 4000e02c: c4 02 a0 08 ld [ %o2 + 8 ], %g2 <== NOT EXECUTED if ( information->maximum >= index ) { 4000e030: c2 12 a0 10 lduh [ %o2 + 0x10 ], %g1 index = id - information->minimum_id + 1; 4000e034: 90 02 20 01 inc %o0 4000e038: 90 22 00 02 sub %o0, %g2, %o0 if ( information->maximum >= index ) { 4000e03c: 80 a0 40 08 cmp %g1, %o0 4000e040: 0a 80 00 0c bcs 4000e070 <_Objects_Get+0x44> <== NEVER TAKEN 4000e044: 01 00 00 00 nop __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000e048: 91 d0 20 09 ta 9 <== NOT EXECUTED Objects_Control *the_object; _ISR_lock_ISR_disable( lock_context ); 4000e04c: c2 22 40 00 st %g1, [ %o1 ] the_object = information->local_table[ index ]; 4000e050: c2 02 a0 1c ld [ %o2 + 0x1c ], %g1 4000e054: 91 2a 20 02 sll %o0, 2, %o0 4000e058: d0 00 40 08 ld [ %g1 + %o0 ], %o0 if ( the_object != NULL ) { 4000e05c: 80 a2 20 00 cmp %o0, 0 4000e060: 02 80 00 06 be 4000e078 <_Objects_Get+0x4c> 4000e064: 01 00 00 00 nop _ISR_lock_ISR_enable( lock_context ); } return NULL; } 4000e068: 81 c3 e0 08 retl 4000e06c: 01 00 00 00 nop 4000e070: 81 c3 e0 08 retl 4000e074: 90 10 20 00 clr %o0 ! 0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e078: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e07c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e080: 01 00 00 00 nop 4000e084: 81 c3 e0 08 retl 4000e088: 01 00 00 00 nop =============================================================================== 4000c05c <_Objects_Get_by_name>: const Objects_Information *information, const char *name, size_t *name_length_p, Objects_Get_by_name_error *error ) { 4000c05c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED uint32_t index; _Assert( information->is_string ); _Assert( _Objects_Allocator_is_owner() ); if ( name == NULL ) { 4000c060: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4000c064: 22 80 00 2e be,a 4000c11c <_Objects_Get_by_name+0xc0> <== NOT EXECUTED 4000c068: c0 26 c0 00 clr [ %i3 ] *error = OBJECTS_GET_BY_NAME_INVALID_NAME; return NULL; } name_length = strnlen( name, information->name_length + 1 ); 4000c06c: d2 16 20 3a lduh [ %i0 + 0x3a ], %o1 4000c070: 92 02 60 01 inc %o1 4000c074: 40 00 1c 31 call 40013138 4000c078: 90 10 00 19 mov %i1, %o0 max_name_length = information->name_length; 4000c07c: e0 16 20 3a lduh [ %i0 + 0x3a ], %l0 if ( name_length > max_name_length ) { 4000c080: 80 a2 00 10 cmp %o0, %l0 4000c084: 18 80 00 22 bgu 4000c10c <_Objects_Get_by_name+0xb0> 4000c088: 80 a6 a0 00 cmp %i2, 0 *error = OBJECTS_GET_BY_NAME_NAME_TOO_LONG; return NULL; } if ( name_length_p != NULL ) { 4000c08c: 32 80 00 02 bne,a 4000c094 <_Objects_Get_by_name+0x38> 4000c090: d0 26 80 00 st %o0, [ %i2 ] *name_length_p = name_length; } for ( index = 1; index <= information->maximum; index++ ) { 4000c094: f8 16 20 10 lduh [ %i0 + 0x10 ], %i4 4000c098: 80 a7 20 00 cmp %i4, 0 4000c09c: 02 80 00 18 be 4000c0fc <_Objects_Get_by_name+0xa0> 4000c0a0: 82 10 20 02 mov 2, %g1 Objects_Control *the_object; the_object = information->local_table[ index ]; 4000c0a4: f4 06 20 1c ld [ %i0 + 0x1c ], %i2 4000c0a8: b8 07 20 01 inc %i4 for ( index = 1; index <= information->maximum; index++ ) { 4000c0ac: ba 10 20 01 mov 1, %i5 the_object = information->local_table[ index ]; 4000c0b0: 83 2f 60 02 sll %i5, 2, %g1 4000c0b4: f0 06 80 01 ld [ %i2 + %g1 ], %i0 if ( the_object == NULL ) 4000c0b8: 80 a6 20 00 cmp %i0, 0 4000c0bc: 22 80 00 0c be,a 4000c0ec <_Objects_Get_by_name+0x90> 4000c0c0: ba 07 60 01 inc %i5 continue; if ( the_object->name.name_p == NULL ) 4000c0c4: d2 06 20 0c ld [ %i0 + 0xc ], %o1 4000c0c8: 80 a2 60 00 cmp %o1, 0 4000c0cc: 02 80 00 07 be 4000c0e8 <_Objects_Get_by_name+0x8c> 4000c0d0: 94 10 00 10 mov %l0, %o2 continue; if ( strncmp( name, the_object->name.name_p, max_name_length ) == 0 ) { 4000c0d4: 40 00 1b cf call 40013010 4000c0d8: 90 10 00 19 mov %i1, %o0 4000c0dc: 80 a2 20 00 cmp %o0, 0 4000c0e0: 02 80 00 09 be 4000c104 <_Objects_Get_by_name+0xa8> 4000c0e4: 01 00 00 00 nop for ( index = 1; index <= information->maximum; index++ ) { 4000c0e8: ba 07 60 01 inc %i5 4000c0ec: 80 a7 40 1c cmp %i5, %i4 4000c0f0: 12 bf ff f1 bne 4000c0b4 <_Objects_Get_by_name+0x58> 4000c0f4: 83 2f 60 02 sll %i5, 2, %g1 return the_object; } } *error = OBJECTS_GET_BY_NAME_NO_OBJECT; 4000c0f8: 82 10 20 02 mov 2, %g1 4000c0fc: c2 26 c0 00 st %g1, [ %i3 ] return NULL; 4000c100: b0 10 20 00 clr %i0 } 4000c104: 81 c7 e0 08 ret 4000c108: 81 e8 00 00 restore *error = OBJECTS_GET_BY_NAME_NAME_TOO_LONG; 4000c10c: 82 10 20 01 mov 1, %g1 4000c110: c2 26 c0 00 st %g1, [ %i3 ] return NULL; 4000c114: 81 c7 e0 08 ret 4000c118: 91 e8 20 00 restore %g0, 0, %o0 return NULL; 4000c11c: 81 c7 e0 08 ret 4000c120: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 4000dfb8 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 4000dfb8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 4000dfbc: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4000dfc0: 02 80 00 19 be 4000e024 <_Objects_Get_information+0x6c> <== NOT EXECUTED 4000dfc4: 01 00 00 00 nop /* * This call implicitly validates the_api so we do not call * _Objects_Is_api_valid above here. */ the_class_api_maximum = _Objects_API_maximum_class( the_api ); 4000dfc8: 40 00 02 c6 call 4000eae0 <_Objects_API_maximum_class> 4000dfcc: 90 10 00 18 mov %i0, %o0 if ( the_class_api_maximum == 0 ) 4000dfd0: 80 a2 20 00 cmp %o0, 0 4000dfd4: 02 80 00 14 be 4000e024 <_Objects_Get_information+0x6c> 4000dfd8: 80 a2 00 19 cmp %o0, %i1 return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 4000dfdc: 0a 80 00 12 bcs 4000e024 <_Objects_Get_information+0x6c> 4000dfe0: 03 10 00 66 sethi %hi(0x40019800), %g1 return NULL; if ( !_Objects_Information_table[ the_api ] ) 4000dfe4: b1 2e 20 02 sll %i0, 2, %i0 4000dfe8: 82 10 60 c0 or %g1, 0xc0, %g1 4000dfec: c2 00 40 18 ld [ %g1 + %i0 ], %g1 4000dff0: 80 a0 60 00 cmp %g1, 0 4000dff4: 02 80 00 0c be 4000e024 <_Objects_Get_information+0x6c> <== NEVER TAKEN 4000dff8: b3 2e 60 02 sll %i1, 2, %i1 return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 4000dffc: f0 00 40 19 ld [ %g1 + %i1 ], %i0 if ( !info ) 4000e000: 80 a6 20 00 cmp %i0, 0 4000e004: 02 80 00 08 be 4000e024 <_Objects_Get_information+0x6c> 4000e008: 01 00 00 00 nop * In a multprocessing configuration, we may access remote objects. * Thus we may have 0 local instances and still have a valid object * pointer. */ #if !defined(RTEMS_MULTIPROCESSING) if ( info->maximum == 0 ) 4000e00c: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 4000e010: 80 a0 60 00 cmp %g1, 0 4000e014: 02 80 00 04 be 4000e024 <_Objects_Get_information+0x6c> 4000e018: 01 00 00 00 nop return NULL; #endif return info; } 4000e01c: 81 c7 e0 08 ret 4000e020: 81 e8 00 00 restore return NULL; 4000e024: 81 c7 e0 08 ret 4000e028: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 4000dfa0 <_Objects_Get_information_id>: 4000dfa0: 83 32 20 18 srl %o0, 0x18, %g1 <== NOT EXECUTED Objects_Information *_Objects_Get_information_id( Objects_Id id ) { return _Objects_Get_information( 4000dfa4: 93 32 20 1b srl %o0, 0x1b, %o1 4000dfa8: 90 08 60 07 and %g1, 7, %o0 4000dfac: 82 13 c0 00 mov %o7, %g1 4000dfb0: 40 00 00 02 call 4000dfb8 <_Objects_Get_information> 4000dfb4: 9e 10 40 00 mov %g1, %o7 =============================================================================== 4001295c <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 4001295c: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Objects_Id tmpId; if ( length == 0 ) return NULL; if ( name == NULL ) 40012960: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 40012964: 02 80 00 1e be 400129dc <_Objects_Get_name_as_string+0x80> <== NOT EXECUTED 40012968: 80 a6 a0 00 cmp %i2, 0 4001296c: 02 80 00 1c be 400129dc <_Objects_Get_name_as_string+0x80> 40012970: 80 a6 20 00 cmp %i0, 0 return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id; 40012974: 22 80 00 18 be,a 400129d4 <_Objects_Get_name_as_string+0x78> 40012978: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1 information = _Objects_Get_information_id( tmpId ); 4001297c: 7f ff e8 24 call 4000ca0c <_Objects_Get_information_id> 40012980: 90 10 00 18 mov %i0, %o0 if ( !information ) 40012984: ba 92 20 00 orcc %o0, 0, %i5 40012988: 02 80 00 15 be 400129dc <_Objects_Get_name_as_string+0x80> 4001298c: 94 10 00 1d mov %i5, %o2 return NULL; the_object = _Objects_Get( tmpId, &lock_context, information ); 40012990: 92 07 bf fc add %fp, -4, %o1 40012994: 7f ff e8 41 call 4000ca98 <_Objects_Get> 40012998: 90 10 00 18 mov %i0, %o0 if ( the_object == NULL ) { 4001299c: 80 a2 20 00 cmp %o0, 0 400129a0: 02 80 00 0f be 400129dc <_Objects_Get_name_as_string+0x80> 400129a4: 96 10 00 19 mov %i1, %o3 return NULL; } _Objects_Name_to_string( 400129a8: c2 02 20 0c ld [ %o0 + 0xc ], %g1 400129ac: d2 0f 60 38 ldub [ %i5 + 0x38 ], %o1 400129b0: c2 27 bf f4 st %g1, [ %fp + -12 ] 400129b4: 94 10 00 1a mov %i2, %o2 400129b8: 7f ff ff be call 400128b0 <_Objects_Name_to_string> 400129bc: 90 07 bf f4 add %fp, -12, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400129c0: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400129c4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400129c8: 01 00 00 00 nop length ); _ISR_lock_ISR_enable( &lock_context ); return name; } 400129cc: 81 c7 e0 08 ret 400129d0: 91 e8 00 1a restore %g0, %i2, %o0 400129d4: 10 bf ff ea b 4001297c <_Objects_Get_name_as_string+0x20> 400129d8: f0 00 60 08 ld [ %g1 + 8 ], %i0 return NULL; 400129dc: 81 c7 e0 08 ret 400129e0: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 4000bfc4 <_Objects_Get_next>: Objects_Control *_Objects_Get_next( Objects_Id id, const Objects_Information *information, Objects_Id *next_id_p ) { 4000bfc4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Objects_Id next_id; if ( !information ) return NULL; if ( !next_id_p ) 4000bfc8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4000bfcc: 02 80 00 20 be 4000c04c <_Objects_Get_next+0x88> <== NOT EXECUTED 4000bfd0: 80 a6 a0 00 cmp %i2, 0 4000bfd4: 02 80 00 1e be 4000c04c <_Objects_Get_next+0x88> 4000bfd8: 83 2e 20 10 sll %i0, 0x10, %g1 return NULL; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) 4000bfdc: 80 a0 60 00 cmp %g1, 0 4000bfe0: 22 80 00 02 be,a 4000bfe8 <_Objects_Get_next+0x24> 4000bfe4: f0 06 60 08 ld [ %i1 + 8 ], %i0 _RTEMS_Lock_allocator(); 4000bfe8: 7f ff f6 d0 call 40009b28 <_RTEMS_Lock_allocator> 4000bfec: 01 00 00 00 nop _Objects_Allocator_lock(); do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 4000bff0: 10 80 00 08 b 4000c010 <_Objects_Get_next+0x4c> 4000bff4: c4 16 60 10 lduh [ %i1 + 0x10 ], %g2 *next_id_p = OBJECTS_ID_FINAL; return NULL; } /* try to grab one */ the_object = _Objects_Get_no_protection( next_id, information ); 4000bff8: 40 00 00 17 call 4000c054 <_Objects_Get_no_protection> 4000bffc: b0 06 20 01 inc %i0 next_id++; } while ( the_object == NULL ); 4000c000: 80 a2 20 00 cmp %o0, 0 4000c004: 32 80 00 10 bne,a 4000c044 <_Objects_Get_next+0x80> 4000c008: f0 26 80 00 st %i0, [ %i2 ] if (_Objects_Get_index(next_id) > information->maximum) 4000c00c: c4 16 60 10 lduh [ %i1 + 0x10 ], %g2 4000c010: 83 2e 20 10 sll %i0, 0x10, %g1 the_object = _Objects_Get_no_protection( next_id, information ); 4000c014: 90 10 00 18 mov %i0, %o0 if (_Objects_Get_index(next_id) > information->maximum) 4000c018: 83 30 60 10 srl %g1, 0x10, %g1 4000c01c: 80 a0 80 01 cmp %g2, %g1 4000c020: 1a bf ff f6 bcc 4000bff8 <_Objects_Get_next+0x34> 4000c024: 92 10 00 19 mov %i1, %o1 _RTEMS_Unlock_allocator(); 4000c028: 7f ff f6 c5 call 40009b3c <_RTEMS_Unlock_allocator> 4000c02c: 01 00 00 00 nop *next_id_p = OBJECTS_ID_FINAL; 4000c030: 82 10 3f ff mov -1, %g1 ! ffffffff 4000c034: c2 26 80 00 st %g1, [ %i2 ] return NULL; 4000c038: 90 10 20 00 clr %o0 *next_id_p = next_id; return the_object; } 4000c03c: 81 c7 e0 08 ret 4000c040: 91 e8 00 08 restore %g0, %o0, %o0 4000c044: 81 c7 e0 08 ret 4000c048: 91 e8 00 08 restore %g0, %o0, %o0 return NULL; 4000c04c: 10 bf ff fc b 4000c03c <_Objects_Get_next+0x78> 4000c050: 90 10 20 00 clr %o0 =============================================================================== 40009174 <_Objects_Get_no_protection>: /* * You can't just extract the index portion or you can get tricked * by a value between 1 and maximum. */ index = id - information->minimum_id + 1; 40009174: c4 02 60 08 ld [ %o1 + 8 ], %g2 <== NOT EXECUTED if ( information->maximum >= index ) { 40009178: c2 12 60 10 lduh [ %o1 + 0x10 ], %g1 <== NOT EXECUTED index = id - information->minimum_id + 1; 4000917c: 90 02 20 01 inc %o0 <== NOT EXECUTED 40009180: 90 22 00 02 sub %o0, %g2, %o0 if ( information->maximum >= index ) { 40009184: 80 a0 40 08 cmp %g1, %o0 40009188: 0a 80 00 06 bcs 400091a0 <_Objects_Get_no_protection+0x2c> <== NEVER TAKEN 4000918c: 01 00 00 00 nop if ( (the_object = information->local_table[ index ]) != NULL ) { 40009190: c2 02 60 1c ld [ %o1 + 0x1c ], %g1 40009194: 91 2a 20 02 sll %o0, 2, %o0 40009198: 81 c3 e0 08 retl 4000919c: d0 00 40 08 ld [ %g1 + %o0 ], %o0 /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ return NULL; } 400091a0: 81 c3 e0 08 retl 400091a4: 90 10 20 00 clr %o0 =============================================================================== 4000cb2c <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 4000cb2c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id; 4000cb30: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 4000cb34: 12 80 00 04 bne 4000cb44 <_Objects_Id_to_name+0x18> <== NOT EXECUTED 4000cb38: 01 00 00 00 nop 4000cb3c: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1 4000cb40: f0 00 60 08 ld [ %g1 + 8 ], %i0 information = _Objects_Get_information_id( tmpId ); 4000cb44: 7f ff ff b2 call 4000ca0c <_Objects_Get_information_id> 4000cb48: 90 10 00 18 mov %i0, %o0 if ( !information ) 4000cb4c: 80 a2 20 00 cmp %o0, 0 4000cb50: 02 80 00 13 be 4000cb9c <_Objects_Id_to_name+0x70> 4000cb54: 01 00 00 00 nop return OBJECTS_INVALID_ID; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) 4000cb58: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1 4000cb5c: 80 a0 60 00 cmp %g1, 0 4000cb60: 12 80 00 0f bne 4000cb9c <_Objects_Id_to_name+0x70> <== NEVER TAKEN 4000cb64: 94 10 00 08 mov %o0, %o2 return OBJECTS_INVALID_ID; #endif the_object = _Objects_Get( 4000cb68: 92 07 bf fc add %fp, -4, %o1 4000cb6c: 7f ff ff cb call 4000ca98 <_Objects_Get> 4000cb70: 90 10 00 18 mov %i0, %o0 tmpId, &lock_context, information ); if ( !the_object ) 4000cb74: 80 a2 20 00 cmp %o0, 0 4000cb78: 02 80 00 09 be 4000cb9c <_Objects_Id_to_name+0x70> 4000cb7c: 01 00 00 00 nop return OBJECTS_INVALID_ID; *name = the_object->name; 4000cb80: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED 4000cb84: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000cb88: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000cb8c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000cb90: 01 00 00 00 nop _ISR_lock_ISR_enable( &lock_context ); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 4000cb94: 81 c7 e0 08 ret 4000cb98: 91 e8 20 00 restore %g0, 0, %o0 return OBJECTS_INVALID_ID; 4000cb9c: 81 c7 e0 08 ret 4000cba0: 91 e8 20 03 restore %g0, 3, %o0 =============================================================================== 400131bc <_Objects_Name_to_id_u32>: Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == false */ if ( !id ) 400131bc: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED 400131c0: 02 80 00 21 be 40013244 <_Objects_Name_to_id_u32+0x88> <== NOT EXECUTED 400131c4: 80 a2 60 00 cmp %o1, 0 return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 400131c8: 02 80 00 1d be 4001323c <_Objects_Name_to_id_u32+0x80> 400131cc: 82 10 20 01 mov 1, %g1 search_local_node = false; if ( information->maximum != 0 && (node == OBJECTS_SEARCH_ALL_NODES || node == OBJECTS_SEARCH_LOCAL_NODE || 400131d0: 05 20 00 00 sethi %hi(0x80000000), %g2 400131d4: 84 38 80 0a xnor %g2, %o2, %g2 400131d8: 80 a0 a0 00 cmp %g2, 0 400131dc: 02 80 00 05 be 400131f0 <_Objects_Name_to_id_u32+0x34> 400131e0: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 400131e4: 80 a2 a0 01 cmp %o2, 1 400131e8: 18 80 00 15 bgu 4001323c <_Objects_Name_to_id_u32+0x80> 400131ec: 01 00 00 00 nop _Objects_Is_local_node( node ) )) search_local_node = true; if ( search_local_node ) { for ( index = 1; index <= information->maximum; index++ ) { 400131f0: 80 a0 e0 00 cmp %g3, 0 400131f4: 02 80 00 11 be 40013238 <_Objects_Name_to_id_u32+0x7c> 400131f8: 82 10 20 01 mov 1, %g1 the_object = information->local_table[ index ]; 400131fc: da 02 20 1c ld [ %o0 + 0x1c ], %o5 40013200: 86 00 e0 01 inc %g3 40013204: 85 28 60 02 sll %g1, 2, %g2 40013208: c4 03 40 02 ld [ %o5 + %g2 ], %g2 if ( !the_object ) 4001320c: 80 a0 a0 00 cmp %g2, 0 40013210: 22 80 00 07 be,a 4001322c <_Objects_Name_to_id_u32+0x70> 40013214: 82 00 60 01 inc %g1 continue; if ( name == the_object->name.name_u32 ) { 40013218: c8 00 a0 0c ld [ %g2 + 0xc ], %g4 4001321c: 80 a1 00 09 cmp %g4, %o1 40013220: 22 80 00 0c be,a 40013250 <_Objects_Name_to_id_u32+0x94> 40013224: c2 00 a0 08 ld [ %g2 + 8 ], %g1 for ( index = 1; index <= information->maximum; index++ ) { 40013228: 82 00 60 01 inc %g1 4001322c: 80 a0 c0 01 cmp %g3, %g1 40013230: 32 bf ff f6 bne,a 40013208 <_Objects_Name_to_id_u32+0x4c> 40013234: 85 28 60 02 sll %g1, 2, %g2 return OBJECTS_INVALID_NAME; 40013238: 82 10 20 01 mov 1, %g1 name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 4001323c: 81 c3 e0 08 retl 40013240: 90 10 00 01 mov %g1, %o0 return OBJECTS_INVALID_ADDRESS; 40013244: 82 10 20 02 mov 2, %g1 } 40013248: 81 c3 e0 08 retl 4001324c: 90 10 00 01 mov %g1, %o0 *id = the_object->id; 40013250: c2 22 c0 00 st %g1, [ %o3 ] return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 40013254: 10 bf ff fa b 4001323c <_Objects_Name_to_id_u32+0x80> 40013258: 82 10 20 00 clr %g1 =============================================================================== 400128b0 <_Objects_Name_to_string>: Objects_Name name, bool is_string, char *buffer, size_t buffer_size ) { 400128b0: 9c 03 bf b0 add %sp, -80, %sp <== NOT EXECUTED const char *s; char *d; size_t i; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( is_string ) { 400128b4: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED 400128b8: 12 80 00 20 bne 40012938 <_Objects_Name_to_string+0x88> <== NOT EXECUTED 400128bc: c2 02 00 00 ld [ %o0 ], %g1 s = name.name_p; } else #endif { lname[ 0 ] = (name.name_u32 >> 24) & 0xff; 400128c0: 85 30 60 18 srl %g1, 0x18, %g2 lname[ 1 ] = (name.name_u32 >> 16) & 0xff; 400128c4: 89 30 60 10 srl %g1, 0x10, %g4 lname[ 2 ] = (name.name_u32 >> 8) & 0xff; 400128c8: 87 30 60 08 srl %g1, 8, %g3 lname[ 0 ] = (name.name_u32 >> 24) & 0xff; 400128cc: c4 2b a0 48 stb %g2, [ %sp + 0x48 ] lname[ 1 ] = (name.name_u32 >> 16) & 0xff; 400128d0: c8 2b a0 49 stb %g4, [ %sp + 0x49 ] lname[ 2 ] = (name.name_u32 >> 8) & 0xff; 400128d4: c6 2b a0 4a stb %g3, [ %sp + 0x4a ] lname[ 3 ] = (name.name_u32 >> 0) & 0xff; lname[ 4 ] = '\0'; 400128d8: c0 2b a0 4c clrb [ %sp + 0x4c ] lname[ 3 ] = (name.name_u32 >> 0) & 0xff; 400128dc: c2 2b a0 4b stb %g1, [ %sp + 0x4b ] s = lname; 400128e0: 82 03 a0 48 add %sp, 0x48, %g1 d = buffer; i = 1; if ( s != NULL ) { while ( *s != '\0' ) { 400128e4: 87 28 a0 18 sll %g2, 0x18, %g3 400128e8: 80 a0 e0 00 cmp %g3, 0 400128ec: 02 80 00 16 be 40012944 <_Objects_Name_to_string+0x94> <== NEVER TAKEN 400128f0: 90 10 20 01 mov 1, %o0 if ( i < buffer_size ) { 400128f4: 80 a2 c0 08 cmp %o3, %o0 400128f8: 08 80 00 09 bleu 4001291c <_Objects_Name_to_string+0x6c> 400128fc: 82 00 60 01 inc %g1 return uc >= ' ' && uc <= '~'; 40012900: 86 00 bf e0 add %g2, -32, %g3 *d = _Objects_Name_char_is_printable(*s) ? *s : '*'; 40012904: 86 08 e0 ff and %g3, 0xff, %g3 40012908: 80 a0 e0 5e cmp %g3, 0x5e 4001290c: 38 80 00 02 bgu,a 40012914 <_Objects_Name_to_string+0x64> 40012910: 84 10 20 2a mov 0x2a, %g2 40012914: c4 2a 80 00 stb %g2, [ %o2 ] ++d; 40012918: 94 02 a0 01 inc %o2 while ( *s != '\0' ) { 4001291c: c6 48 40 00 ldsb [ %g1 ], %g3 } ++s; ++i; 40012920: 88 02 20 01 add %o0, 1, %g4 while ( *s != '\0' ) { 40012924: 80 a0 e0 00 cmp %g3, 0 40012928: 02 80 00 08 be 40012948 <_Objects_Name_to_string+0x98> 4001292c: c4 08 40 00 ldub [ %g1 ], %g2 ++i; 40012930: 10 bf ff f1 b 400128f4 <_Objects_Name_to_string+0x44> 40012934: 90 10 00 04 mov %g4, %o0 if ( s != NULL ) { 40012938: 80 a0 60 00 cmp %g1, 0 4001293c: 32 bf ff ea bne,a 400128e4 <_Objects_Name_to_string+0x34> 40012940: c4 08 40 00 ldub [ %g1 ], %g2 *d = _Objects_Name_char_is_printable(*s) ? *s : '*'; 40012944: 90 10 20 00 clr %o0 } } if ( buffer_size > 0 ) { 40012948: 80 a2 e0 00 cmp %o3, 0 4001294c: 32 80 00 02 bne,a 40012954 <_Objects_Name_to_string+0xa4> 40012950: c0 2a 80 00 clrb [ %o2 ] *d = '\0'; } return i - 1; } 40012954: 81 c3 e0 08 retl 40012958: 9c 03 a0 50 add %sp, 0x50, %sp =============================================================================== 4000e08c <_Objects_Namespace_remove>: void _Objects_Namespace_remove( Objects_Information *information, Objects_Control *the_object ) { 4000e08c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) /* * If this is a string format name, then free the memory. */ if ( information->is_string ) 4000e090: c2 0e 20 38 ldub [ %i0 + 0x38 ], %g1 <== NOT EXECUTED 4000e094: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000e098: 22 80 00 05 be,a 4000e0ac <_Objects_Namespace_remove+0x20> <== NOT EXECUTED 4000e09c: c0 26 60 0c clr [ %i1 + 0xc ] _Workspace_Free( (void *)the_object->name.name_p ); 4000e0a0: 7f ff f8 d6 call 4000c3f8 <_Workspace_Free> 4000e0a4: d0 06 60 0c ld [ %i1 + 0xc ], %o0 /* * Clear out either format. */ #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) the_object->name.name_p = NULL; 4000e0a8: c0 26 60 0c clr [ %i1 + 0xc ] #endif the_object->name.name_u32 = 0; } 4000e0ac: 81 c7 e0 08 ret 4000e0b0: 81 e8 00 00 restore =============================================================================== 40008c54 <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 40008c54: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED size_t length; const char *s; s = name; length = strnlen( name, information->name_length ); 40008c58: d2 16 20 3a lduh [ %i0 + 0x3a ], %o1 <== NOT EXECUTED 40008c5c: 40 00 1a 73 call 4000f628 <== NOT EXECUTED 40008c60: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) { 40008c64: f0 0e 20 38 ldub [ %i0 + 0x38 ], %i0 40008c68: 80 a6 20 00 cmp %i0, 0 40008c6c: 12 80 00 19 bne 40008cd0 <_Objects_Set_name+0x7c> 40008c70: ba 10 00 08 mov %o0, %i5 40008c74: 03 08 08 08 sethi %hi(0x20202000), %g1 d[length] = '\0'; the_object->name.name_p = d; } else #endif { the_object->name.name_u32 = _Objects_Build_name( 40008c78: 80 a2 20 00 cmp %o0, 0 40008c7c: 02 80 00 12 be 40008cc4 <_Objects_Set_name+0x70> 40008c80: 82 10 60 20 or %g1, 0x20, %g1 40008c84: c2 4e 80 00 ldsb [ %i2 ], %g1 40008c88: 80 a2 20 01 cmp %o0, 1 40008c8c: 08 80 00 29 bleu 40008d30 <_Objects_Set_name+0xdc> 40008c90: 85 28 60 18 sll %g1, 0x18, %g2 40008c94: c2 4e a0 01 ldsb [ %i2 + 1 ], %g1 40008c98: 83 28 60 10 sll %g1, 0x10, %g1 40008c9c: 80 a2 20 02 cmp %o0, 2 40008ca0: 02 80 00 1e be 40008d18 <_Objects_Set_name+0xc4> 40008ca4: 84 10 40 02 or %g1, %g2, %g2 40008ca8: c2 4e a0 02 ldsb [ %i2 + 2 ], %g1 40008cac: 83 28 60 08 sll %g1, 8, %g1 40008cb0: 80 a2 20 03 cmp %o0, 3 40008cb4: 02 80 00 1d be 40008d28 <_Objects_Set_name+0xd4> 40008cb8: 82 10 40 02 or %g1, %g2, %g1 40008cbc: c4 4e a0 03 ldsb [ %i2 + 3 ], %g2 40008cc0: 82 10 80 01 or %g2, %g1, %g1 40008cc4: c2 26 60 0c st %g1, [ %i1 + 0xc ] 40008cc8: 81 c7 e0 08 ret 40008ccc: 91 e8 20 01 restore %g0, 1, %o0 d = _Workspace_Allocate( length + 1 ); 40008cd0: 40 00 0c 79 call 4000beb4 <_Workspace_Allocate> 40008cd4: 90 02 20 01 inc %o0 if ( !d ) 40008cd8: b8 92 20 00 orcc %o0, 0, %i4 40008cdc: 02 80 00 0d be 40008d10 <_Objects_Set_name+0xbc> 40008ce0: 01 00 00 00 nop _Workspace_Free( (void *)the_object->name.name_p ); 40008ce4: 40 00 0c 84 call 4000bef4 <_Workspace_Free> 40008ce8: d0 06 60 0c ld [ %i1 + 0xc ], %o0 the_object->name.name_p = NULL; 40008cec: c0 26 60 0c clr [ %i1 + 0xc ] strncpy( d, name, length ); 40008cf0: 94 10 00 1d mov %i5, %o2 40008cf4: 92 10 00 1a mov %i2, %o1 40008cf8: 40 00 1a 08 call 4000f518 40008cfc: 90 10 00 1c mov %i4, %o0 d[length] = '\0'; 40008d00: c0 2f 00 1d clrb [ %i4 + %i5 ] the_object->name.name_p = d; 40008d04: f8 26 60 0c st %i4, [ %i1 + 0xc ] 40008d08: 81 c7 e0 08 ret 40008d0c: 81 e8 00 00 restore ); } return true; } 40008d10: 81 c7 e0 08 ret 40008d14: 91 e8 20 00 restore %g0, 0, %o0 40008d18: 07 00 00 08 sethi %hi(0x2000), %g3 40008d1c: 86 10 e0 20 or %g3, 0x20, %g3 ! 2020 <_Configuration_Interrupt_stack_size+0x1020> 40008d20: 10 bf ff e9 b 40008cc4 <_Objects_Set_name+0x70> 40008d24: 82 10 80 03 or %g2, %g3, %g1 40008d28: 10 bf ff e7 b 40008cc4 <_Objects_Set_name+0x70> 40008d2c: 82 10 60 20 or %g1, 0x20, %g1 40008d30: 03 00 08 08 sethi %hi(0x202000), %g1 40008d34: 82 10 60 20 or %g1, 0x20, %g1 ! 202020 40008d38: 10 bf ff e3 b 40008cc4 <_Objects_Set_name+0x70> 40008d3c: 82 10 80 01 or %g2, %g1, %g1 =============================================================================== 4000e0b4 <_Objects_Shrink_information>: #include void _Objects_Shrink_information( Objects_Information *information ) { 4000e0b4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 4000e0b8: c6 16 20 0a lduh [ %i0 + 0xa ], %g3 <== NOT EXECUTED * Search the list to find block or chunk with all objects inactive. */ index_base = _Objects_Get_index( information->minimum_id ); block_count = (information->maximum - index_base) / information->allocation_size; 4000e0bc: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2 <== NOT EXECUTED block_count = (information->maximum - index_base) / 4000e0c0: c8 16 20 10 lduh [ %i0 + 0x10 ], %g4 <== NOT EXECUTED 4000e0c4: 88 21 00 03 sub %g4, %g3, %g4 <== NOT EXECUTED for ( block = 0; block < block_count; block++ ) { 4000e0c8: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 4000e0cc: 01 00 00 00 nop <== NOT EXECUTED 4000e0d0: 01 00 00 00 nop <== NOT EXECUTED 4000e0d4: 01 00 00 00 nop <== NOT EXECUTED 4000e0d8: 88 f1 00 02 udivcc %g4, %g2, %g4 <== NOT EXECUTED 4000e0dc: 02 80 00 35 be 4000e1b0 <_Objects_Shrink_information+0xfc> <== NOT EXECUTED 4000e0e0: 01 00 00 00 nop if ( information->inactive_per_block[ block ] == 4000e0e4: f4 06 20 30 ld [ %i0 + 0x30 ], %i2 4000e0e8: c2 06 80 00 ld [ %i2 ], %g1 4000e0ec: 80 a0 80 01 cmp %g2, %g1 4000e0f0: 02 80 00 0f be 4000e12c <_Objects_Shrink_information+0x78> <== NEVER TAKEN 4000e0f4: ba 10 20 04 mov 4, %i5 for ( block = 0; block < block_count; block++ ) { 4000e0f8: 10 80 00 07 b 4000e114 <_Objects_Shrink_information+0x60> 4000e0fc: 82 10 20 00 clr %g1 if ( information->inactive_per_block[ block ] == 4000e100: f8 06 80 1d ld [ %i2 + %i5 ], %i4 4000e104: 80 a0 80 1c cmp %g2, %i4 4000e108: 02 80 00 0a be 4000e130 <_Objects_Shrink_information+0x7c> 4000e10c: b6 07 60 04 add %i5, 4, %i3 4000e110: ba 10 00 1b mov %i3, %i5 for ( block = 0; block < block_count; block++ ) { 4000e114: 82 00 60 01 inc %g1 4000e118: 80 a1 00 01 cmp %g4, %g1 4000e11c: 12 bf ff f9 bne 4000e100 <_Objects_Shrink_information+0x4c> 4000e120: 86 00 c0 02 add %g3, %g2, %g3 return; } index_base += information->allocation_size; } } 4000e124: 81 c7 e0 08 ret 4000e128: 81 e8 00 00 restore if ( information->inactive_per_block[ block ] == 4000e12c: ba 10 20 00 clr %i5 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 4000e130: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 return &the_chain->Tail.Node; 4000e134: b4 06 20 24 add %i0, 0x24, %i2 while ( node != tail ) { 4000e138: 80 a0 40 1a cmp %g1, %i2 4000e13c: 02 80 00 12 be 4000e184 <_Objects_Shrink_information+0xd0> <== NEVER TAKEN 4000e140: 84 00 80 03 add %g2, %g3, %g2 4000e144: 37 00 00 3f sethi %hi(0xfc00), %i3 4000e148: b6 16 e3 ff or %i3, 0x3ff, %i3 ! ffff <_Configuration_Interrupt_stack_size+0xefff> 4000e14c: c8 00 60 08 ld [ %g1 + 8 ], %g4 4000e150: 88 09 00 1b and %g4, %i3, %g4 if ( index >= index_base && index < index_end ) { 4000e154: 80 a1 00 03 cmp %g4, %g3 4000e158: 0a 80 00 08 bcs 4000e178 <_Objects_Shrink_information+0xc4> 4000e15c: f8 00 40 00 ld [ %g1 ], %i4 4000e160: 80 a1 00 02 cmp %g4, %g2 4000e164: 1a 80 00 06 bcc 4000e17c <_Objects_Shrink_information+0xc8> 4000e168: 80 a6 80 1c cmp %i2, %i4 previous = the_node->previous; 4000e16c: c2 00 60 04 ld [ %g1 + 4 ], %g1 next->previous = previous; 4000e170: c2 27 20 04 st %g1, [ %i4 + 4 ] previous->next = next; 4000e174: f8 20 40 00 st %i4, [ %g1 ] while ( node != tail ) { 4000e178: 80 a6 80 1c cmp %i2, %i4 4000e17c: 12 bf ff f4 bne 4000e14c <_Objects_Shrink_information+0x98> 4000e180: 82 10 00 1c mov %i4, %g1 _Workspace_Free( information->object_blocks[ block ] ); 4000e184: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 4000e188: 7f ff f8 9c call 4000c3f8 <_Workspace_Free> 4000e18c: d0 00 40 1d ld [ %g1 + %i5 ], %o0 information->object_blocks[ block ] = NULL; 4000e190: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 4000e194: c0 20 40 1d clr [ %g1 + %i5 ] information->inactive_per_block[ block ] = 0; 4000e198: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 information->inactive -= information->allocation_size; 4000e19c: c2 16 20 2c lduh [ %i0 + 0x2c ], %g1 information->inactive_per_block[ block ] = 0; 4000e1a0: c0 20 80 1d clr [ %g2 + %i5 ] information->inactive -= information->allocation_size; 4000e1a4: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2 4000e1a8: 82 20 40 02 sub %g1, %g2, %g1 4000e1ac: c2 36 20 2c sth %g1, [ %i0 + 0x2c ] return; 4000e1b0: 81 c7 e0 08 ret 4000e1b4: 81 e8 00 00 restore =============================================================================== 40009280 <_Once>: #define ONCE_STATE_NOT_RUN 0 #define ONCE_STATE_RUNNING 1 #define ONCE_STATE_COMPLETE 2 int _Once( unsigned char *once_state, void ( *init_routine )( void ) ) { 40009280: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED int eno = 0; if ( *once_state != ONCE_STATE_COMPLETE ) { 40009284: c2 0e 00 00 ldub [ %i0 ], %g1 <== NOT EXECUTED 40009288: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000928c: 02 80 00 0e be 400092c4 <_Once+0x44> <== NOT EXECUTED 40009290: ba 10 20 00 clr %i5 static API_Mutex_Control _Once_Mutex = API_MUTEX_INITIALIZER( "_Once" ); void _Once_Lock( void ) { _API_Mutex_Lock( &_Once_Mutex ); 40009294: 39 10 00 6d sethi %hi(0x4001b400), %i4 40009298: 7f ff f7 7b call 40007084 <_API_Mutex_Lock> 4000929c: 90 17 21 b0 or %i4, 0x1b0, %o0 ! 4001b5b0 <_Once_Mutex> switch ( *once_state ) { 400092a0: c2 0e 00 00 ldub [ %i0 ], %g1 400092a4: 80 a0 60 00 cmp %g1, 0 400092a8: 02 80 00 09 be 400092cc <_Once+0x4c> 400092ac: 82 18 60 01 xor %g1, 1, %g1 int eno = 0; 400092b0: 80 a0 00 01 cmp %g0, %g1 400092b4: ba 40 3f ff addx %g0, -1, %i5 400092b8: ba 0f 60 16 and %i5, 0x16, %i5 } void _Once_Unlock( void ) { _API_Mutex_Unlock( &_Once_Mutex ); 400092bc: 7f ff f7 7e call 400070b4 <_API_Mutex_Unlock> 400092c0: 90 17 21 b0 or %i4, 0x1b0, %o0 } 400092c4: 81 c7 e0 08 ret 400092c8: 91 e8 00 1d restore %g0, %i5, %o0 *once_state = ONCE_STATE_RUNNING; 400092cc: 82 10 20 01 mov 1, %g1 ( *init_routine )(); 400092d0: 9f c6 40 00 call %i1 400092d4: c2 2e 00 00 stb %g1, [ %i0 ] *once_state = ONCE_STATE_COMPLETE; 400092d8: 82 10 20 02 mov 2, %g1 break; 400092dc: 10 bf ff f8 b 400092bc <_Once+0x3c> 400092e0: c2 2e 00 00 stb %g1, [ %i0 ] =============================================================================== 4000a32c <_Once_Lock>: static API_Mutex_Control _Once_Mutex = API_MUTEX_INITIALIZER( "_Once" ); void _Once_Lock( void ) { _API_Mutex_Lock( &_Once_Mutex ); 4000a32c: 11 10 00 4f sethi %hi(0x40013c00), %o0 <== NOT EXECUTED 4000a330: 90 12 20 c0 or %o0, 0xc0, %o0 ! 40013cc0 <_Once_Mutex> <== NOT EXECUTED 4000a334: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4000a338: 7f ff f6 2c call 40007be8 <_API_Mutex_Lock> <== NOT EXECUTED 4000a33c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 4000a340 <_Once_Unlock>: } void _Once_Unlock( void ) { _API_Mutex_Unlock( &_Once_Mutex ); 4000a340: 11 10 00 4f sethi %hi(0x40013c00), %o0 <== NOT EXECUTED 4000a344: 90 12 20 c0 or %o0, 0xc0, %o0 ! 40013cc0 <_Once_Mutex> <== NOT EXECUTED 4000a348: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4000a34c: 7f ff f6 33 call 40007c18 <_API_Mutex_Unlock> <== NOT EXECUTED 4000a350: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 40023cb8 <_Processor_mask_Copy>: long *dst, size_t dst_size, const long *src, size_t src_size ) { 40023cb8: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED long inclusive = 0; long exclusive = 0; if ( ( dst_size | src_size ) % sizeof( long ) != 0 ) { 40023cbc: 84 12 40 0b or %o1, %o3, %g2 <== NOT EXECUTED 40023cc0: 80 88 a0 03 btst 3, %g2 <== NOT EXECUTED 40023cc4: 12 80 00 2b bne 40023d70 <_Processor_mask_Copy+0xb8> <== NOT EXECUTED 40023cc8: 90 10 20 03 mov 3, %o0 return PROCESSOR_MASK_COPY_INVALID_SIZE; } while ( dst_size > 0 && src_size > 0 ) { 40023ccc: 80 a2 e0 00 cmp %o3, 0 40023cd0: 02 80 00 11 be 40023d14 <_Processor_mask_Copy+0x5c> 40023cd4: 86 10 20 00 clr %g3 40023cd8: 80 a2 60 00 cmp %o1, 0 40023cdc: 32 80 00 07 bne,a 40023cf8 <_Processor_mask_Copy+0x40> 40023ce0: c4 02 80 00 ld [ %o2 ], %g2 40023ce4: 30 80 00 0d b,a 40023d18 <_Processor_mask_Copy+0x60> 40023ce8: 80 a2 e0 00 cmp %o3, 0 40023cec: 02 80 00 0b be 40023d18 <_Processor_mask_Copy+0x60> <== ALWAYS TAKEN 40023cf0: 80 a2 60 00 cmp %o1, 0 long bits = *src; 40023cf4: c4 02 80 00 ld [ %o2 ], %g2 <== NOT EXECUTED inclusive |= bits; *dst = bits; 40023cf8: c4 20 40 00 st %g2, [ %g1 ] ++dst; ++src; dst_size -= sizeof( long ); src_size -= sizeof( long ); 40023cfc: 96 02 ff fc add %o3, -4, %o3 while ( dst_size > 0 && src_size > 0 ) { 40023d00: 92 82 7f fc addcc %o1, -4, %o1 inclusive |= bits; 40023d04: 86 10 c0 02 or %g3, %g2, %g3 ++dst; 40023d08: 82 00 60 04 add %g1, 4, %g1 while ( dst_size > 0 && src_size > 0 ) { 40023d0c: 12 bf ff f7 bne 40023ce8 <_Processor_mask_Copy+0x30> 40023d10: 94 02 a0 04 add %o2, 4, %o2 } while ( dst_size > 0 ) { 40023d14: 80 a2 60 00 cmp %o1, 0 40023d18: 02 80 00 07 be 40023d34 <_Processor_mask_Copy+0x7c> 40023d1c: 80 a2 e0 00 cmp %o3, 0 *dst = 0; 40023d20: c0 20 40 00 clr [ %g1 ] while ( dst_size > 0 ) { 40023d24: 92 82 7f fc addcc %o1, -4, %o1 40023d28: 12 bf ff fe bne 40023d20 <_Processor_mask_Copy+0x68> <== NEVER TAKEN 40023d2c: 82 00 60 04 add %g1, 4, %g1 ++dst; dst_size -= sizeof( long ); } while ( src_size > 0 ) { 40023d30: 80 a2 e0 00 cmp %o3, 0 40023d34: 02 80 00 0e be 40023d6c <_Processor_mask_Copy+0xb4> 40023d38: 82 10 20 00 clr %g1 exclusive |= *src; 40023d3c: c4 02 80 00 ld [ %o2 ], %g2 40023d40: 82 10 40 02 or %g1, %g2, %g1 while ( src_size > 0 ) { 40023d44: 96 82 ff fc addcc %o3, -4, %o3 40023d48: 12 bf ff fd bne 40023d3c <_Processor_mask_Copy+0x84> <== NEVER TAKEN 40023d4c: 94 02 a0 04 add %o2, 4, %o2 ++src; src_size -= sizeof( long ); } if ( exclusive != 0 ) { 40023d50: 80 a0 60 00 cmp %g1, 0 40023d54: 02 80 00 07 be 40023d70 <_Processor_mask_Copy+0xb8> 40023d58: 90 10 20 00 clr %o0 if ( inclusive != 0 ) { return PROCESSOR_MASK_COPY_PARTIAL_LOSS; } else { return PROCESSOR_MASK_COPY_COMPLETE_LOSS; 40023d5c: 80 a0 00 03 cmp %g0, %g3 40023d60: 90 60 3f ff subx %g0, -1, %o0 40023d64: 81 c3 e0 08 retl 40023d68: 90 02 20 01 inc %o0 } } return PROCESSOR_MASK_COPY_LOSSLESS; 40023d6c: 90 10 20 00 clr %o0 } 40023d70: 81 c3 e0 08 retl 40023d74: 01 00 00 00 nop =============================================================================== 40008c20 <_Protected_heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t size, uintptr_t alignment, uintptr_t boundary ) { 40008c20: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED void *p; _RTEMS_Lock_allocator(); 40008c24: 7f ff f7 4c call 40006954 <_RTEMS_Lock_allocator> <== NOT EXECUTED 40008c28: 01 00 00 00 nop <== NOT EXECUTED p = _Heap_Allocate_aligned_with_boundary( 40008c2c: 96 10 00 1b mov %i3, %o3 40008c30: 94 10 00 1a mov %i2, %o2 40008c34: 92 10 00 19 mov %i1, %o1 40008c38: 7f ff f7 b2 call 40006b00 <_Heap_Allocate_aligned_with_boundary> 40008c3c: 90 10 00 18 mov %i0, %o0 heap, size, alignment, boundary ); _RTEMS_Unlock_allocator(); 40008c40: 7f ff f7 4a call 40006968 <_RTEMS_Unlock_allocator> 40008c44: b0 10 00 08 mov %o0, %i0 return p; } 40008c48: 81 c7 e0 08 ret 40008c4c: 81 e8 00 00 restore =============================================================================== 40008c50 <_Protected_heap_Extend>: bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, uintptr_t size ) { 40008c50: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED uintptr_t amount_extended; _RTEMS_Lock_allocator(); 40008c54: 7f ff f7 40 call 40006954 <_RTEMS_Lock_allocator> <== NOT EXECUTED 40008c58: 01 00 00 00 nop <== NOT EXECUTED amount_extended = _Heap_Extend( the_heap, starting_address, size, 0 ); 40008c5c: 96 10 20 00 clr %o3 ! 0 40008c60: 92 10 00 19 mov %i1, %o1 40008c64: 94 10 00 1a mov %i2, %o2 40008c68: 40 00 12 95 call 4000d6bc <_Heap_Extend> 40008c6c: 90 10 00 18 mov %i0, %o0 _RTEMS_Unlock_allocator(); 40008c70: 7f ff f7 3e call 40006968 <_RTEMS_Unlock_allocator> 40008c74: ba 10 00 08 mov %o0, %i5 return amount_extended != 0; } 40008c78: 80 a0 00 1d cmp %g0, %i5 40008c7c: b0 40 20 00 addx %g0, 0, %i0 40008c80: 81 c7 e0 08 ret 40008c84: 81 e8 00 00 restore =============================================================================== 4000d1e4 <_Protected_heap_Get_free_information>: bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 4000d1e4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED /* * TBD: _Heap_Get_free_information does not error check or return status. */ _RTEMS_Lock_allocator(); 4000d1e8: 7f ff f2 c9 call 40009d0c <_RTEMS_Lock_allocator> <== NOT EXECUTED 4000d1ec: 01 00 00 00 nop <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 4000d1f0: 90 10 00 18 mov %i0, %o0 4000d1f4: 92 10 00 19 mov %i1, %o1 4000d1f8: 40 00 14 73 call 400123c4 <_Heap_Get_free_information> 4000d1fc: b0 10 20 01 mov 1, %i0 _RTEMS_Unlock_allocator(); 4000d200: 7f ff f2 c8 call 40009d20 <_RTEMS_Unlock_allocator> 4000d204: 01 00 00 00 nop return true; } 4000d208: 81 c7 e0 08 ret 4000d20c: 81 e8 00 00 restore =============================================================================== 4000d210 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 4000d210: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED if ( !the_heap ) return false; if ( !the_info ) 4000d214: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 4000d218: 02 80 00 0e be 4000d250 <_Protected_heap_Get_information+0x40> <== NOT EXECUTED 4000d21c: 80 a6 60 00 cmp %i1, 0 4000d220: 22 80 00 0d be,a 4000d254 <_Protected_heap_Get_information+0x44> 4000d224: b0 10 20 00 clr %i0 return false; _RTEMS_Lock_allocator(); 4000d228: 7f ff f2 b9 call 40009d0c <_RTEMS_Lock_allocator> 4000d22c: 01 00 00 00 nop _Heap_Get_information( the_heap, the_info ); 4000d230: 90 10 00 18 mov %i0, %o0 4000d234: 92 10 00 19 mov %i1, %o1 4000d238: 7f ff f4 88 call 4000a458 <_Heap_Get_information> 4000d23c: b0 10 20 01 mov 1, %i0 _RTEMS_Unlock_allocator(); 4000d240: 7f ff f2 b8 call 40009d20 <_RTEMS_Unlock_allocator> 4000d244: b0 0e 20 01 and %i0, 1, %i0 return true; } 4000d248: 81 c7 e0 08 ret 4000d24c: 81 e8 00 00 restore return false; 4000d250: b0 10 20 00 clr %i0 } 4000d254: b0 0e 20 01 and %i0, 1, %i0 4000d258: 81 c7 e0 08 ret 4000d25c: 81 e8 00 00 restore =============================================================================== 4000d260 <_Protected_heap_Walk>: bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 4000d260: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED enabled = _Thread_Dispatch_disable_level == 0; 4000d264: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED * then it is forbidden to lock a mutex. But since we are inside * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( _Thread_Dispatch_is_enabled() ) { 4000d268: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000d26c: 02 80 00 04 be 4000d27c <_Protected_heap_Walk+0x1c> <== NOT EXECUTED 4000d270: 01 00 00 00 nop _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 4000d274: 7f ff f6 78 call 4000ac54 <_Heap_Walk> 4000d278: 81 e8 00 00 restore _RTEMS_Lock_allocator(); 4000d27c: 7f ff f2 a4 call 40009d0c <_RTEMS_Lock_allocator> 4000d280: 01 00 00 00 nop status = _Heap_Walk( the_heap, source, do_dump ); 4000d284: 94 10 00 1a mov %i2, %o2 4000d288: 92 10 00 19 mov %i1, %o1 4000d28c: 7f ff f6 72 call 4000ac54 <_Heap_Walk> 4000d290: 90 10 00 18 mov %i0, %o0 _RTEMS_Unlock_allocator(); 4000d294: 7f ff f2 a3 call 40009d20 <_RTEMS_Unlock_allocator> 4000d298: b0 10 00 08 mov %o0, %i0 } return status; } 4000d29c: 81 c7 e0 08 ret 4000d2a0: 81 e8 00 00 restore =============================================================================== 4000930c <_RBTree_Extract>: #include RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 4000930c: c6 02 40 00 ld [ %o1 ], %g3 <== NOT EXECUTED 40009310: 80 a0 e0 00 cmp %g3, 0 40009314: 02 80 00 d0 be 40009654 <_RBTree_Extract+0x348> <== ALWAYS TAKEN 40009318: c4 02 60 04 ld [ %o1 + 4 ], %g2 4000931c: 80 a0 a0 00 cmp %g2, 0 40009320: 32 80 00 13 bne,a 4000936c <_RBTree_Extract+0x60> 40009324: c2 00 80 00 ld [ %g2 ], %g1 40009328: c2 02 60 08 ld [ %o1 + 8 ], %g1 4000932c: c8 02 60 0c ld [ %o1 + 0xc ], %g4 40009330: c2 20 e0 08 st %g1, [ %g3 + 8 ] 40009334: 80 a0 60 00 cmp %g1, 0 40009338: 22 80 00 cf be,a 40009674 <_RBTree_Extract+0x368> 4000933c: c6 22 00 00 st %g3, [ %o0 ] 40009340: c4 00 40 00 ld [ %g1 ], %g2 40009344: 80 a2 40 02 cmp %o1, %g2 40009348: 22 80 00 d3 be,a 40009694 <_RBTree_Extract+0x388> 4000934c: c6 20 40 00 st %g3, [ %g1 ] 40009350: c6 20 60 04 st %g3, [ %g1 + 4 ] 40009354: 80 a1 20 00 cmp %g4, 0 40009358: 02 80 00 55 be 400094ac <_RBTree_Extract+0x1a0> 4000935c: 9a 10 20 01 mov 1, %o5 ) { _Assert( _RBTree_Find_root( the_node ) == _RBTree_Root( the_rbtree ) ); RB_REMOVE( RBTree_Control, the_rbtree, the_node ); _RBTree_Initialize_node( the_node ); } 40009360: 81 c3 e0 08 retl 40009364: 01 00 00 00 nop RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 40009368: c2 00 80 00 ld [ %g2 ], %g1 4000936c: 80 a0 60 00 cmp %g1, 0 40009370: 32 bf ff fe bne,a 40009368 <_RBTree_Extract+0x5c> 40009374: 84 10 00 01 mov %g1, %g2 40009378: c6 00 a0 04 ld [ %g2 + 4 ], %g3 4000937c: c2 00 a0 08 ld [ %g2 + 8 ], %g1 40009380: c8 00 a0 0c ld [ %g2 + 0xc ], %g4 40009384: 80 a0 e0 00 cmp %g3, 0 40009388: 02 80 00 04 be 40009398 <_RBTree_Extract+0x8c> 4000938c: 9a 10 00 01 mov %g1, %o5 40009390: c2 20 e0 08 st %g1, [ %g3 + 8 ] 40009394: da 00 a0 08 ld [ %g2 + 8 ], %o5 40009398: 80 a0 60 00 cmp %g1, 0 4000939c: 22 80 00 07 be,a 400093b8 <_RBTree_Extract+0xac> <== NEVER TAKEN 400093a0: c6 22 00 00 st %g3, [ %o0 ] <== NOT EXECUTED 400093a4: d8 00 40 00 ld [ %g1 ], %o4 400093a8: 80 a0 80 0c cmp %g2, %o4 400093ac: 22 80 00 03 be,a 400093b8 <_RBTree_Extract+0xac> 400093b0: c6 20 40 00 st %g3, [ %g1 ] 400093b4: c6 20 60 04 st %g3, [ %g1 + 4 ] 400093b8: 80 a2 40 0d cmp %o1, %o5 400093bc: 22 80 00 02 be,a 400093c4 <_RBTree_Extract+0xb8> 400093c0: 82 10 00 02 mov %g2, %g1 400093c4: da 02 40 00 ld [ %o1 ], %o5 400093c8: da 20 80 00 st %o5, [ %g2 ] 400093cc: da 02 60 04 ld [ %o1 + 4 ], %o5 400093d0: da 20 a0 04 st %o5, [ %g2 + 4 ] 400093d4: da 02 60 08 ld [ %o1 + 8 ], %o5 400093d8: da 20 a0 08 st %o5, [ %g2 + 8 ] 400093dc: da 02 60 0c ld [ %o1 + 0xc ], %o5 400093e0: da 20 a0 0c st %o5, [ %g2 + 0xc ] 400093e4: da 02 60 08 ld [ %o1 + 8 ], %o5 400093e8: 80 a3 60 00 cmp %o5, 0 400093ec: 22 80 00 07 be,a 40009408 <_RBTree_Extract+0xfc> 400093f0: c4 22 00 00 st %g2, [ %o0 ] 400093f4: d8 03 40 00 ld [ %o5 ], %o4 400093f8: 80 a2 40 0c cmp %o1, %o4 400093fc: 22 80 00 03 be,a 40009408 <_RBTree_Extract+0xfc> 40009400: c4 23 40 00 st %g2, [ %o5 ] 40009404: c4 23 60 04 st %g2, [ %o5 + 4 ] 40009408: da 02 40 00 ld [ %o1 ], %o5 4000940c: c4 23 60 08 st %g2, [ %o5 + 8 ] 40009410: da 02 60 04 ld [ %o1 + 4 ], %o5 40009414: 80 a3 60 00 cmp %o5, 0 40009418: 32 80 00 02 bne,a 40009420 <_RBTree_Extract+0x114> 4000941c: c4 23 60 08 st %g2, [ %o5 + 8 ] 40009420: 80 a0 60 00 cmp %g1, 0 40009424: 02 bf ff cc be 40009354 <_RBTree_Extract+0x48> <== NEVER TAKEN 40009428: 84 10 00 01 mov %g1, %g2 4000942c: c4 00 a0 08 ld [ %g2 + 8 ], %g2 40009430: 80 a0 a0 00 cmp %g2, 0 40009434: 32 bf ff ff bne,a 40009430 <_RBTree_Extract+0x124> 40009438: c4 00 a0 08 ld [ %g2 + 8 ], %g2 4000943c: 80 a1 20 00 cmp %g4, 0 40009440: 12 bf ff c8 bne 40009360 <_RBTree_Extract+0x54> 40009444: 9a 10 20 01 mov 1, %o5 RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 40009448: 10 80 00 1a b 400094b0 <_RBTree_Extract+0x1a4> 4000944c: 80 a0 e0 00 cmp %g3, 0 40009450: 80 a0 e0 01 cmp %g3, 1 40009454: 22 80 00 54 be,a 400095a4 <_RBTree_Extract+0x298> 40009458: c8 00 a0 04 ld [ %g2 + 4 ], %g4 4000945c: c6 00 80 00 ld [ %g2 ], %g3 40009460: 80 a0 e0 00 cmp %g3, 0 40009464: 22 80 00 07 be,a 40009480 <_RBTree_Extract+0x174> 40009468: c8 00 a0 04 ld [ %g2 + 4 ], %g4 4000946c: c8 00 e0 0c ld [ %g3 + 0xc ], %g4 40009470: 80 a1 20 00 cmp %g4, 0 40009474: 32 80 00 98 bne,a 400096d4 <_RBTree_Extract+0x3c8> 40009478: da 00 60 0c ld [ %g1 + 0xc ], %o5 4000947c: c8 00 a0 04 ld [ %g2 + 4 ], %g4 40009480: 80 a1 20 00 cmp %g4, 0 40009484: 22 80 00 07 be,a 400094a0 <_RBTree_Extract+0x194> 40009488: da 20 a0 0c st %o5, [ %g2 + 0xc ] 4000948c: d8 01 20 0c ld [ %g4 + 0xc ], %o4 40009490: 80 a3 20 00 cmp %o4, 0 40009494: 12 80 00 89 bne 400096b8 <_RBTree_Extract+0x3ac> 40009498: 80 a0 e0 00 cmp %g3, 0 4000949c: da 20 a0 0c st %o5, [ %g2 + 0xc ] 400094a0: 86 10 00 01 mov %g1, %g3 400094a4: c4 00 60 08 ld [ %g1 + 8 ], %g2 400094a8: 82 10 00 02 mov %g2, %g1 400094ac: 80 a0 e0 00 cmp %g3, 0 400094b0: 22 80 00 07 be,a 400094cc <_RBTree_Extract+0x1c0> 400094b4: c4 02 00 00 ld [ %o0 ], %g2 400094b8: c4 00 e0 0c ld [ %g3 + 0xc ], %g2 400094bc: 80 a0 a0 00 cmp %g2, 0 400094c0: 12 80 00 37 bne 4000959c <_RBTree_Extract+0x290> 400094c4: 01 00 00 00 nop 400094c8: c4 02 00 00 ld [ %o0 ], %g2 400094cc: 80 a0 c0 02 cmp %g3, %g2 400094d0: 02 80 00 31 be 40009594 <_RBTree_Extract+0x288> 400094d4: 80 a0 e0 00 cmp %g3, 0 400094d8: c4 00 40 00 ld [ %g1 ], %g2 400094dc: 80 a0 80 03 cmp %g2, %g3 400094e0: 32 bf ff dc bne,a 40009450 <_RBTree_Extract+0x144> 400094e4: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 400094e8: c4 00 60 04 ld [ %g1 + 4 ], %g2 400094ec: c8 00 a0 0c ld [ %g2 + 0xc ], %g4 400094f0: 80 a1 20 01 cmp %g4, 1 400094f4: 02 80 00 40 be 400095f4 <_RBTree_Extract+0x2e8> 400094f8: c6 00 80 00 ld [ %g2 ], %g3 400094fc: 80 a0 e0 00 cmp %g3, 0 40009500: 22 80 00 06 be,a 40009518 <_RBTree_Extract+0x20c> 40009504: c8 00 a0 04 ld [ %g2 + 4 ], %g4 40009508: c8 00 e0 0c ld [ %g3 + 0xc ], %g4 4000950c: 80 a1 20 00 cmp %g4, 0 40009510: 12 80 00 ac bne 400097c0 <_RBTree_Extract+0x4b4> 40009514: c8 00 a0 04 ld [ %g2 + 4 ], %g4 40009518: 80 a1 20 00 cmp %g4, 0 4000951c: 22 bf ff e1 be,a 400094a0 <_RBTree_Extract+0x194> 40009520: da 20 a0 0c st %o5, [ %g2 + 0xc ] 40009524: c6 01 20 0c ld [ %g4 + 0xc ], %g3 40009528: 80 a0 e0 00 cmp %g3, 0 4000952c: 22 bf ff dd be,a 400094a0 <_RBTree_Extract+0x194> 40009530: da 20 a0 0c st %o5, [ %g2 + 0xc ] 40009534: c6 00 60 0c ld [ %g1 + 0xc ], %g3 40009538: da 00 60 04 ld [ %g1 + 4 ], %o5 4000953c: c6 20 a0 0c st %g3, [ %g2 + 0xc ] 40009540: c0 20 60 0c clr [ %g1 + 0xc ] 40009544: c0 21 20 0c clr [ %g4 + 0xc ] 40009548: c4 03 40 00 ld [ %o5 ], %g2 4000954c: 80 a0 a0 00 cmp %g2, 0 40009550: 02 80 00 03 be 4000955c <_RBTree_Extract+0x250> 40009554: c4 20 60 04 st %g2, [ %g1 + 4 ] 40009558: c2 20 a0 08 st %g1, [ %g2 + 8 ] 4000955c: c4 00 60 08 ld [ %g1 + 8 ], %g2 40009560: 80 a0 a0 00 cmp %g2, 0 40009564: 02 80 00 c1 be 40009868 <_RBTree_Extract+0x55c> 40009568: c4 23 60 08 st %g2, [ %o5 + 8 ] 4000956c: c4 00 60 08 ld [ %g1 + 8 ], %g2 40009570: c6 00 80 00 ld [ %g2 ], %g3 40009574: 80 a0 40 03 cmp %g1, %g3 40009578: 22 80 00 c1 be,a 4000987c <_RBTree_Extract+0x570> 4000957c: da 20 80 00 st %o5, [ %g2 ] 40009580: da 20 a0 04 st %o5, [ %g2 + 4 ] 40009584: c6 02 00 00 ld [ %o0 ], %g3 40009588: c2 23 40 00 st %g1, [ %o5 ] 4000958c: da 20 60 08 st %o5, [ %g1 + 8 ] 40009590: 80 a0 e0 00 cmp %g3, 0 40009594: 02 bf ff 73 be 40009360 <_RBTree_Extract+0x54> 40009598: 01 00 00 00 nop } 4000959c: 81 c3 e0 08 retl 400095a0: c0 20 e0 0c clr [ %g3 + 0xc ] RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 400095a4: c0 20 a0 0c clr [ %g2 + 0xc ] 400095a8: 80 a1 20 00 cmp %g4, 0 400095ac: c6 20 60 0c st %g3, [ %g1 + 0xc ] 400095b0: 02 80 00 03 be 400095bc <_RBTree_Extract+0x2b0> <== NEVER TAKEN 400095b4: c8 20 40 00 st %g4, [ %g1 ] 400095b8: c2 21 20 08 st %g1, [ %g4 + 8 ] 400095bc: c6 00 60 08 ld [ %g1 + 8 ], %g3 400095c0: 80 a0 e0 00 cmp %g3, 0 400095c4: 02 80 00 22 be 4000964c <_RBTree_Extract+0x340> 400095c8: c6 20 a0 08 st %g3, [ %g2 + 8 ] 400095cc: c6 00 60 08 ld [ %g1 + 8 ], %g3 400095d0: d8 00 c0 00 ld [ %g3 ], %o4 400095d4: 80 a0 40 0c cmp %g1, %o4 400095d8: 22 80 00 25 be,a 4000966c <_RBTree_Extract+0x360> 400095dc: c4 20 c0 00 st %g2, [ %g3 ] 400095e0: c4 20 e0 04 st %g2, [ %g3 + 4 ] 400095e4: c2 20 a0 04 st %g1, [ %g2 + 4 ] 400095e8: c4 20 60 08 st %g2, [ %g1 + 8 ] 400095ec: 10 bf ff 9c b 4000945c <_RBTree_Extract+0x150> 400095f0: 84 10 00 04 mov %g4, %g2 400095f4: c0 20 a0 0c clr [ %g2 + 0xc ] 400095f8: 80 a0 e0 00 cmp %g3, 0 400095fc: c8 20 60 0c st %g4, [ %g1 + 0xc ] 40009600: 02 80 00 03 be 4000960c <_RBTree_Extract+0x300> <== NEVER TAKEN 40009604: c6 20 60 04 st %g3, [ %g1 + 4 ] 40009608: c2 20 e0 08 st %g1, [ %g3 + 8 ] 4000960c: c8 00 60 08 ld [ %g1 + 8 ], %g4 40009610: 80 a1 20 00 cmp %g4, 0 40009614: 02 80 00 1d be 40009688 <_RBTree_Extract+0x37c> 40009618: c8 20 a0 08 st %g4, [ %g2 + 8 ] 4000961c: c8 00 60 08 ld [ %g1 + 8 ], %g4 40009620: d8 01 00 00 ld [ %g4 ], %o4 40009624: 80 a0 40 0c cmp %g1, %o4 40009628: 22 80 00 22 be,a 400096b0 <_RBTree_Extract+0x3a4> 4000962c: c4 21 00 00 st %g2, [ %g4 ] 40009630: c4 21 20 04 st %g2, [ %g4 + 4 ] 40009634: c8 00 60 04 ld [ %g1 + 4 ], %g4 40009638: c2 20 80 00 st %g1, [ %g2 ] 4000963c: c6 01 00 00 ld [ %g4 ], %g3 40009640: c4 20 60 08 st %g2, [ %g1 + 8 ] 40009644: 10 bf ff ae b 400094fc <_RBTree_Extract+0x1f0> 40009648: 84 10 00 04 mov %g4, %g2 4000964c: 10 bf ff e6 b 400095e4 <_RBTree_Extract+0x2d8> 40009650: c4 22 00 00 st %g2, [ %o0 ] RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 40009654: c2 02 60 08 ld [ %o1 + 8 ], %g1 40009658: 80 a0 a0 00 cmp %g2, 0 4000965c: 02 bf ff 36 be 40009334 <_RBTree_Extract+0x28> 40009660: c8 02 60 0c ld [ %o1 + 0xc ], %g4 40009664: 10 bf ff 33 b 40009330 <_RBTree_Extract+0x24> 40009668: 86 10 00 02 mov %g2, %g3 4000966c: 10 bf ff de b 400095e4 <_RBTree_Extract+0x2d8> 40009670: c8 00 40 00 ld [ %g1 ], %g4 40009674: 80 a1 20 00 cmp %g4, 0 40009678: 12 bf ff 3a bne 40009360 <_RBTree_Extract+0x54> <== NEVER TAKEN 4000967c: 9a 10 20 01 mov 1, %o5 RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 40009680: 10 bf ff 8c b 400094b0 <_RBTree_Extract+0x1a4> 40009684: 80 a0 e0 00 cmp %g3, 0 40009688: c4 22 00 00 st %g2, [ %o0 ] 4000968c: 10 bf ff eb b 40009638 <_RBTree_Extract+0x32c> 40009690: 88 10 00 03 mov %g3, %g4 RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 40009694: 80 a1 20 00 cmp %g4, 0 40009698: 12 bf ff 32 bne 40009360 <_RBTree_Extract+0x54> 4000969c: 9a 10 20 01 mov 1, %o5 RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 400096a0: 10 bf ff 84 b 400094b0 <_RBTree_Extract+0x1a4> 400096a4: 80 a0 e0 00 cmp %g3, 0 RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 400096a8: 10 bf ff 58 b 40009408 <_RBTree_Extract+0xfc> <== NOT EXECUTED 400096ac: c4 23 40 00 st %g2, [ %o5 ] <== NOT EXECUTED RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 400096b0: 10 bf ff e2 b 40009638 <_RBTree_Extract+0x32c> 400096b4: 88 10 00 03 mov %g3, %g4 400096b8: 22 80 00 21 be,a 4000973c <_RBTree_Extract+0x430> 400096bc: c6 01 00 00 ld [ %g4 ], %g3 400096c0: da 00 e0 0c ld [ %g3 + 0xc ], %o5 400096c4: 80 a3 60 00 cmp %o5, 0 400096c8: 22 80 00 1d be,a 4000973c <_RBTree_Extract+0x430> <== ALWAYS TAKEN 400096cc: c6 01 00 00 ld [ %g4 ], %g3 400096d0: da 00 60 0c ld [ %g1 + 0xc ], %o5 <== NOT EXECUTED 400096d4: c8 00 40 00 ld [ %g1 ], %g4 400096d8: da 20 a0 0c st %o5, [ %g2 + 0xc ] 400096dc: c0 20 60 0c clr [ %g1 + 0xc ] 400096e0: c0 20 e0 0c clr [ %g3 + 0xc ] 400096e4: c4 01 20 04 ld [ %g4 + 4 ], %g2 400096e8: 80 a0 a0 00 cmp %g2, 0 400096ec: 02 80 00 03 be 400096f8 <_RBTree_Extract+0x3ec> 400096f0: c4 20 40 00 st %g2, [ %g1 ] 400096f4: c2 20 a0 08 st %g1, [ %g2 + 8 ] 400096f8: c4 00 60 08 ld [ %g1 + 8 ], %g2 400096fc: 80 a0 a0 00 cmp %g2, 0 40009700: 02 80 00 2b be 400097ac <_RBTree_Extract+0x4a0> 40009704: c4 21 20 08 st %g2, [ %g4 + 8 ] 40009708: c4 00 60 08 ld [ %g1 + 8 ], %g2 4000970c: c6 00 80 00 ld [ %g2 ], %g3 40009710: 80 a0 40 03 cmp %g1, %g3 40009714: 22 80 00 4f be,a 40009850 <_RBTree_Extract+0x544> 40009718: c8 20 80 00 st %g4, [ %g2 ] 4000971c: c8 20 a0 04 st %g4, [ %g2 + 4 ] 40009720: c6 02 00 00 ld [ %o0 ], %g3 40009724: c2 21 20 04 st %g1, [ %g4 + 4 ] 40009728: c8 20 60 08 st %g4, [ %g1 + 8 ] 4000972c: 80 a0 e0 00 cmp %g3, 0 40009730: 12 bf ff 9b bne 4000959c <_RBTree_Extract+0x290> <== ALWAYS TAKEN 40009734: 01 00 00 00 nop 40009738: 30 bf ff 0a b,a 40009360 <_RBTree_Extract+0x54> <== NOT EXECUTED 4000973c: c0 21 20 0c clr [ %g4 + 0xc ] 40009740: 9a 10 20 01 mov 1, %o5 40009744: c6 20 a0 04 st %g3, [ %g2 + 4 ] 40009748: 80 a0 e0 00 cmp %g3, 0 4000974c: 02 80 00 03 be 40009758 <_RBTree_Extract+0x44c> 40009750: da 20 a0 0c st %o5, [ %g2 + 0xc ] 40009754: c4 20 e0 08 st %g2, [ %g3 + 8 ] 40009758: c6 00 a0 08 ld [ %g2 + 8 ], %g3 4000975c: 80 a0 e0 00 cmp %g3, 0 40009760: 02 80 00 40 be 40009860 <_RBTree_Extract+0x554> <== NEVER TAKEN 40009764: c6 21 20 08 st %g3, [ %g4 + 8 ] 40009768: c6 00 a0 08 ld [ %g2 + 8 ], %g3 4000976c: da 00 c0 00 ld [ %g3 ], %o5 40009770: 80 a0 80 0d cmp %g2, %o5 40009774: 22 80 00 03 be,a 40009780 <_RBTree_Extract+0x474> <== ALWAYS TAKEN 40009778: c8 20 c0 00 st %g4, [ %g3 ] 4000977c: c8 20 e0 04 st %g4, [ %g3 + 4 ] <== NOT EXECUTED 40009780: c4 21 00 00 st %g2, [ %g4 ] 40009784: c8 20 a0 08 st %g4, [ %g2 + 8 ] 40009788: c8 00 40 00 ld [ %g1 ], %g4 4000978c: c4 00 60 0c ld [ %g1 + 0xc ], %g2 40009790: c4 21 20 0c st %g2, [ %g4 + 0xc ] 40009794: c6 01 00 00 ld [ %g4 ], %g3 40009798: 80 a0 e0 00 cmp %g3, 0 4000979c: 02 bf ff d2 be 400096e4 <_RBTree_Extract+0x3d8> <== NEVER TAKEN 400097a0: c0 20 60 0c clr [ %g1 + 0xc ] 400097a4: 10 bf ff d0 b 400096e4 <_RBTree_Extract+0x3d8> 400097a8: c0 20 e0 0c clr [ %g3 + 0xc ] 400097ac: c8 22 00 00 st %g4, [ %o0 ] 400097b0: 86 10 00 04 mov %g4, %g3 400097b4: c2 21 20 04 st %g1, [ %g4 + 4 ] 400097b8: 10 bf ff dd b 4000972c <_RBTree_Extract+0x420> 400097bc: c8 20 60 08 st %g4, [ %g1 + 8 ] 400097c0: 80 a1 20 00 cmp %g4, 0 400097c4: 22 80 00 07 be,a 400097e0 <_RBTree_Extract+0x4d4> 400097c8: c8 00 e0 04 ld [ %g3 + 4 ], %g4 400097cc: da 01 20 0c ld [ %g4 + 0xc ], %o5 400097d0: 80 a3 60 00 cmp %o5, 0 400097d4: 32 bf ff 59 bne,a 40009538 <_RBTree_Extract+0x22c> 400097d8: c6 00 60 0c ld [ %g1 + 0xc ], %g3 400097dc: c8 00 e0 04 ld [ %g3 + 4 ], %g4 400097e0: c0 20 e0 0c clr [ %g3 + 0xc ] 400097e4: 9a 10 20 01 mov 1, %o5 400097e8: c8 20 80 00 st %g4, [ %g2 ] 400097ec: 80 a1 20 00 cmp %g4, 0 400097f0: 02 80 00 03 be 400097fc <_RBTree_Extract+0x4f0> 400097f4: da 20 a0 0c st %o5, [ %g2 + 0xc ] 400097f8: c4 21 20 08 st %g2, [ %g4 + 8 ] 400097fc: c8 00 a0 08 ld [ %g2 + 8 ], %g4 40009800: 80 a1 20 00 cmp %g4, 0 40009804: 02 80 00 22 be 4000988c <_RBTree_Extract+0x580> <== NEVER TAKEN 40009808: c8 20 e0 08 st %g4, [ %g3 + 8 ] 4000980c: c8 00 a0 08 ld [ %g2 + 8 ], %g4 40009810: da 01 00 00 ld [ %g4 ], %o5 40009814: 80 a0 80 0d cmp %g2, %o5 40009818: 22 80 00 03 be,a 40009824 <_RBTree_Extract+0x518> <== NEVER TAKEN 4000981c: c6 21 00 00 st %g3, [ %g4 ] <== NOT EXECUTED 40009820: c6 21 20 04 st %g3, [ %g4 + 4 ] 40009824: c4 20 e0 04 st %g2, [ %g3 + 4 ] 40009828: c6 20 a0 08 st %g3, [ %g2 + 8 ] 4000982c: da 00 60 04 ld [ %g1 + 4 ], %o5 40009830: c4 00 60 0c ld [ %g1 + 0xc ], %g2 40009834: c4 23 60 0c st %g2, [ %o5 + 0xc ] 40009838: c8 03 60 04 ld [ %o5 + 4 ], %g4 4000983c: 80 a1 20 00 cmp %g4, 0 40009840: 02 bf ff 42 be 40009548 <_RBTree_Extract+0x23c> <== NEVER TAKEN 40009844: c0 20 60 0c clr [ %g1 + 0xc ] 40009848: 10 bf ff 40 b 40009548 <_RBTree_Extract+0x23c> 4000984c: c0 21 20 0c clr [ %g4 + 0xc ] 40009850: c6 02 00 00 ld [ %o0 ], %g3 40009854: c2 21 20 04 st %g1, [ %g4 + 4 ] 40009858: 10 bf ff b5 b 4000972c <_RBTree_Extract+0x420> 4000985c: c8 20 60 08 st %g4, [ %g1 + 8 ] 40009860: 10 bf ff c8 b 40009780 <_RBTree_Extract+0x474> <== NOT EXECUTED 40009864: c8 22 00 00 st %g4, [ %o0 ] <== NOT EXECUTED 40009868: da 22 00 00 st %o5, [ %o0 ] 4000986c: 86 10 00 0d mov %o5, %g3 40009870: c2 23 40 00 st %g1, [ %o5 ] 40009874: 10 bf ff 47 b 40009590 <_RBTree_Extract+0x284> 40009878: da 20 60 08 st %o5, [ %g1 + 8 ] 4000987c: c6 02 00 00 ld [ %o0 ], %g3 40009880: c2 23 40 00 st %g1, [ %o5 ] 40009884: 10 bf ff 43 b 40009590 <_RBTree_Extract+0x284> 40009888: da 20 60 08 st %o5, [ %g1 + 8 ] 4000988c: 10 bf ff e6 b 40009824 <_RBTree_Extract+0x518> <== NOT EXECUTED 40009890: c6 22 00 00 st %g3, [ %o0 ] <== NOT EXECUTED =============================================================================== 40009894 <_RBTree_Insert_color>: #include "config.h" #endif #include RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline ) 40009894: 98 10 20 01 mov 1, %o4 <== NOT EXECUTED 40009898: c2 02 60 08 ld [ %o1 + 8 ], %g1 4000989c: 80 a0 60 00 cmp %g1, 0 400098a0: 22 80 00 2f be,a 4000995c <_RBTree_Insert_color+0xc8> 400098a4: c2 02 00 00 ld [ %o0 ], %g1 400098a8: c4 00 60 0c ld [ %g1 + 0xc ], %g2 400098ac: 80 a0 a0 01 cmp %g2, 1 400098b0: 32 80 00 2b bne,a 4000995c <_RBTree_Insert_color+0xc8> 400098b4: c2 02 00 00 ld [ %o0 ], %g1 400098b8: c6 00 60 08 ld [ %g1 + 8 ], %g3 400098bc: c8 00 c0 00 ld [ %g3 ], %g4 400098c0: 80 a0 40 04 cmp %g1, %g4 400098c4: 02 80 00 28 be 40009964 <_RBTree_Insert_color+0xd0> 400098c8: 84 10 00 03 mov %g3, %g2 400098cc: 80 a1 20 00 cmp %g4, 0 400098d0: 22 80 00 07 be,a 400098ec <_RBTree_Insert_color+0x58> 400098d4: c8 00 40 00 ld [ %g1 ], %g4 400098d8: da 01 20 0c ld [ %g4 + 0xc ], %o5 400098dc: 80 a3 60 01 cmp %o5, 1 400098e0: 22 80 00 58 be,a 40009a40 <_RBTree_Insert_color+0x1ac> 400098e4: c0 21 20 0c clr [ %g4 + 0xc ] 400098e8: c8 00 40 00 ld [ %g1 ], %g4 400098ec: 80 a2 40 04 cmp %o1, %g4 400098f0: 22 80 00 3c be,a 400099e0 <_RBTree_Insert_color+0x14c> 400098f4: c8 02 60 04 ld [ %o1 + 4 ], %g4 400098f8: c6 00 a0 04 ld [ %g2 + 4 ], %g3 400098fc: c0 20 60 0c clr [ %g1 + 0xc ] 40009900: c2 00 c0 00 ld [ %g3 ], %g1 40009904: c2 20 a0 04 st %g1, [ %g2 + 4 ] 40009908: 80 a0 60 00 cmp %g1, 0 4000990c: 02 80 00 03 be 40009918 <_RBTree_Insert_color+0x84> 40009910: d8 20 a0 0c st %o4, [ %g2 + 0xc ] 40009914: c4 20 60 08 st %g2, [ %g1 + 8 ] 40009918: c2 00 a0 08 ld [ %g2 + 8 ], %g1 4000991c: 80 a0 60 00 cmp %g1, 0 40009920: 02 80 00 44 be 40009a30 <_RBTree_Insert_color+0x19c> 40009924: c2 20 e0 08 st %g1, [ %g3 + 8 ] 40009928: c2 00 a0 08 ld [ %g2 + 8 ], %g1 4000992c: c8 00 40 00 ld [ %g1 ], %g4 40009930: 80 a0 80 04 cmp %g2, %g4 40009934: 22 80 00 47 be,a 40009a50 <_RBTree_Insert_color+0x1bc> 40009938: c6 20 40 00 st %g3, [ %g1 ] 4000993c: c6 20 60 04 st %g3, [ %g1 + 4 ] 40009940: c4 20 c0 00 st %g2, [ %g3 ] 40009944: c6 20 a0 08 st %g3, [ %g2 + 8 ] 40009948: c2 02 60 08 ld [ %o1 + 8 ], %g1 4000994c: 80 a0 60 00 cmp %g1, 0 40009950: 32 bf ff d7 bne,a 400098ac <_RBTree_Insert_color+0x18> <== ALWAYS TAKEN 40009954: c4 00 60 0c ld [ %g1 + 0xc ], %g2 40009958: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED RBTree_Control *the_rbtree, RBTree_Node *the_node ) { RBTree_Control_RB_INSERT_COLOR( the_rbtree, the_node ); } 4000995c: 81 c3 e0 08 retl 40009960: c0 20 60 0c clr [ %g1 + 0xc ] RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline ) 40009964: c8 00 e0 04 ld [ %g3 + 4 ], %g4 40009968: 80 a1 20 00 cmp %g4, 0 4000996c: 22 80 00 07 be,a 40009988 <_RBTree_Insert_color+0xf4> 40009970: da 00 60 04 ld [ %g1 + 4 ], %o5 40009974: da 01 20 0c ld [ %g4 + 0xc ], %o5 40009978: 80 a3 60 01 cmp %o5, 1 4000997c: 22 80 00 31 be,a 40009a40 <_RBTree_Insert_color+0x1ac> 40009980: c0 21 20 0c clr [ %g4 + 0xc ] 40009984: da 00 60 04 ld [ %g1 + 4 ], %o5 40009988: 80 a3 40 09 cmp %o5, %o1 4000998c: 02 80 00 3a be 40009a74 <_RBTree_Insert_color+0x1e0> 40009990: 88 10 00 01 mov %g1, %g4 40009994: c0 20 60 0c clr [ %g1 + 0xc ] 40009998: 80 a3 60 00 cmp %o5, 0 4000999c: d8 20 a0 0c st %o4, [ %g2 + 0xc ] 400099a0: 02 80 00 03 be 400099ac <_RBTree_Insert_color+0x118> 400099a4: da 20 80 00 st %o5, [ %g2 ] 400099a8: c4 23 60 08 st %g2, [ %o5 + 8 ] 400099ac: c2 00 a0 08 ld [ %g2 + 8 ], %g1 400099b0: 80 a0 60 00 cmp %g1, 0 400099b4: 02 80 00 2c be 40009a64 <_RBTree_Insert_color+0x1d0> 400099b8: c2 21 20 08 st %g1, [ %g4 + 8 ] 400099bc: c2 00 a0 08 ld [ %g2 + 8 ], %g1 400099c0: c6 00 40 00 ld [ %g1 ], %g3 400099c4: 80 a0 80 03 cmp %g2, %g3 400099c8: 22 80 00 4a be,a 40009af0 <_RBTree_Insert_color+0x25c> 400099cc: c8 20 40 00 st %g4, [ %g1 ] 400099d0: c8 20 60 04 st %g4, [ %g1 + 4 ] 400099d4: c4 21 20 04 st %g2, [ %g4 + 4 ] 400099d8: 10 bf ff b0 b 40009898 <_RBTree_Insert_color+0x4> 400099dc: c8 20 a0 08 st %g4, [ %g2 + 8 ] 400099e0: 80 a1 20 00 cmp %g4, 0 400099e4: 02 80 00 3b be 40009ad0 <_RBTree_Insert_color+0x23c> 400099e8: c8 20 40 00 st %g4, [ %g1 ] 400099ec: c2 21 20 08 st %g1, [ %g4 + 8 ] 400099f0: c6 00 60 08 ld [ %g1 + 8 ], %g3 400099f4: 80 a0 e0 00 cmp %g3, 0 400099f8: 02 80 00 19 be 40009a5c <_RBTree_Insert_color+0x1c8> <== NEVER TAKEN 400099fc: c6 22 60 08 st %g3, [ %o1 + 8 ] 40009a00: c6 00 60 08 ld [ %g1 + 8 ], %g3 40009a04: c8 00 c0 00 ld [ %g3 ], %g4 40009a08: 80 a0 40 04 cmp %g1, %g4 40009a0c: 22 80 00 03 be,a 40009a18 <_RBTree_Insert_color+0x184> <== NEVER TAKEN 40009a10: d2 20 c0 00 st %o1, [ %g3 ] <== NOT EXECUTED 40009a14: d2 20 e0 04 st %o1, [ %g3 + 4 ] 40009a18: 86 10 00 09 mov %o1, %g3 40009a1c: c2 22 60 04 st %g1, [ %o1 + 4 ] 40009a20: d2 20 60 08 st %o1, [ %g1 + 8 ] 40009a24: 92 10 00 01 mov %g1, %o1 40009a28: 10 bf ff b4 b 400098f8 <_RBTree_Insert_color+0x64> 40009a2c: 82 10 00 03 mov %g3, %g1 40009a30: c6 22 00 00 st %g3, [ %o0 ] 40009a34: c4 20 c0 00 st %g2, [ %g3 ] 40009a38: 10 bf ff c4 b 40009948 <_RBTree_Insert_color+0xb4> 40009a3c: c6 20 a0 08 st %g3, [ %g2 + 8 ] 40009a40: 92 10 00 03 mov %g3, %o1 40009a44: c0 20 60 0c clr [ %g1 + 0xc ] 40009a48: 10 bf ff 94 b 40009898 <_RBTree_Insert_color+0x4> 40009a4c: da 20 e0 0c st %o5, [ %g3 + 0xc ] 40009a50: c4 20 c0 00 st %g2, [ %g3 ] 40009a54: 10 bf ff bd b 40009948 <_RBTree_Insert_color+0xb4> 40009a58: c6 20 a0 08 st %g3, [ %g2 + 8 ] 40009a5c: 10 bf ff ef b 40009a18 <_RBTree_Insert_color+0x184> <== NOT EXECUTED 40009a60: d2 22 00 00 st %o1, [ %o0 ] <== NOT EXECUTED 40009a64: c8 22 00 00 st %g4, [ %o0 ] 40009a68: c4 21 20 04 st %g2, [ %g4 + 4 ] 40009a6c: 10 bf ff 8b b 40009898 <_RBTree_Insert_color+0x4> 40009a70: c8 20 a0 08 st %g4, [ %g2 + 8 ] 40009a74: c8 02 40 00 ld [ %o1 ], %g4 40009a78: 80 a1 20 00 cmp %g4, 0 40009a7c: 02 80 00 04 be 40009a8c <_RBTree_Insert_color+0x1f8> 40009a80: c8 20 60 04 st %g4, [ %g1 + 4 ] 40009a84: c2 21 20 08 st %g1, [ %g4 + 8 ] 40009a88: c6 00 60 08 ld [ %g1 + 8 ], %g3 40009a8c: 80 a0 e0 00 cmp %g3, 0 40009a90: 02 80 00 1b be 40009afc <_RBTree_Insert_color+0x268> <== NEVER TAKEN 40009a94: c6 22 60 08 st %g3, [ %o1 + 8 ] 40009a98: c6 00 60 08 ld [ %g1 + 8 ], %g3 40009a9c: c8 00 c0 00 ld [ %g3 ], %g4 40009aa0: 80 a0 40 04 cmp %g1, %g4 40009aa4: 22 80 00 03 be,a 40009ab0 <_RBTree_Insert_color+0x21c> <== ALWAYS TAKEN 40009aa8: d2 20 c0 00 st %o1, [ %g3 ] 40009aac: d2 20 e0 04 st %o1, [ %g3 + 4 ] <== NOT EXECUTED 40009ab0: 86 10 00 09 mov %o1, %g3 40009ab4: c2 22 40 00 st %g1, [ %o1 ] 40009ab8: c8 00 80 00 ld [ %g2 ], %g4 40009abc: da 01 20 04 ld [ %g4 + 4 ], %o5 40009ac0: d2 20 60 08 st %o1, [ %g1 + 8 ] 40009ac4: 92 10 00 01 mov %g1, %o1 40009ac8: 10 bf ff b3 b 40009994 <_RBTree_Insert_color+0x100> 40009acc: 82 10 00 03 mov %g3, %g1 40009ad0: c6 22 60 08 st %g3, [ %o1 + 8 ] 40009ad4: c6 00 60 08 ld [ %g1 + 8 ], %g3 40009ad8: c8 00 c0 00 ld [ %g3 ], %g4 40009adc: 80 a0 40 04 cmp %g1, %g4 40009ae0: 32 bf ff ce bne,a 40009a18 <_RBTree_Insert_color+0x184> <== ALWAYS TAKEN 40009ae4: d2 20 e0 04 st %o1, [ %g3 + 4 ] 40009ae8: 10 bf ff cc b 40009a18 <_RBTree_Insert_color+0x184> <== NOT EXECUTED 40009aec: d2 20 c0 00 st %o1, [ %g3 ] <== NOT EXECUTED 40009af0: c4 21 20 04 st %g2, [ %g4 + 4 ] 40009af4: 10 bf ff 69 b 40009898 <_RBTree_Insert_color+0x4> 40009af8: c8 20 a0 08 st %g4, [ %g2 + 8 ] 40009afc: 10 bf ff ed b 40009ab0 <_RBTree_Insert_color+0x21c> <== NOT EXECUTED 40009b00: d2 22 00 00 st %o1, [ %o0 ] <== NOT EXECUTED =============================================================================== 40009de0 <_RBTree_Iterate>: void _RBTree_Iterate( const RBTree_Control *rbtree, RBTree_Visitor visitor, void *visitor_arg ) { 40009de0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED const RBTree_Node *current = _RBTree_Minimum( rbtree ); 40009de4: 40 00 00 12 call 40009e2c <_RBTree_Minimum> <== NOT EXECUTED 40009de8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009dec: 10 80 00 0b b 40009e18 <_RBTree_Iterate+0x38> 40009df0: ba 10 00 08 mov %o0, %i5 bool stop = false; while ( !stop && current != NULL ) { stop = ( *visitor )( current, visitor_arg ); 40009df4: 9f c6 40 00 call %i1 40009df8: 90 10 00 1d mov %i5, %o0 40009dfc: b8 10 00 08 mov %o0, %i4 current = _RBTree_Successor( current ); 40009e00: 40 00 00 18 call 40009e60 <_RBTree_Successor> 40009e04: 90 10 00 1d mov %i5, %o0 while ( !stop && current != NULL ) { 40009e08: b8 1f 20 01 xor %i4, 1, %i4 40009e0c: 80 8f 20 ff btst 0xff, %i4 40009e10: 02 80 00 05 be 40009e24 <_RBTree_Iterate+0x44> <== NEVER TAKEN 40009e14: ba 10 00 08 mov %o0, %i5 40009e18: 80 a7 60 00 cmp %i5, 0 40009e1c: 12 bf ff f6 bne 40009df4 <_RBTree_Iterate+0x14> 40009e20: 92 10 00 1a mov %i2, %o1 } } 40009e24: 81 c7 e0 08 ret 40009e28: 81 e8 00 00 restore =============================================================================== 40017838 <_RBTree_Maximum>: RB_GENERATE_MINMAX( RBTree_Control, RBTree_Node, Node, static ) 40017838: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED 4001783c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40017840: 32 80 00 04 bne,a 40017850 <_RBTree_Maximum+0x18> <== NOT EXECUTED 40017844: c2 02 20 04 ld [ %o0 + 4 ], %g1 40017848: 30 80 00 07 b,a 40017864 <_RBTree_Maximum+0x2c> 4001784c: c2 02 20 04 ld [ %o0 + 4 ], %g1 40017850: 80 a0 60 00 cmp %g1, 0 40017854: 32 bf ff fe bne,a 4001784c <_RBTree_Maximum+0x14> 40017858: 90 10 00 01 mov %g1, %o0 RBTree_Node *_RBTree_Maximum( const RBTree_Control *tree ) { return RB_MAX( RBTree_Control, RTEMS_DECONST( RBTree_Control *, tree ) ); } 4001785c: 81 c3 e0 08 retl 40017860: 01 00 00 00 nop 40017864: 81 c3 e0 08 retl 40017868: 01 00 00 00 nop =============================================================================== 4000e1b8 <_RBTree_Minimum>: #endif #include #include RB_GENERATE_MINMAX( RBTree_Control, RBTree_Node, Node, static ) 4000e1b8: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED 4000e1bc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000e1c0: 32 80 00 04 bne,a 4000e1d0 <_RBTree_Minimum+0x18> <== NOT EXECUTED 4000e1c4: c2 02 00 00 ld [ %o0 ], %g1 4000e1c8: 30 80 00 07 b,a 4000e1e4 <_RBTree_Minimum+0x2c> 4000e1cc: c2 02 00 00 ld [ %o0 ], %g1 4000e1d0: 80 a0 60 00 cmp %g1, 0 4000e1d4: 32 bf ff fe bne,a 4000e1cc <_RBTree_Minimum+0x14> 4000e1d8: 90 10 00 01 mov %g1, %o0 RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static ) RBTree_Node *_RBTree_Minimum( const RBTree_Control *tree ) { return RB_MIN( RBTree_Control, RTEMS_DECONST( RBTree_Control *, tree ) ); } 4000e1dc: 81 c3 e0 08 retl 4000e1e0: 01 00 00 00 nop 4000e1e4: 81 c3 e0 08 retl 4000e1e8: 01 00 00 00 nop =============================================================================== 400179f0 <_RBTree_Postorder_first>: return RB_ROOT( the_rbtree ); 400179f0: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED ) { const RBTree_Node *the_node; the_node = _RBTree_Root( the_rbtree ); if ( the_node == NULL ) { 400179f4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400179f8: 02 80 00 0d be 40017a2c <_RBTree_Postorder_first+0x3c> <== NOT EXECUTED 400179fc: 01 00 00 00 nop if ( _RBTree_Left( the_node ) != NULL ) { 40017a00: 90 10 00 01 mov %g1, %o0 40017a04: c2 00 40 00 ld [ %g1 ], %g1 40017a08: 80 a0 60 00 cmp %g1, 0 40017a0c: 32 bf ff fe bne,a 40017a04 <_RBTree_Postorder_first+0x14> 40017a10: 90 10 00 01 mov %g1, %o0 40017a14: c2 02 20 04 ld [ %o0 + 4 ], %g1 } else if ( _RBTree_Right( the_node ) != NULL ) { 40017a18: 80 a0 60 00 cmp %g1, 0 40017a1c: 32 bf ff fa bne,a 40017a04 <_RBTree_Postorder_first+0x14> 40017a20: 90 10 00 01 mov %g1, %o0 return NULL; } return _RBTree_Postorder_dive_left( the_node, offset ); 40017a24: 81 c3 e0 08 retl 40017a28: 90 22 00 09 sub %o0, %o1, %o0 } 40017a2c: 81 c3 e0 08 retl 40017a30: 90 10 20 00 clr %o0 =============================================================================== 4001798c <_RBTree_Postorder_next>: void *_RBTree_Postorder_next( const RBTree_Node *the_node, size_t offset ) { 4001798c: c6 02 20 08 ld [ %o0 + 8 ], %g3 <== NOT EXECUTED const RBTree_Node *parent; parent = _RBTree_Parent( the_node ); if ( parent == NULL ) { 40017990: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40017994: 02 80 00 15 be 400179e8 <_RBTree_Postorder_next+0x5c> <== NOT EXECUTED 40017998: 01 00 00 00 nop return NULL; } if ( 4001799c: c2 00 c0 00 ld [ %g3 ], %g1 400179a0: 80 a2 00 01 cmp %o0, %g1 400179a4: 22 80 00 04 be,a 400179b4 <_RBTree_Postorder_next+0x28> 400179a8: c2 00 e0 04 ld [ %g3 + 4 ], %g1 && _RBTree_Right( parent ) != NULL ) { return _RBTree_Postorder_dive_left( _RBTree_Right( parent ), offset ); } return (void *) ( (uintptr_t) parent - offset ); 400179ac: 81 c3 e0 08 retl 400179b0: 90 20 c0 09 sub %g3, %o1, %o0 && _RBTree_Right( parent ) != NULL 400179b4: 80 a0 60 00 cmp %g1, 0 400179b8: 02 bf ff fd be 400179ac <_RBTree_Postorder_next+0x20> 400179bc: 84 10 00 01 mov %g1, %g2 400179c0: c2 00 40 00 ld [ %g1 ], %g1 if ( _RBTree_Left( the_node ) != NULL ) { 400179c4: 80 a0 60 00 cmp %g1, 0 400179c8: 32 bf ff fe bne,a 400179c0 <_RBTree_Postorder_next+0x34> 400179cc: 84 10 00 01 mov %g1, %g2 400179d0: c2 00 a0 04 ld [ %g2 + 4 ], %g1 } else if ( _RBTree_Right( the_node ) != NULL ) { 400179d4: 80 a0 60 00 cmp %g1, 0 400179d8: 32 bf ff fa bne,a 400179c0 <_RBTree_Postorder_next+0x34> 400179dc: 84 10 00 01 mov %g1, %g2 return _RBTree_Postorder_dive_left( _RBTree_Right( parent ), offset ); 400179e0: 81 c3 e0 08 retl 400179e4: 90 20 80 09 sub %g2, %o1, %o0 } 400179e8: 81 c3 e0 08 retl 400179ec: 90 10 20 00 clr %o0 =============================================================================== 400178fc <_RBTree_Predecessor>: RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static ) 400178fc: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 40017900: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40017904: 32 80 00 05 bne,a 40017918 <_RBTree_Predecessor+0x1c> <== NOT EXECUTED 40017908: c4 00 60 04 ld [ %g1 + 4 ], %g2 4001790c: 10 80 00 08 b 4001792c <_RBTree_Predecessor+0x30> 40017910: c2 02 20 08 ld [ %o0 + 8 ], %g1 40017914: c4 00 60 04 ld [ %g1 + 4 ], %g2 40017918: 80 a0 a0 00 cmp %g2, 0 4001791c: 32 bf ff fe bne,a 40017914 <_RBTree_Predecessor+0x18> 40017920: 82 10 00 02 mov %g2, %g1 RBTree_Node *_RBTree_Predecessor( const RBTree_Node *node ) { return RB_PREV( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) ); } 40017924: 81 c3 e0 08 retl 40017928: 90 10 00 01 mov %g1, %o0 RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static ) 4001792c: 80 a0 60 00 cmp %g1, 0 40017930: 02 bf ff fd be 40017924 <_RBTree_Predecessor+0x28> 40017934: 01 00 00 00 nop 40017938: c4 00 60 04 ld [ %g1 + 4 ], %g2 4001793c: 80 a2 00 02 cmp %o0, %g2 40017940: 02 bf ff f9 be 40017924 <_RBTree_Predecessor+0x28> 40017944: 01 00 00 00 nop 40017948: c4 00 40 00 ld [ %g1 ], %g2 4001794c: 80 a0 80 08 cmp %g2, %o0 40017950: 12 bf ff f5 bne 40017924 <_RBTree_Predecessor+0x28> <== NEVER TAKEN 40017954: 01 00 00 00 nop 40017958: c4 00 60 08 ld [ %g1 + 8 ], %g2 4001795c: 80 a0 a0 00 cmp %g2, 0 40017960: 02 80 00 09 be 40017984 <_RBTree_Predecessor+0x88> 40017964: 90 10 00 01 mov %g1, %o0 40017968: 82 10 00 02 mov %g2, %g1 4001796c: c4 00 40 00 ld [ %g1 ], %g2 40017970: 80 a0 80 08 cmp %g2, %o0 40017974: 22 bf ff fa be,a 4001795c <_RBTree_Predecessor+0x60> 40017978: c4 00 60 08 ld [ %g1 + 8 ], %g2 } 4001797c: 81 c3 e0 08 retl 40017980: 90 10 00 01 mov %g1, %o0 return RB_PREV( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) ); 40017984: 10 bf ff e8 b 40017924 <_RBTree_Predecessor+0x28> 40017988: 82 10 20 00 clr %g1 =============================================================================== 40017a34 <_RBTree_Replace_node>: void _RBTree_Replace_node( RBTree_Control *the_rbtree, RBTree_Node *victim, RBTree_Node *replacement ) { 40017a34: c2 02 60 08 ld [ %o1 + 8 ], %g1 <== NOT EXECUTED RBTree_Node *parent = _RBTree_Parent( victim ); RBTree_Node **link; RBTree_Node *child; if (parent != NULL) { 40017a38: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40017a3c: 22 80 00 07 be,a 40017a58 <_RBTree_Replace_node+0x24> <== NOT EXECUTED 40017a40: d4 22 00 00 st %o2, [ %o0 ] if ( victim == _RBTree_Left( parent ) ) { 40017a44: c4 00 40 00 ld [ %g1 ], %g2 40017a48: 80 a2 40 02 cmp %o1, %g2 40017a4c: 02 80 00 14 be 40017a9c <_RBTree_Replace_node+0x68> 40017a50: 90 00 60 04 add %g1, 4, %o0 link = _RBTree_Right_reference( parent ); } } else { link = _RBTree_Root_reference( the_rbtree ); } *link = replacement; 40017a54: d4 22 00 00 st %o2, [ %o0 ] 40017a58: c2 02 40 00 ld [ %o1 ], %g1 child = _RBTree_Left( victim ); if ( child != NULL ) { 40017a5c: 80 a0 60 00 cmp %g1, 0 40017a60: 32 80 00 02 bne,a 40017a68 <_RBTree_Replace_node+0x34> 40017a64: d4 20 60 08 st %o2, [ %g1 + 8 ] 40017a68: c2 02 60 04 ld [ %o1 + 4 ], %g1 RB_PARENT( child, Node ) = replacement; } child = _RBTree_Right( victim ); if ( child != NULL ) { 40017a6c: 80 a0 60 00 cmp %g1, 0 40017a70: 32 80 00 02 bne,a 40017a78 <_RBTree_Replace_node+0x44> 40017a74: d4 20 60 08 st %o2, [ %g1 + 8 ] RB_PARENT( child, Node ) = replacement; } *replacement = *victim; 40017a78: c2 02 40 00 ld [ %o1 ], %g1 40017a7c: c2 22 80 00 st %g1, [ %o2 ] 40017a80: c2 02 60 04 ld [ %o1 + 4 ], %g1 40017a84: c2 22 a0 04 st %g1, [ %o2 + 4 ] 40017a88: c2 02 60 08 ld [ %o1 + 8 ], %g1 40017a8c: c2 22 a0 08 st %g1, [ %o2 + 8 ] 40017a90: c2 02 60 0c ld [ %o1 + 0xc ], %g1 } 40017a94: 81 c3 e0 08 retl 40017a98: c2 22 a0 0c st %g1, [ %o2 + 0xc ] 40017a9c: 10 bf ff ee b 40017a54 <_RBTree_Replace_node+0x20> 40017aa0: 90 10 00 01 mov %g1, %o0 =============================================================================== 4001786c <_RBTree_Successor>: RB_GENERATE_NEXT( RBTree_Control, RBTree_Node, Node, static ) 4001786c: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 40017870: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40017874: 32 80 00 05 bne,a 40017888 <_RBTree_Successor+0x1c> <== NOT EXECUTED 40017878: c4 00 40 00 ld [ %g1 ], %g2 4001787c: 10 80 00 08 b 4001789c <_RBTree_Successor+0x30> 40017880: c2 02 20 08 ld [ %o0 + 8 ], %g1 40017884: c4 00 40 00 ld [ %g1 ], %g2 40017888: 80 a0 a0 00 cmp %g2, 0 4001788c: 32 bf ff fe bne,a 40017884 <_RBTree_Successor+0x18> 40017890: 82 10 00 02 mov %g2, %g1 RBTree_Node *_RBTree_Successor( const RBTree_Node *node ) { return RB_NEXT( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) ); } 40017894: 81 c3 e0 08 retl 40017898: 90 10 00 01 mov %g1, %o0 RB_GENERATE_NEXT( RBTree_Control, RBTree_Node, Node, static ) 4001789c: 80 a0 60 00 cmp %g1, 0 400178a0: 02 bf ff fd be 40017894 <_RBTree_Successor+0x28> 400178a4: 01 00 00 00 nop 400178a8: c4 00 40 00 ld [ %g1 ], %g2 400178ac: 80 a2 00 02 cmp %o0, %g2 400178b0: 02 bf ff f9 be 40017894 <_RBTree_Successor+0x28> 400178b4: 01 00 00 00 nop 400178b8: c4 00 60 04 ld [ %g1 + 4 ], %g2 400178bc: 80 a0 80 08 cmp %g2, %o0 400178c0: 12 bf ff f5 bne 40017894 <_RBTree_Successor+0x28> <== NEVER TAKEN 400178c4: 01 00 00 00 nop 400178c8: c4 00 60 08 ld [ %g1 + 8 ], %g2 400178cc: 80 a0 a0 00 cmp %g2, 0 400178d0: 02 80 00 09 be 400178f4 <_RBTree_Successor+0x88> 400178d4: 90 10 00 01 mov %g1, %o0 400178d8: 82 10 00 02 mov %g2, %g1 400178dc: c4 00 60 04 ld [ %g1 + 4 ], %g2 400178e0: 80 a0 80 08 cmp %g2, %o0 400178e4: 22 bf ff fa be,a 400178cc <_RBTree_Successor+0x60> 400178e8: c4 00 60 08 ld [ %g1 + 8 ], %g2 } 400178ec: 81 c3 e0 08 retl 400178f0: 90 10 00 01 mov %g1, %o0 return RB_NEXT( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) ); 400178f4: 10 bf ff e8 b 40017894 <_RBTree_Successor+0x28> 400178f8: 82 10 20 00 clr %g1 =============================================================================== 40008090 <_RTEMS_Allocator_is_owner>: } bool _RTEMS_Allocator_is_owner( void ) { return _API_Mutex_Is_owner( &_RTEMS_Allocator_Mutex ); 40008090: 11 10 00 4f sethi %hi(0x40013c00), %o0 <== NOT EXECUTED 40008094: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 40013ee8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 40008098: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4000809c: 40 00 00 02 call 400080a4 <_API_Mutex_Is_owner> <== NOT EXECUTED 400080a0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 40007070 <_RTEMS_Unlock_allocator>: } void _RTEMS_Unlock_allocator( void ) { _API_Mutex_Unlock( &_RTEMS_Allocator_Mutex ); 40007070: 11 10 00 6d sethi %hi(0x4001b400), %o0 <== NOT EXECUTED 40007074: 90 12 20 cc or %o0, 0xcc, %o0 ! 4001b4cc <_RTEMS_Allocator_Mutex> 40007078: 82 13 c0 00 mov %o7, %g1 4000707c: 40 00 00 0e call 400070b4 <_API_Mutex_Unlock> 40007080: 9e 10 40 00 mov %g1, %o7 =============================================================================== 4000e7a4 <_SMP_barrier_Wait>: SMP_barrier_Control *control, SMP_barrier_State *state, unsigned int count ) { unsigned int sense = ~state->sense; 4000e7a4: c4 02 40 00 ld [ %o1 ], %g2 <== NOT EXECUTED 4000e7a8: 84 38 00 02 xnor %g0, %g2, %g2 <== NOT EXECUTED unsigned int previous_value; bool performed_release; state->sense = sense; 4000e7ac: c4 22 40 00 st %g2, [ %o1 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000e7b0: 91 d0 20 09 ta 9 <== NOT EXECUTED *obj = val + arg; 4000e7b4: c6 02 00 00 ld [ %o0 ], %g3 <== NOT EXECUTED 4000e7b8: 86 00 e0 01 inc %g3 <== NOT EXECUTED 4000e7bc: c6 22 00 00 st %g3, [ %o0 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e7c0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e7c4: 01 00 00 00 nop &control->value, 1U, ATOMIC_ORDER_RELAXED ); if ( previous_value + 1U == count ) { 4000e7c8: 80 a2 80 03 cmp %o2, %g3 4000e7cc: 02 80 00 09 be 4000e7f0 <_SMP_barrier_Wait+0x4c> <== ALWAYS TAKEN 4000e7d0: 01 00 00 00 nop 4000e7d4: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED _Atomic_Store_uint( &control->value, 0U, ATOMIC_ORDER_RELAXED ); _Atomic_Store_uint( &control->sense, sense, ATOMIC_ORDER_RELEASE ); performed_release = true; } else { while ( 4000e7d8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 4000e7dc: 32 bf ff ff bne,a 4000e7d8 <_SMP_barrier_Wait+0x34> <== NOT EXECUTED 4000e7e0: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED _Atomic_Load_uint( &control->sense, ATOMIC_ORDER_ACQUIRE ) != sense ) { /* Wait */ } performed_release = false; 4000e7e4: 82 10 20 00 clr %g1 <== NOT EXECUTED } return performed_release; } 4000e7e8: 81 c3 e0 08 retl <== NOT EXECUTED 4000e7ec: 90 08 60 01 and %g1, 1, %o0 <== NOT EXECUTED *obj = desired; 4000e7f0: c0 22 00 00 clr [ %o0 ] performed_release = true; 4000e7f4: 82 10 20 01 mov 1, %g1 4000e7f8: c4 22 20 04 st %g2, [ %o0 + 4 ] } 4000e7fc: 81 c3 e0 08 retl 4000e800: 90 08 60 01 and %g1, 1, %o0 =============================================================================== 4000b4cc <_Sched_Index>: int _Sched_Index( void ) { Thread_Control *executing = _Thread_Get_executing(); return (int) _Scheduler_Get_index( _Thread_Scheduler_get_home( executing ) ); } 4000b4cc: 81 c3 e0 08 retl <== NOT EXECUTED 4000b4d0: 90 10 20 00 clr %o0 =============================================================================== 4000b4d4 <_Sched_Name_to_index>: int _Sched_Name_to_index( const char *name, size_t len ) { uint32_t name_32 = 0; size_t i = 0; while ( i < 4 && i < len ) { 4000b4d4: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED 4000b4d8: 02 80 00 15 be 4000b52c <_Sched_Name_to_index+0x58> <== NOT EXECUTED 4000b4dc: 86 10 20 18 mov 0x18, %g3 size_t i = 0; 4000b4e0: 82 10 20 00 clr %g1 uint32_t name_32 = 0; 4000b4e4: 10 80 00 05 b 4000b4f8 <_Sched_Name_to_index+0x24> 4000b4e8: 88 10 20 00 clr %g4 while ( i < 4 && i < len ) { 4000b4ec: 80 a0 40 09 cmp %g1, %o1 4000b4f0: 3a 80 00 0a bcc,a 4000b518 <_Sched_Name_to_index+0x44> 4000b4f4: 03 10 00 48 sethi %hi(0x40012000), %g1 name_32 |= ( (uint32_t) ( (uint8_t) *name ) ) << ( ( 3 - i ) * 8 ); 4000b4f8: c4 0a 00 01 ldub [ %o0 + %g1 ], %g2 4000b4fc: 85 28 80 03 sll %g2, %g3, %g2 ++name; ++i; 4000b500: 82 00 60 01 inc %g1 name_32 |= ( (uint32_t) ( (uint8_t) *name ) ) << ( ( 3 - i ) * 8 ); 4000b504: 88 11 00 02 or %g4, %g2, %g4 while ( i < 4 && i < len ) { 4000b508: 80 a0 60 03 cmp %g1, 3 4000b50c: 08 bf ff f8 bleu 4000b4ec <_Sched_Name_to_index+0x18> 4000b510: 86 00 ff f8 add %g3, -8, %g3 } for ( i = 0 ; i < _Scheduler_Count ; ++i ) { const Scheduler_Control *scheduler = &_Scheduler_Table[ i ]; if ( scheduler->name == name_32 ) { 4000b514: 03 10 00 48 sethi %hi(0x40012000), %g1 4000b518: c2 00 61 e8 ld [ %g1 + 0x1e8 ], %g1 ! 400121e8 <_Scheduler_Table+0x48> 4000b51c: 88 18 40 04 xor %g1, %g4, %g4 return (int) i; } } return -1; } 4000b520: 80 a0 00 04 cmp %g0, %g4 4000b524: 81 c3 e0 08 retl 4000b528: 90 60 20 00 subx %g0, 0, %o0 if ( scheduler->name == name_32 ) { 4000b52c: 03 10 00 48 sethi %hi(0x40012000), %g1 4000b530: c2 00 61 e8 ld [ %g1 + 0x1e8 ], %g1 ! 400121e8 <_Scheduler_Table+0x48> uint32_t name_32 = 0; 4000b534: 88 10 20 00 clr %g4 if ( scheduler->name == name_32 ) { 4000b538: 88 18 40 04 xor %g1, %g4, %g4 } 4000b53c: 80 a0 00 04 cmp %g0, %g4 4000b540: 81 c3 e0 08 retl 4000b544: 90 60 20 00 subx %g0, 0, %o0 =============================================================================== 4000b548 <_Sched_Processor_count>: if ( i < _Scheduler_Count ) { return _Scheduler_Get_processor_count( &_Scheduler_Table[ i ] ); } else { return 0; } } 4000b548: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 4000b54c: 81 c3 e0 08 retl <== NOT EXECUTED 4000b550: 90 60 3f ff subx %g0, -1, %o0 =============================================================================== 4000ae8c <_Scheduler_CBS_Attach_thread>: int _Scheduler_CBS_Attach_thread ( Scheduler_CBS_Server_id server_id, rtems_id task_id ) { 4000ae8c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Scheduler_CBS_Server *server; ISR_lock_Context lock_context; Thread_Control *the_thread; Scheduler_CBS_Node *node; if ( server_id >= _Scheduler_CBS_Maximum_servers ) { 4000ae90: 03 10 00 4b sethi %hi(0x40012c00), %g1 <== NOT EXECUTED 4000ae94: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 40012fd0 <_Scheduler_CBS_Maximum_servers> <== NOT EXECUTED 4000ae98: 80 a0 40 18 cmp %g1, %i0 <== NOT EXECUTED 4000ae9c: 08 80 00 2c bleu 4000af4c <_Scheduler_CBS_Attach_thread+0xc0> <== NOT EXECUTED 4000aea0: 3b 10 00 56 sethi %hi(0x40015800), %i5 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; } server = &_Scheduler_CBS_Server_list[ server_id ]; 4000aea4: b1 2e 20 05 sll %i0, 5, %i0 4000aea8: ba 17 62 08 or %i5, 0x208, %i5 4000aeac: b8 06 00 1d add %i0, %i5, %i4 if ( !server->initialized ) { 4000aeb0: c2 0f 20 1c ldub [ %i4 + 0x1c ], %g1 4000aeb4: 80 a0 60 00 cmp %g1, 0 4000aeb8: 02 80 00 27 be 4000af54 <_Scheduler_CBS_Attach_thread+0xc8> 4000aebc: 01 00 00 00 nop return SCHEDULER_CBS_ERROR_NOSERVER; } if ( server->task_id != -1 ) { 4000aec0: c2 07 40 18 ld [ %i5 + %i0 ], %g1 4000aec4: 80 a0 7f ff cmp %g1, -1 4000aec8: 12 80 00 1a bne 4000af30 <_Scheduler_CBS_Attach_thread+0xa4> 4000aecc: 92 07 bf fc add %fp, -4, %o1 return SCHEDULER_CBS_ERROR_FULL; } the_thread = _Thread_Get( task_id, &lock_context ); 4000aed0: 40 00 05 5b call 4000c43c <_Thread_Get> 4000aed4: 90 10 00 19 mov %i1, %o0 if ( the_thread == NULL ) { 4000aed8: 80 a2 20 00 cmp %o0, 0 4000aedc: 02 80 00 1c be 4000af4c <_Scheduler_CBS_Attach_thread+0xc0> 4000aee0: 01 00 00 00 nop 4000aee4: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; } node = _Scheduler_CBS_Thread_get_node( the_thread ); if ( node->cbs_server != NULL ) { 4000aee8: c4 00 60 50 ld [ %g1 + 0x50 ], %g2 4000aeec: 80 a0 a0 00 cmp %g2, 0 4000aef0: 12 80 00 12 bne 4000af38 <_Scheduler_CBS_Attach_thread+0xac> <== NEVER TAKEN 4000aef4: 01 00 00 00 nop <== NOT EXECUTED _ISR_lock_ISR_enable( &lock_context ); return SCHEDULER_CBS_ERROR_FULL; } node->cbs_server = server; 4000aef8: f8 20 60 50 st %i4, [ %g1 + 0x50 ] <== NOT EXECUTED server->task_id = task_id; the_thread->budget_callout = _Scheduler_CBS_Budget_callout; 4000aefc: 03 10 00 2d sethi %hi(0x4000b400), %g1 <== NOT EXECUTED server->task_id = task_id; 4000af00: f2 27 40 18 st %i1, [ %i5 + %i0 ] <== NOT EXECUTED the_thread->budget_callout = _Scheduler_CBS_Budget_callout; 4000af04: 82 10 60 40 or %g1, 0x40, %g1 <== NOT EXECUTED 4000af08: c2 22 20 94 st %g1, [ %o0 + 0x94 ] <== NOT EXECUTED the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 4000af0c: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 4000af10: c2 22 20 90 st %g1, [ %o0 + 0x90 ] <== NOT EXECUTED the_thread->is_preemptible = true; 4000af14: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 4000af18: c2 2a 20 89 stb %g1, [ %o0 + 0x89 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000af1c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000af20: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000af24: 01 00 00 00 nop _ISR_lock_ISR_enable( &lock_context ); return SCHEDULER_CBS_OK; 4000af28: 81 c7 e0 08 ret 4000af2c: 91 e8 20 00 restore %g0, 0, %o0 } 4000af30: 81 c7 e0 08 ret 4000af34: 91 e8 3f e6 restore %g0, -26, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000af38: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000af3c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000af40: 01 00 00 00 nop <== NOT EXECUTED return SCHEDULER_CBS_ERROR_FULL; 4000af44: 81 c7 e0 08 ret <== NOT EXECUTED 4000af48: 91 e8 3f e6 restore %g0, -26, %o0 <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 4000af4c: 81 c7 e0 08 ret 4000af50: 91 e8 3f ee restore %g0, -18, %o0 return SCHEDULER_CBS_ERROR_NOSERVER; 4000af54: 81 c7 e0 08 ret 4000af58: 91 e8 3f e7 restore %g0, -25, %o0 =============================================================================== 4000b440 <_Scheduler_CBS_Budget_callout>: #include void _Scheduler_CBS_Budget_callout( Thread_Control *the_thread ) { 4000b440: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED 4000b444: fa 06 20 38 ld [ %i0 + 0x38 ], %i5 <== NOT EXECUTED node = _Scheduler_CBS_Thread_get_node( the_thread ); /* Put violating task to background until the end of period. */ _Thread_queue_Context_clear_priority_updates( &queue_context ); _Scheduler_CBS_Cancel_job( 4000b448: d4 07 60 54 ld [ %i5 + 0x54 ], %o2 <== NOT EXECUTED 4000b44c: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED 4000b450: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4000b454: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000b458: 40 00 00 21 call 4000b4dc <_Scheduler_CBS_Cancel_job> <== NOT EXECUTED 4000b45c: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED NULL, the_thread, node->deadline_node, &queue_context ); _Thread_Priority_update( &queue_context ); 4000b460: 40 00 02 f5 call 4000c034 <_Thread_Priority_update> 4000b464: 90 07 bf dc add %fp, -36, %o0 /* Invoke callback function if any. */ if ( node->cbs_server->cbs_budget_overrun ) { 4000b468: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 4000b46c: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 4000b470: 80 a0 a0 00 cmp %g2, 0 4000b474: 02 80 00 09 be 4000b498 <_Scheduler_CBS_Budget_callout+0x58> <== NEVER TAKEN 4000b478: 01 00 00 00 nop _Scheduler_CBS_Get_server_id( 4000b47c: d0 00 40 00 ld [ %g1 ], %o0 4000b480: 7f ff ff ce call 4000b3b8 <_Scheduler_CBS_Get_server_id> 4000b484: 92 07 bf d8 add %fp, -40, %o1 node->cbs_server->task_id, &server_id ); node->cbs_server->cbs_budget_overrun( server_id ); 4000b488: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 4000b48c: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 4000b490: 9f c0 40 00 call %g1 4000b494: d0 07 bf d8 ld [ %fp + -40 ], %o0 } } 4000b498: 81 c7 e0 08 ret 4000b49c: 81 e8 00 00 restore =============================================================================== 4000a4e0 <_Scheduler_CBS_Cancel_job>: const Scheduler_Control *scheduler, Thread_Control *the_thread, Priority_Node *priority_node, Thread_queue_Context *queue_context ) { 4000a4e0: c2 02 60 38 ld [ %o1 + 0x38 ], %g1 <== NOT EXECUTED Scheduler_CBS_Node *node; node = _Scheduler_CBS_Thread_get_node( the_thread ); if ( node->deadline_node != NULL ) { 4000a4e4: c4 00 60 54 ld [ %g1 + 0x54 ], %g2 <== NOT EXECUTED 4000a4e8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000a4ec: 02 80 00 06 be 4000a504 <_Scheduler_CBS_Cancel_job+0x24> <== NOT EXECUTED 4000a4f0: 01 00 00 00 nop _Assert( node->deadline_node == priority_node ); node->deadline_node = NULL; 4000a4f4: c0 20 60 54 clr [ %g1 + 0x54 ] _Scheduler_EDF_Cancel_job( 4000a4f8: 82 13 c0 00 mov %o7, %g1 4000a4fc: 40 00 01 0e call 4000a934 <_Scheduler_EDF_Cancel_job> 4000a500: 9e 10 40 00 mov %g1, %o7 the_thread, priority_node, queue_context ); } } 4000a504: 81 c3 e0 08 retl 4000a508: 01 00 00 00 nop =============================================================================== 4000af5c <_Scheduler_CBS_Cleanup>: #include #include int _Scheduler_CBS_Cleanup (void) { 4000af5c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 4000af60: 03 10 00 4b sethi %hi(0x40012c00), %g1 <== NOT EXECUTED 4000af64: f6 00 63 d0 ld [ %g1 + 0x3d0 ], %i3 ! 40012fd0 <_Scheduler_CBS_Maximum_servers> <== NOT EXECUTED 4000af68: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 4000af6c: 02 80 00 12 be 4000afb4 <_Scheduler_CBS_Cleanup+0x58> <== NOT EXECUTED 4000af70: 39 10 00 56 sethi %hi(0x40015800), %i4 4000af74: ba 10 20 00 clr %i5 4000af78: 10 80 00 05 b 4000af8c <_Scheduler_CBS_Cleanup+0x30> 4000af7c: b8 17 22 24 or %i4, 0x224, %i4 4000af80: 80 a7 40 1b cmp %i5, %i3 4000af84: 02 80 00 0c be 4000afb4 <_Scheduler_CBS_Cleanup+0x58> 4000af88: b8 07 20 20 add %i4, 0x20, %i4 if ( _Scheduler_CBS_Server_list[ i ].initialized ) 4000af8c: c2 0f 00 00 ldub [ %i4 ], %g1 4000af90: 80 a0 60 00 cmp %g1, 0 4000af94: 22 bf ff fb be,a 4000af80 <_Scheduler_CBS_Cleanup+0x24> 4000af98: ba 07 60 01 inc %i5 _Scheduler_CBS_Destroy_server( i ); 4000af9c: 40 00 00 43 call 4000b0a8 <_Scheduler_CBS_Destroy_server> 4000afa0: 90 10 00 1d mov %i5, %o0 for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 4000afa4: ba 07 60 01 inc %i5 4000afa8: 80 a7 40 1b cmp %i5, %i3 4000afac: 12 bf ff f8 bne 4000af8c <_Scheduler_CBS_Cleanup+0x30> <== ALWAYS TAKEN 4000afb0: b8 07 20 20 add %i4, 0x20, %i4 } return SCHEDULER_CBS_OK; } 4000afb4: 81 c7 e0 08 ret 4000afb8: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 4000afbc <_Scheduler_CBS_Create_server>: ) { unsigned int i; Scheduler_CBS_Server *the_server; if ( params->budget <= 0 || 4000afbc: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED 4000afc0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000afc4: 04 80 00 2a ble 4000b06c <_Scheduler_CBS_Create_server+0xb0> <== NOT EXECUTED 4000afc8: 01 00 00 00 nop 4000afcc: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 4000afd0: 80 a0 60 00 cmp %g1, 0 4000afd4: 04 80 00 2e ble 4000b08c <_Scheduler_CBS_Create_server+0xd0> <== ALWAYS TAKEN 4000afd8: 03 10 00 4b sethi %hi(0x40012c00), %g1 params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 4000afdc: c8 00 63 d0 ld [ %g1 + 0x3d0 ], %g4 ! 40012fd0 <_Scheduler_CBS_Maximum_servers> 4000afe0: 80 a1 20 00 cmp %g4, 0 4000afe4: 02 80 00 11 be 4000b028 <_Scheduler_CBS_Create_server+0x6c> <== NEVER TAKEN 4000afe8: 1b 10 00 56 sethi %hi(0x40015800), %o5 if ( !_Scheduler_CBS_Server_list[i].initialized ) 4000afec: 9a 13 62 08 or %o5, 0x208, %o5 ! 40015a08 <_Scheduler_CBS_Server_list> 4000aff0: c2 0b 60 1c ldub [ %o5 + 0x1c ], %g1 4000aff4: 80 a0 60 00 cmp %g1, 0 4000aff8: 02 80 00 0e be 4000b030 <_Scheduler_CBS_Create_server+0x74> 4000affc: 84 03 60 3c add %o5, 0x3c, %g2 for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 4000b000: 10 80 00 06 b 4000b018 <_Scheduler_CBS_Create_server+0x5c> 4000b004: 82 10 20 00 clr %g1 if ( !_Scheduler_CBS_Server_list[i].initialized ) 4000b008: c6 08 bf e0 ldub [ %g2 + -32 ], %g3 4000b00c: 80 a0 e0 00 cmp %g3, 0 4000b010: 22 80 00 0a be,a 4000b038 <_Scheduler_CBS_Create_server+0x7c> 4000b014: c2 22 80 00 st %g1, [ %o2 ] for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 4000b018: 82 00 60 01 inc %g1 4000b01c: 80 a1 00 01 cmp %g4, %g1 4000b020: 12 bf ff fa bne 4000b008 <_Scheduler_CBS_Create_server+0x4c> 4000b024: 84 00 a0 20 add %g2, 0x20, %g2 break; } if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; 4000b028: 81 c3 e0 08 retl 4000b02c: 90 10 3f e6 mov -26, %o0 for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 4000b030: 82 10 20 00 clr %g1 *server_id = i; 4000b034: c2 22 80 00 st %g1, [ %o2 ] the_server = &_Scheduler_CBS_Server_list[*server_id]; the_server->parameters = *params; 4000b038: 83 28 60 05 sll %g1, 5, %g1 4000b03c: d4 1a 00 00 ldd [ %o0 ], %o2 4000b040: 84 03 40 01 add %o5, %g1, %g2 4000b044: d4 38 a0 08 std %o2, [ %g2 + 8 ] the_server->task_id = -1; 4000b048: 86 10 3f ff mov -1, %g3 the_server->parameters = *params; 4000b04c: d4 1a 20 08 ldd [ %o0 + 8 ], %o2 4000b050: d4 38 a0 10 std %o2, [ %g2 + 0x10 ] the_server->cbs_budget_overrun = budget_overrun_callback; the_server->initialized = true; return SCHEDULER_CBS_OK; 4000b054: 90 10 20 00 clr %o0 the_server->task_id = -1; 4000b058: c6 23 40 01 st %g3, [ %o5 + %g1 ] the_server->initialized = true; 4000b05c: 82 10 20 01 mov 1, %g1 the_server->cbs_budget_overrun = budget_overrun_callback; 4000b060: d2 20 a0 18 st %o1, [ %g2 + 0x18 ] } 4000b064: 81 c3 e0 08 retl 4000b068: c2 28 a0 1c stb %g1, [ %g2 + 0x1c ] if ( params->budget <= 0 || 4000b06c: 12 80 00 06 bne 4000b084 <_Scheduler_CBS_Create_server+0xc8> 4000b070: 01 00 00 00 nop 4000b074: c2 02 20 0c ld [ %o0 + 0xc ], %g1 4000b078: 80 a0 60 00 cmp %g1, 0 4000b07c: 32 bf ff d5 bne,a 4000afd0 <_Scheduler_CBS_Create_server+0x14> <== ALWAYS TAKEN 4000b080: c2 02 00 00 ld [ %o0 ], %g1 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 4000b084: 81 c3 e0 08 retl 4000b088: 90 10 3f ee mov -18, %o0 if ( params->budget <= 0 || 4000b08c: 12 bf ff fe bne 4000b084 <_Scheduler_CBS_Create_server+0xc8> 4000b090: 01 00 00 00 nop 4000b094: c2 02 20 04 ld [ %o0 + 4 ], %g1 4000b098: 80 a0 60 00 cmp %g1, 0 4000b09c: 12 bf ff d0 bne 4000afdc <_Scheduler_CBS_Create_server+0x20> <== ALWAYS TAKEN 4000b0a0: 03 10 00 4b sethi %hi(0x40012c00), %g1 4000b0a4: 30 bf ff f8 b,a 4000b084 <_Scheduler_CBS_Create_server+0xc8> <== NOT EXECUTED =============================================================================== 4000b0a8 <_Scheduler_CBS_Destroy_server>: #include int _Scheduler_CBS_Destroy_server ( Scheduler_CBS_Server_id server_id ) { 4000b0a8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED int ret = SCHEDULER_CBS_OK; rtems_id tid; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 4000b0ac: 05 10 00 4b sethi %hi(0x40012c00), %g2 <== NOT EXECUTED 4000b0b0: c4 00 a3 d0 ld [ %g2 + 0x3d0 ], %g2 ! 40012fd0 <_Scheduler_CBS_Maximum_servers> <== NOT EXECUTED 4000b0b4: 80 a0 80 18 cmp %g2, %i0 <== NOT EXECUTED 4000b0b8: 08 80 00 17 bleu 4000b114 <_Scheduler_CBS_Destroy_server+0x6c> <== NOT EXECUTED 4000b0bc: 90 10 00 18 mov %i0, %o0 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id].initialized ) 4000b0c0: b9 2e 20 05 sll %i0, 5, %i4 4000b0c4: 3b 10 00 56 sethi %hi(0x40015800), %i5 4000b0c8: ba 17 62 08 or %i5, 0x208, %i5 ! 40015a08 <_Scheduler_CBS_Server_list> 4000b0cc: 84 07 40 1c add %i5, %i4, %g2 4000b0d0: c4 08 a0 1c ldub [ %g2 + 0x1c ], %g2 4000b0d4: 80 a0 a0 00 cmp %g2, 0 4000b0d8: 02 80 00 11 be 4000b11c <_Scheduler_CBS_Destroy_server+0x74> 4000b0dc: 01 00 00 00 nop return SCHEDULER_CBS_ERROR_NOSERVER; if ( (tid = _Scheduler_CBS_Server_list[server_id].task_id) != -1 ) 4000b0e0: d2 07 40 1c ld [ %i5 + %i4 ], %o1 4000b0e4: 80 a2 7f ff cmp %o1, -1 4000b0e8: 12 80 00 06 bne 4000b100 <_Scheduler_CBS_Destroy_server+0x58> 4000b0ec: b0 10 20 00 clr %i0 ret = _Scheduler_CBS_Detach_thread ( server_id, tid ); _Scheduler_CBS_Server_list[server_id].initialized = false; 4000b0f0: ba 07 40 1c add %i5, %i4, %i5 4000b0f4: c0 2f 60 1c clrb [ %i5 + 0x1c ] return ret; 4000b0f8: 81 c7 e0 08 ret 4000b0fc: 81 e8 00 00 restore ret = _Scheduler_CBS_Detach_thread ( server_id, tid ); 4000b100: 40 00 00 09 call 4000b124 <_Scheduler_CBS_Detach_thread> 4000b104: ba 07 40 1c add %i5, %i4, %i5 _Scheduler_CBS_Server_list[server_id].initialized = false; 4000b108: c0 2f 60 1c clrb [ %i5 + 0x1c ] return ret; 4000b10c: 81 c7 e0 08 ret 4000b110: 91 e8 00 08 restore %g0, %o0, %o0 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 4000b114: 81 c7 e0 08 ret 4000b118: 91 e8 3f ee restore %g0, -18, %o0 } 4000b11c: 81 c7 e0 08 ret 4000b120: 91 e8 3f e7 restore %g0, -25, %o0 =============================================================================== 4000b124 <_Scheduler_CBS_Detach_thread>: int _Scheduler_CBS_Detach_thread ( Scheduler_CBS_Server_id server_id, rtems_id task_id ) { 4000b124: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Scheduler_CBS_Server *server; ISR_lock_Context lock_context; Thread_Control *the_thread; Scheduler_CBS_Node *node; if ( server_id >= _Scheduler_CBS_Maximum_servers ) { 4000b128: 03 10 00 4b sethi %hi(0x40012c00), %g1 <== NOT EXECUTED 4000b12c: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 40012fd0 <_Scheduler_CBS_Maximum_servers> <== NOT EXECUTED 4000b130: 80 a0 40 18 cmp %g1, %i0 <== NOT EXECUTED 4000b134: 08 80 00 21 bleu 4000b1b8 <_Scheduler_CBS_Detach_thread+0x94> <== NOT EXECUTED 4000b138: 3b 10 00 56 sethi %hi(0x40015800), %i5 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; } server = &_Scheduler_CBS_Server_list[ server_id ]; if ( !server->initialized ) { 4000b13c: b1 2e 20 05 sll %i0, 5, %i0 4000b140: ba 17 62 08 or %i5, 0x208, %i5 4000b144: 82 07 40 18 add %i5, %i0, %g1 4000b148: c2 08 60 1c ldub [ %g1 + 0x1c ], %g1 4000b14c: 80 a0 60 00 cmp %g1, 0 4000b150: 02 80 00 1c be 4000b1c0 <_Scheduler_CBS_Detach_thread+0x9c> 4000b154: 01 00 00 00 nop return SCHEDULER_CBS_ERROR_NOSERVER; } if ( server->task_id != task_id ) { 4000b158: d0 07 40 18 ld [ %i5 + %i0 ], %o0 4000b15c: 80 a2 00 19 cmp %o0, %i1 4000b160: 12 80 00 16 bne 4000b1b8 <_Scheduler_CBS_Detach_thread+0x94> 4000b164: 01 00 00 00 nop return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; } the_thread = _Thread_Get( task_id, &lock_context ); 4000b168: 40 00 04 b5 call 4000c43c <_Thread_Get> 4000b16c: 92 07 bf fc add %fp, -4, %o1 if ( the_thread == NULL ) { 4000b170: 80 a2 20 00 cmp %o0, 0 4000b174: 02 80 00 11 be 4000b1b8 <_Scheduler_CBS_Detach_thread+0x94> 4000b178: 01 00 00 00 nop return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; } node = _Scheduler_CBS_Thread_get_node( the_thread ); node->cbs_server = NULL; 4000b17c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 <== NOT EXECUTED 4000b180: c0 20 60 50 clr [ %g1 + 0x50 ] <== NOT EXECUTED server->task_id = -1; 4000b184: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED 4000b188: c2 27 40 18 st %g1, [ %i5 + %i0 ] <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000b18c: c6 02 20 b0 ld [ %o0 + 0xb0 ], %g3 <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 4000b190: c4 02 20 b4 ld [ %o0 + 0xb4 ], %g2 <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 4000b194: c2 0a 20 ac ldub [ %o0 + 0xac ], %g1 <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000b198: c6 22 20 90 st %g3, [ %o0 + 0x90 ] <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 4000b19c: c4 22 20 94 st %g2, [ %o0 + 0x94 ] <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 4000b1a0: c2 2a 20 89 stb %g1, [ %o0 + 0x89 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000b1a4: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b1a8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b1ac: 01 00 00 00 nop _ISR_lock_ISR_enable( &lock_context ); return SCHEDULER_CBS_OK; 4000b1b0: 81 c7 e0 08 ret 4000b1b4: 91 e8 20 00 restore %g0, 0, %o0 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 4000b1b8: 81 c7 e0 08 ret 4000b1bc: 91 e8 3f ee restore %g0, -18, %o0 } 4000b1c0: 81 c7 e0 08 ret 4000b1c4: 91 e8 3f e7 restore %g0, -25, %o0 =============================================================================== 4000b1c8 <_Scheduler_CBS_Get_approved_budget>: int _Scheduler_CBS_Get_approved_budget ( Scheduler_CBS_Server_id server_id, time_t *approved_budget ) { if ( server_id >= _Scheduler_CBS_Maximum_servers ) 4000b1c8: 03 10 00 4b sethi %hi(0x40012c00), %g1 <== NOT EXECUTED 4000b1cc: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 40012fd0 <_Scheduler_CBS_Maximum_servers> <== NOT EXECUTED 4000b1d0: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED 4000b1d4: 08 80 00 0d bleu 4000b208 <_Scheduler_CBS_Get_approved_budget+0x40> <== NOT EXECUTED 4000b1d8: 83 2a 20 05 sll %o0, 5, %g1 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id].initialized ) 4000b1dc: 11 10 00 56 sethi %hi(0x40015800), %o0 4000b1e0: 90 12 22 08 or %o0, 0x208, %o0 ! 40015a08 <_Scheduler_CBS_Server_list> 4000b1e4: 90 02 00 01 add %o0, %g1, %o0 4000b1e8: c2 0a 20 1c ldub [ %o0 + 0x1c ], %g1 4000b1ec: 80 a0 60 00 cmp %g1, 0 4000b1f0: 02 80 00 08 be 4000b210 <_Scheduler_CBS_Get_approved_budget+0x48> 4000b1f4: 01 00 00 00 nop return SCHEDULER_CBS_ERROR_NOSERVER; *approved_budget = _Scheduler_CBS_Server_list[server_id].parameters.budget; 4000b1f8: c4 1a 20 10 ldd [ %o0 + 0x10 ], %g2 4000b1fc: c4 3a 40 00 std %g2, [ %o1 ] return SCHEDULER_CBS_OK; 4000b200: 81 c3 e0 08 retl 4000b204: 90 10 20 00 clr %o0 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 4000b208: 81 c3 e0 08 retl 4000b20c: 90 10 3f ee mov -18, %o0 } 4000b210: 81 c3 e0 08 retl 4000b214: 90 10 3f e7 mov -25, %o0 =============================================================================== 4000b218 <_Scheduler_CBS_Get_execution_time>: int _Scheduler_CBS_Get_execution_time ( Scheduler_CBS_Server_id server_id, time_t *exec_time, time_t *abs_time ) { 4000b218: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Scheduler_CBS_Server *server; ISR_lock_Context lock_context; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) { 4000b21c: 03 10 00 4b sethi %hi(0x40012c00), %g1 <== NOT EXECUTED 4000b220: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 40012fd0 <_Scheduler_CBS_Maximum_servers> <== NOT EXECUTED 4000b224: 80 a0 40 18 cmp %g1, %i0 <== NOT EXECUTED 4000b228: 08 80 00 22 bleu 4000b2b0 <_Scheduler_CBS_Get_execution_time+0x98> <== NOT EXECUTED 4000b22c: 03 10 00 56 sethi %hi(0x40015800), %g1 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; } server = &_Scheduler_CBS_Server_list[ server_id ]; if ( !server->initialized ) { 4000b230: b1 2e 20 05 sll %i0, 5, %i0 4000b234: 82 10 62 08 or %g1, 0x208, %g1 4000b238: ba 00 40 18 add %g1, %i0, %i5 4000b23c: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2 4000b240: 80 a0 a0 00 cmp %g2, 0 4000b244: 02 80 00 1d be 4000b2b8 <_Scheduler_CBS_Get_execution_time+0xa0> 4000b248: 01 00 00 00 nop return SCHEDULER_CBS_ERROR_NOSERVER; } if ( server->task_id == -1 ) { 4000b24c: d0 00 40 18 ld [ %g1 + %i0 ], %o0 4000b250: 80 a2 3f ff cmp %o0, -1 4000b254: 22 80 00 11 be,a 4000b298 <_Scheduler_CBS_Get_execution_time+0x80> 4000b258: c0 26 40 00 clr [ %i1 ] *exec_time = 0; return SCHEDULER_CBS_OK; } the_thread = _Thread_Get( server->task_id, &lock_context ); 4000b25c: 40 00 04 78 call 4000c43c <_Thread_Get> 4000b260: 92 07 bf fc add %fp, -4, %o1 if ( the_thread != NULL ) { 4000b264: 80 a2 20 00 cmp %o0, 0 4000b268: 22 80 00 0f be,a 4000b2a4 <_Scheduler_CBS_Get_execution_time+0x8c> 4000b26c: c4 1f 60 10 ldd [ %i5 + 0x10 ], %g2 *exec_time = server->parameters.budget - the_thread->cpu_time_budget; 4000b270: f8 1f 60 10 ldd [ %i5 + 0x10 ], %i4 <== NOT EXECUTED 4000b274: c2 02 20 8c ld [ %o0 + 0x8c ], %g1 <== NOT EXECUTED 4000b278: 86 a7 40 01 subcc %i5, %g1, %g3 <== NOT EXECUTED 4000b27c: 84 67 20 00 subx %i4, 0, %g2 <== NOT EXECUTED 4000b280: c4 3e 40 00 std %g2, [ %i1 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000b284: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b288: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b28c: 01 00 00 00 nop _ISR_lock_ISR_enable( &lock_context ); } else { *exec_time = server->parameters.budget; } return SCHEDULER_CBS_OK; 4000b290: 81 c7 e0 08 ret 4000b294: 91 e8 20 00 restore %g0, 0, %o0 *exec_time = 0; 4000b298: c0 26 60 04 clr [ %i1 + 4 ] return SCHEDULER_CBS_OK; 4000b29c: 81 c7 e0 08 ret 4000b2a0: 91 e8 20 00 restore %g0, 0, %o0 *exec_time = server->parameters.budget; 4000b2a4: c4 3e 40 00 std %g2, [ %i1 ] return SCHEDULER_CBS_OK; 4000b2a8: 81 c7 e0 08 ret 4000b2ac: 91 e8 20 00 restore %g0, 0, %o0 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 4000b2b0: 81 c7 e0 08 ret 4000b2b4: 91 e8 3f ee restore %g0, -18, %o0 } 4000b2b8: 81 c7 e0 08 ret 4000b2bc: 91 e8 3f e7 restore %g0, -25, %o0 =============================================================================== 4000b2c0 <_Scheduler_CBS_Get_parameters>: int _Scheduler_CBS_Get_parameters ( Scheduler_CBS_Server_id server_id, Scheduler_CBS_Parameters *params ) { if ( server_id >= _Scheduler_CBS_Maximum_servers ) 4000b2c0: 03 10 00 4b sethi %hi(0x40012c00), %g1 <== NOT EXECUTED 4000b2c4: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 40012fd0 <_Scheduler_CBS_Maximum_servers> <== NOT EXECUTED 4000b2c8: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED 4000b2cc: 08 80 00 0f bleu 4000b308 <_Scheduler_CBS_Get_parameters+0x48> <== NOT EXECUTED 4000b2d0: 03 10 00 56 sethi %hi(0x40015800), %g1 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id].initialized ) 4000b2d4: 91 2a 20 05 sll %o0, 5, %o0 4000b2d8: 82 10 62 08 or %g1, 0x208, %g1 4000b2dc: 82 00 40 08 add %g1, %o0, %g1 4000b2e0: c4 08 60 1c ldub [ %g1 + 0x1c ], %g2 4000b2e4: 80 a0 a0 00 cmp %g2, 0 4000b2e8: 02 80 00 0a be 4000b310 <_Scheduler_CBS_Get_parameters+0x50> 4000b2ec: 01 00 00 00 nop return SCHEDULER_CBS_ERROR_NOSERVER; *params = _Scheduler_CBS_Server_list[server_id].parameters; 4000b2f0: c4 18 60 08 ldd [ %g1 + 8 ], %g2 4000b2f4: c4 3a 40 00 std %g2, [ %o1 ] return SCHEDULER_CBS_OK; 4000b2f8: 90 10 20 00 clr %o0 *params = _Scheduler_CBS_Server_list[server_id].parameters; 4000b2fc: c4 18 60 10 ldd [ %g1 + 0x10 ], %g2 return SCHEDULER_CBS_OK; 4000b300: 81 c3 e0 08 retl 4000b304: c4 3a 60 08 std %g2, [ %o1 + 8 ] return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 4000b308: 81 c3 e0 08 retl 4000b30c: 90 10 3f ee mov -18, %o0 } 4000b310: 81 c3 e0 08 retl 4000b314: 90 10 3f e7 mov -25, %o0 =============================================================================== 4000b318 <_Scheduler_CBS_Get_remaining_budget>: int _Scheduler_CBS_Get_remaining_budget ( Scheduler_CBS_Server_id server_id, time_t *remaining_budget ) { 4000b318: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Scheduler_CBS_Server *server; ISR_lock_Context lock_context; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) { 4000b31c: 03 10 00 4b sethi %hi(0x40012c00), %g1 <== NOT EXECUTED 4000b320: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 40012fd0 <_Scheduler_CBS_Maximum_servers> <== NOT EXECUTED 4000b324: 80 a0 40 18 cmp %g1, %i0 <== NOT EXECUTED 4000b328: 08 80 00 20 bleu 4000b3a8 <_Scheduler_CBS_Get_remaining_budget+0x90> <== NOT EXECUTED 4000b32c: 03 10 00 56 sethi %hi(0x40015800), %g1 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; } server = &_Scheduler_CBS_Server_list[ server_id ]; if ( !server->initialized ) { 4000b330: b1 2e 20 05 sll %i0, 5, %i0 4000b334: 82 10 62 08 or %g1, 0x208, %g1 4000b338: 84 00 40 18 add %g1, %i0, %g2 4000b33c: c6 08 a0 1c ldub [ %g2 + 0x1c ], %g3 4000b340: 80 a0 e0 00 cmp %g3, 0 4000b344: 02 80 00 1b be 4000b3b0 <_Scheduler_CBS_Get_remaining_budget+0x98> 4000b348: 01 00 00 00 nop return SCHEDULER_CBS_ERROR_NOSERVER; } if ( server->task_id == -1 ) { 4000b34c: d0 00 40 18 ld [ %g1 + %i0 ], %o0 4000b350: 80 a2 3f ff cmp %o0, -1 4000b354: 22 80 00 0f be,a 4000b390 <_Scheduler_CBS_Get_remaining_budget+0x78> 4000b358: c4 18 a0 10 ldd [ %g2 + 0x10 ], %g2 *remaining_budget = server->parameters.budget; return SCHEDULER_CBS_OK; } the_thread = _Thread_Get( server->task_id, &lock_context ); 4000b35c: 40 00 04 38 call 4000c43c <_Thread_Get> 4000b360: 92 07 bf fc add %fp, -4, %o1 if ( the_thread != NULL ) { 4000b364: 80 a2 20 00 cmp %o0, 0 4000b368: 22 80 00 0d be,a 4000b39c <_Scheduler_CBS_Get_remaining_budget+0x84> 4000b36c: c0 26 40 00 clr [ %i1 ] *remaining_budget = the_thread->cpu_time_budget; 4000b370: c2 02 20 8c ld [ %o0 + 0x8c ], %g1 <== NOT EXECUTED 4000b374: c2 26 60 04 st %g1, [ %i1 + 4 ] <== NOT EXECUTED 4000b378: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000b37c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b380: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b384: 01 00 00 00 nop _ISR_lock_ISR_enable( &lock_context ); } else { *remaining_budget = 0; } return SCHEDULER_CBS_OK; 4000b388: 81 c7 e0 08 ret 4000b38c: 91 e8 20 00 restore %g0, 0, %o0 *remaining_budget = server->parameters.budget; 4000b390: c4 3e 40 00 std %g2, [ %i1 ] return SCHEDULER_CBS_OK; 4000b394: 81 c7 e0 08 ret 4000b398: 91 e8 20 00 restore %g0, 0, %o0 *remaining_budget = 0; 4000b39c: c0 26 60 04 clr [ %i1 + 4 ] return SCHEDULER_CBS_OK; 4000b3a0: 81 c7 e0 08 ret 4000b3a4: 91 e8 20 00 restore %g0, 0, %o0 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 4000b3a8: 81 c7 e0 08 ret 4000b3ac: 91 e8 3f ee restore %g0, -18, %o0 } 4000b3b0: 81 c7 e0 08 ret 4000b3b4: 91 e8 3f e7 restore %g0, -25, %o0 =============================================================================== 4000b3b8 <_Scheduler_CBS_Get_server_id>: rtems_id task_id, Scheduler_CBS_Server_id *server_id ) { unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 4000b3b8: 03 10 00 4b sethi %hi(0x40012c00), %g1 <== NOT EXECUTED 4000b3bc: c8 00 63 d0 ld [ %g1 + 0x3d0 ], %g4 ! 40012fd0 <_Scheduler_CBS_Maximum_servers> <== NOT EXECUTED 4000b3c0: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED 4000b3c4: 02 80 00 10 be 4000b404 <_Scheduler_CBS_Get_server_id+0x4c> <== NOT EXECUTED 4000b3c8: 03 10 00 56 sethi %hi(0x40015800), %g1 4000b3cc: 84 10 20 00 clr %g2 4000b3d0: 82 10 62 08 or %g1, 0x208, %g1 if ( _Scheduler_CBS_Server_list[i].initialized && 4000b3d4: c6 08 60 1c ldub [ %g1 + 0x1c ], %g3 4000b3d8: 80 a0 e0 00 cmp %g3, 0 4000b3dc: 22 80 00 07 be,a 4000b3f8 <_Scheduler_CBS_Get_server_id+0x40> 4000b3e0: 84 00 a0 01 inc %g2 4000b3e4: c6 00 40 00 ld [ %g1 ], %g3 4000b3e8: 80 a0 c0 08 cmp %g3, %o0 4000b3ec: 22 80 00 08 be,a 4000b40c <_Scheduler_CBS_Get_server_id+0x54> 4000b3f0: c4 22 40 00 st %g2, [ %o1 ] for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 4000b3f4: 84 00 a0 01 inc %g2 4000b3f8: 80 a0 80 04 cmp %g2, %g4 4000b3fc: 12 bf ff f6 bne 4000b3d4 <_Scheduler_CBS_Get_server_id+0x1c> 4000b400: 82 00 60 20 add %g1, 0x20, %g1 *server_id = i; return SCHEDULER_CBS_OK; } } return SCHEDULER_CBS_ERROR_NOSERVER; } 4000b404: 81 c3 e0 08 retl 4000b408: 90 10 3f e7 mov -25, %o0 return SCHEDULER_CBS_OK; 4000b40c: 81 c3 e0 08 retl 4000b410: 90 10 20 00 clr %o0 =============================================================================== 4000b4a0 <_Scheduler_CBS_Initialize>: int _Scheduler_CBS_Initialize(void) { return SCHEDULER_CBS_OK; } 4000b4a0: 81 c3 e0 08 retl <== NOT EXECUTED 4000b4a4: 90 10 20 00 clr %o0 =============================================================================== 4000a480 <_Scheduler_CBS_Node_initialize>: const Scheduler_Control *scheduler, Scheduler_Node *node, Thread_Control *the_thread, Priority_Control priority ) { 4000a480: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Scheduler_CBS_Node *the_node; _Scheduler_EDF_Node_initialize( scheduler, node, the_thread, priority ); 4000a484: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 4000a488: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED 4000a48c: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED 4000a490: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000a494: 40 00 00 fc call 4000a884 <_Scheduler_EDF_Node_initialize> <== NOT EXECUTED 4000a498: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED the_node = _Scheduler_CBS_Node_downcast( node ); the_node->cbs_server = NULL; 4000a49c: c0 26 60 50 clr [ %i1 + 0x50 ] the_node->deadline_node = NULL; 4000a4a0: c0 26 60 54 clr [ %i1 + 0x54 ] } 4000a4a4: 81 c7 e0 08 ret 4000a4a8: 81 e8 00 00 restore =============================================================================== 4000a4ac <_Scheduler_CBS_Release_job>: Thread_Control *the_thread, Priority_Node *priority_node, uint64_t deadline, Thread_queue_Context *queue_context ) { 4000a4ac: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 4000a4b0: c2 06 60 38 ld [ %i1 + 0x38 ], %g1 <== NOT EXECUTED Scheduler_CBS_Node *node; Scheduler_CBS_Server *serv_info; node = _Scheduler_CBS_Thread_get_node( the_thread ); serv_info = node->cbs_server; 4000a4b4: c4 00 60 50 ld [ %g1 + 0x50 ], %g2 <== NOT EXECUTED { 4000a4b8: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED /* Budget replenishment for the next job. */ if ( serv_info != NULL ) { 4000a4bc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000a4c0: 02 80 00 04 be 4000a4d0 <_Scheduler_CBS_Release_job+0x24> <== NOT EXECUTED 4000a4c4: 9a 10 00 1c mov %i4, %o5 the_thread->cpu_time_budget = serv_info->parameters.budget; 4000a4c8: c4 00 a0 14 ld [ %g2 + 0x14 ], %g2 4000a4cc: c4 26 60 8c st %g2, [ %i1 + 0x8c ] } node->deadline_node = priority_node; _Scheduler_EDF_Release_job( 4000a4d0: b6 10 00 0c mov %o4, %i3 node->deadline_node = priority_node; 4000a4d4: f4 20 60 54 st %i2, [ %g1 + 0x54 ] _Scheduler_EDF_Release_job( 4000a4d8: 40 00 01 01 call 4000a8dc <_Scheduler_EDF_Release_job> 4000a4dc: 99 e8 00 0d restore %g0, %o5, %o4 =============================================================================== 4000b508 <_Scheduler_CBS_Set_parameters>: int _Scheduler_CBS_Set_parameters ( Scheduler_CBS_Server_id server_id, Scheduler_CBS_Parameters *params ) { if ( server_id >= _Scheduler_CBS_Maximum_servers ) 4000b508: 03 10 00 4b sethi %hi(0x40012c00), %g1 <== NOT EXECUTED 4000b50c: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 40012fd0 <_Scheduler_CBS_Maximum_servers> <== NOT EXECUTED 4000b510: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED 4000b514: 08 80 00 1e bleu 4000b58c <_Scheduler_CBS_Set_parameters+0x84> <== NOT EXECUTED 4000b518: 01 00 00 00 nop return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( params->budget <= 0 || 4000b51c: c2 02 60 08 ld [ %o1 + 8 ], %g1 4000b520: 80 a0 60 00 cmp %g1, 0 4000b524: 04 80 00 1e ble 4000b59c <_Scheduler_CBS_Set_parameters+0x94> <== ALWAYS TAKEN 4000b528: 01 00 00 00 nop 4000b52c: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED 4000b530: 80 a0 60 00 cmp %g1, 0 4000b534: 04 80 00 10 ble 4000b574 <_Scheduler_CBS_Set_parameters+0x6c> <== ALWAYS TAKEN 4000b538: 01 00 00 00 nop params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id].initialized ) 4000b53c: 91 2a 20 05 sll %o0, 5, %o0 <== NOT EXECUTED 4000b540: 03 10 00 56 sethi %hi(0x40015800), %g1 4000b544: 82 10 62 08 or %g1, 0x208, %g1 ! 40015a08 <_Scheduler_CBS_Server_list> 4000b548: 82 00 40 08 add %g1, %o0, %g1 4000b54c: c4 08 60 1c ldub [ %g1 + 0x1c ], %g2 4000b550: 80 a0 a0 00 cmp %g2, 0 4000b554: 02 80 00 10 be 4000b594 <_Scheduler_CBS_Set_parameters+0x8c> 4000b558: 01 00 00 00 nop return SCHEDULER_CBS_ERROR_NOSERVER; _Scheduler_CBS_Server_list[server_id].parameters = *params; 4000b55c: c4 1a 40 00 ldd [ %o1 ], %g2 4000b560: c4 38 60 08 std %g2, [ %g1 + 8 ] return SCHEDULER_CBS_OK; 4000b564: 90 10 20 00 clr %o0 _Scheduler_CBS_Server_list[server_id].parameters = *params; 4000b568: c4 1a 60 08 ldd [ %o1 + 8 ], %g2 return SCHEDULER_CBS_OK; 4000b56c: 81 c3 e0 08 retl 4000b570: c4 38 60 10 std %g2, [ %g1 + 0x10 ] if ( params->budget <= 0 || 4000b574: 12 80 00 06 bne 4000b58c <_Scheduler_CBS_Set_parameters+0x84> 4000b578: 01 00 00 00 nop 4000b57c: c2 02 60 04 ld [ %o1 + 4 ], %g1 4000b580: 80 a0 60 00 cmp %g1, 0 4000b584: 32 bf ff ef bne,a 4000b540 <_Scheduler_CBS_Set_parameters+0x38> <== ALWAYS TAKEN 4000b588: 91 2a 20 05 sll %o0, 5, %o0 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 4000b58c: 81 c3 e0 08 retl 4000b590: 90 10 3f ee mov -18, %o0 } 4000b594: 81 c3 e0 08 retl 4000b598: 90 10 3f e7 mov -25, %o0 if ( params->budget <= 0 || 4000b59c: 12 bf ff fc bne 4000b58c <_Scheduler_CBS_Set_parameters+0x84> 4000b5a0: 01 00 00 00 nop 4000b5a4: c2 02 60 0c ld [ %o1 + 0xc ], %g1 4000b5a8: 80 a0 60 00 cmp %g1, 0 4000b5ac: 32 bf ff e1 bne,a 4000b530 <_Scheduler_CBS_Set_parameters+0x28> <== ALWAYS TAKEN 4000b5b0: c2 02 40 00 ld [ %o1 ], %g1 4000b5b4: 30 bf ff f6 b,a 4000b58c <_Scheduler_CBS_Set_parameters+0x84> <== NOT EXECUTED =============================================================================== 4000a50c <_Scheduler_CBS_Unblock>: void _Scheduler_CBS_Unblock( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 4000a50c: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED Scheduler_CBS_Node *the_node; Scheduler_CBS_Server *serv_info; Priority_Control priority; the_node = _Scheduler_CBS_Node_downcast( node ); serv_info = the_node->cbs_server; 4000a510: c2 06 a0 50 ld [ %i2 + 0x50 ], %g1 <== NOT EXECUTED priority = _Scheduler_Node_get_priority( &the_node->Base.Base ); priority = SCHEDULER_PRIORITY_PURIFY( priority ); 4000a514: c8 06 a0 34 ld [ %i2 + 0x34 ], %g4 <== NOT EXECUTED 4000a518: c4 06 a0 30 ld [ %i2 + 0x30 ], %g2 <== NOT EXECUTED * Late unblock rule for deadline-driven tasks. The remaining time to * deadline must be sufficient to serve the remaining computation time * without increased utilization of this task. It might cause a deadline * miss of another task. */ if ( serv_info != NULL && ( priority & SCHEDULER_EDF_PRIO_MSB ) == 0 ) { 4000a51c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000a520: 02 80 00 1c be 4000a590 <_Scheduler_CBS_Unblock+0x84> <== NOT EXECUTED 4000a524: 86 09 3f fe and %g4, -2, %g3 4000a528: 80 a0 a0 00 cmp %g2, 0 4000a52c: 06 80 00 19 bl 4000a590 <_Scheduler_CBS_Unblock+0x84> 4000a530: 09 10 00 50 sethi %hi(0x40014000), %g4 time_t deadline = serv_info->parameters.deadline; time_t budget = serv_info->parameters.budget; uint32_t deadline_left = the_thread->cpu_time_budget; Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot; if ( deadline * budget_left > budget * deadline_left ) { 4000a534: fa 00 60 08 ld [ %g1 + 8 ], %i5 Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot; 4000a538: c8 01 21 dc ld [ %g4 + 0x1dc ], %g4 4000a53c: 9a a0 c0 04 subcc %g3, %g4, %o5 if ( deadline * budget_left > budget * deadline_left ) { 4000a540: f6 06 60 8c ld [ %i1 + 0x8c ], %i3 Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot; 4000a544: 98 60 a0 00 subx %g2, 0, %o4 if ( deadline * budget_left > budget * deadline_left ) { 4000a548: f8 00 60 14 ld [ %g1 + 0x14 ], %i4 4000a54c: c4 00 60 0c ld [ %g1 + 0xc ], %g2 4000a550: ba 5f 40 0d smul %i5, %o5, %i5 4000a554: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 4000a558: 88 58 80 0c smul %g2, %o4, %g4 4000a55c: 82 58 40 1b smul %g1, %i3, %g1 4000a560: 88 01 00 1d add %g4, %i5, %g4 4000a564: 86 50 80 0d umul %g2, %o5, %g3 4000a568: 85 40 00 00 rd %y, %g2 4000a56c: ba 57 00 1b umul %i4, %i3, %i5 4000a570: b9 40 00 00 rd %y, %i4 4000a574: 84 01 00 02 add %g4, %g2, %g2 4000a578: b8 00 40 1c add %g1, %i4, %i4 4000a57c: 80 a0 80 1c cmp %g2, %i4 4000a580: 38 80 00 0d bgu,a 4000a5b4 <_Scheduler_CBS_Unblock+0xa8> <== NEVER TAKEN 4000a584: d4 06 a0 54 ld [ %i2 + 0x54 ], %o2 <== NOT EXECUTED 4000a588: 02 80 00 08 be 4000a5a8 <_Scheduler_CBS_Unblock+0x9c> <== ALWAYS TAKEN 4000a58c: 80 a0 c0 1d cmp %g3, %i5 &queue_context ); } } _Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base ); 4000a590: 94 10 00 1a mov %i2, %o2 4000a594: 92 10 00 19 mov %i1, %o1 4000a598: 40 00 01 0c call 4000a9c8 <_Scheduler_EDF_Unblock> 4000a59c: 90 10 00 18 mov %i0, %o0 } 4000a5a0: 81 c7 e0 08 ret 4000a5a4: 81 e8 00 00 restore if ( deadline * budget_left > budget * deadline_left ) { 4000a5a8: 08 bf ff fb bleu 4000a594 <_Scheduler_CBS_Unblock+0x88> <== NEVER TAKEN 4000a5ac: 94 10 00 1a mov %i2, %o2 _Scheduler_CBS_Cancel_job( 4000a5b0: d4 06 a0 54 ld [ %i2 + 0x54 ], %o2 4000a5b4: 92 10 00 19 mov %i1, %o1 4000a5b8: 90 10 00 18 mov %i0, %o0 RTEMS_INLINE_ROUTINE void _Thread_queue_Context_clear_priority_updates( Thread_queue_Context *queue_context ) { queue_context->Priority.update_count = 0; 4000a5bc: c0 27 bf f0 clr [ %fp + -16 ] 4000a5c0: 7f ff ff c8 call 4000a4e0 <_Scheduler_CBS_Cancel_job> 4000a5c4: 96 07 bf dc add %fp, -36, %o3 _Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base ); 4000a5c8: 94 10 00 1a mov %i2, %o2 4000a5cc: 92 10 00 19 mov %i1, %o1 4000a5d0: 40 00 00 fe call 4000a9c8 <_Scheduler_EDF_Unblock> 4000a5d4: 90 10 00 18 mov %i0, %o0 } 4000a5d8: 81 c7 e0 08 ret 4000a5dc: 81 e8 00 00 restore =============================================================================== 4000a6b0 <_Scheduler_EDF_Block>: void _Scheduler_EDF_Block( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 4000a6b0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Scheduler_EDF_Extract( Scheduler_EDF_Context *context, Scheduler_EDF_Node *node ) { _RBTree_Extract( &context->Ready, &node->Node ); 4000a6b4: d0 06 00 00 ld [ %i0 ], %o0 <== NOT EXECUTED 4000a6b8: 7f ff fd 74 call 40009c88 <_RBTree_Extract> <== NOT EXECUTED 4000a6bc: 92 06 a0 38 add %i2, 0x38, %o1 <== NOT EXECUTED { ( *extract )( scheduler, the_thread, node ); /* TODO: flash critical section? */ if ( _Thread_Is_executing( the_thread ) || _Thread_Is_heir( the_thread ) ) { 4000a6c0: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2 4000a6c4: 80 a6 40 02 cmp %i1, %g2 4000a6c8: 02 80 00 08 be 4000a6e8 <_Scheduler_EDF_Block+0x38> 4000a6cc: 01 00 00 00 nop 4000a6d0: c2 01 a0 24 ld [ %g6 + 0x24 ], %g1 4000a6d4: 80 a6 40 01 cmp %i1, %g1 4000a6d8: 02 80 00 04 be 4000a6e8 <_Scheduler_EDF_Block+0x38> <== NEVER TAKEN 4000a6dc: 01 00 00 00 nop the_thread, node, _Scheduler_EDF_Extract_body, _Scheduler_EDF_Schedule_body ); } 4000a6e0: 81 c7 e0 08 ret 4000a6e4: 81 e8 00 00 restore Scheduler_EDF_Node *node; (void) the_thread; context = _Scheduler_EDF_Get_context( scheduler ); first = _RBTree_Minimum( &context->Ready ); 4000a6e8: 40 00 12 7d call 4000f0dc <_RBTree_Minimum> 4000a6ec: d0 06 00 00 ld [ %i0 ], %o0 node = RTEMS_CONTAINER_OF( first, Scheduler_EDF_Node, Node ); _Scheduler_Update_heir( node->Base.owner, force_dispatch ); 4000a6f0: f6 02 3f c8 ld [ %o0 + -56 ], %i3 RTEMS_INLINE_ROUTINE void _Scheduler_Update_heir( Thread_Control *new_heir, bool force_dispatch ) { Thread_Control *heir = _Thread_Heir; 4000a6f4: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000a6f8: 80 a6 c0 1d cmp %i3, %i5 4000a6fc: 02 bf ff f9 be 4000a6e0 <_Scheduler_EDF_Block+0x30> <== NEVER TAKEN 4000a700: b8 10 00 06 mov %g6, %i4 *time = _Timecounter_Sbinuptime(); 4000a704: 7f ff fa 04 call 40008f14 <_Timecounter_Sbinuptime> 4000a708: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 4000a70c: d0 3f 20 28 std %o0, [ %i4 + 0x28 ] const Timestamp_Control *_start, const Timestamp_Control *_end, Timestamp_Control *_result ) { *_result = *_end - *_start; 4000a710: b2 a2 40 11 subcc %o1, %l1, %i1 *_time += *_add; 4000a714: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4 *_result = *_end - *_start; 4000a718: b0 62 00 10 subx %o0, %l0, %i0 *_time += *_add; 4000a71c: 86 83 40 19 addcc %o5, %i1, %g3 4000a720: 84 43 00 18 addx %o4, %i0, %g2 4000a724: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] heir->Scheduler.state = THREAD_SCHEDULER_BLOCKED; new_heir->Scheduler.state = THREAD_SCHEDULER_SCHEDULED; #endif _Thread_Update_CPU_time_used( heir, _Thread_Get_CPU( heir ) ); _Thread_Heir = new_heir; _Thread_Dispatch_necessary = true; 4000a728: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 4000a72c: f6 21 a0 24 st %i3, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 4000a730: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] 4000a734: 81 c7 e0 08 ret 4000a738: 81 e8 00 00 restore =============================================================================== 4000a934 <_Scheduler_EDF_Cancel_job>: const Scheduler_Control *scheduler, Thread_Control *the_thread, Priority_Node *priority_node, Thread_queue_Context *queue_context ) { 4000a934: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED (void) scheduler; _Thread_Wait_acquire_critical( the_thread, queue_context ); _Thread_Priority_remove( the_thread, priority_node, queue_context ); 4000a938: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 4000a93c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4000a940: 40 00 01 86 call 4000af58 <_Thread_Priority_remove> <== NOT EXECUTED 4000a944: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED RB_COLOR( the_node, Node ) = -1; 4000a948: 82 10 3f ff mov -1, %g1 4000a94c: c2 26 a0 0c st %g1, [ %i2 + 0xc ] _Priority_Node_set_inactive( priority_node ); _Thread_Wait_release_critical( the_thread, queue_context ); } 4000a950: 81 c7 e0 08 ret 4000a954: 81 e8 00 00 restore =============================================================================== 4000a89c <_Scheduler_EDF_Initialize>: RB_INIT( the_rbtree ); 4000a89c: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED { Scheduler_EDF_Context *context = _Scheduler_EDF_Get_context( scheduler ); _RBTree_Initialize_empty( &context->Ready ); } 4000a8a0: 81 c3 e0 08 retl <== NOT EXECUTED 4000a8a4: c0 20 40 00 clr [ %g1 ] =============================================================================== 4000a8a8 <_Scheduler_EDF_Map_priority>: Priority_Control _Scheduler_EDF_Map_priority( const Scheduler_Control *scheduler, Priority_Control priority ) { return SCHEDULER_EDF_PRIO_MSB | SCHEDULER_PRIORITY_MAP( priority ); 4000a8a8: 83 2a 60 01 sll %o1, 1, %g1 <== NOT EXECUTED 4000a8ac: 85 32 a0 1f srl %o2, 0x1f, %g2 <== NOT EXECUTED } 4000a8b0: 93 2a a0 01 sll %o2, 1, %o1 <== NOT EXECUTED return SCHEDULER_EDF_PRIO_MSB | SCHEDULER_PRIORITY_MAP( priority ); 4000a8b4: 82 10 80 01 or %g2, %g1, %g1 <== NOT EXECUTED } 4000a8b8: 11 20 00 00 sethi %hi(0x80000000), %o0 <== NOT EXECUTED 4000a8bc: 81 c3 e0 08 retl <== NOT EXECUTED 4000a8c0: 90 10 40 08 or %g1, %o0, %o0 =============================================================================== 4000a884 <_Scheduler_EDF_Node_initialize>: const Scheduler_Control *scheduler, Scheduler_Node *node, Thread_Control *the_thread, Priority_Control priority ) { 4000a884: 84 10 00 0b mov %o3, %g2 <== NOT EXECUTED 4000a888: 86 10 00 0c mov %o4, %g3 <== NOT EXECUTED Scheduler_Node *node, Thread_Control *the_thread, Priority_Control priority ) { node->owner = the_thread; 4000a88c: d4 22 40 00 st %o2, [ %o1 ] <== NOT EXECUTED node->Priority.value = priority; 4000a890: c4 3a 60 30 std %g2, [ %o1 + 0x30 ] <== NOT EXECUTED _Scheduler_Node_do_initialize( scheduler, node, the_thread, priority ); the_node = _Scheduler_EDF_Node_downcast( node ); _RBTree_Initialize_node( &the_node->Node ); the_node->priority = priority; } 4000a894: 81 c3 e0 08 retl <== NOT EXECUTED 4000a898: c4 3a 60 48 std %g2, [ %o1 + 0x48 ] =============================================================================== 4000a8dc <_Scheduler_EDF_Release_job>: * There is no integer overflow problem here due to the * SCHEDULER_PRIORITY_MAP(). The deadline is in clock ticks. With the * minimum clock tick interval of 1us, the uptime is limited to about 146235 * years. */ _Priority_Node_set_priority( 4000a8dc: 85 33 20 1f srl %o4, 0x1f, %g2 <== NOT EXECUTED 4000a8e0: 97 2a e0 01 sll %o3, 1, %o3 <== NOT EXECUTED 4000a8e4: 99 2b 20 01 sll %o4, 1, %o4 <== NOT EXECUTED 4000a8e8: 96 12 c0 02 or %o3, %g2, %o3 <== NOT EXECUTED 4000a8ec: d8 22 a0 14 st %o4, [ %o2 + 0x14 ] <== NOT EXECUTED { 4000a8f0: 82 10 00 0a mov %o2, %g1 <== NOT EXECUTED _Priority_Node_set_priority( 4000a8f4: d6 22 a0 10 st %o3, [ %o2 + 0x10 ] <== NOT EXECUTED priority_node, SCHEDULER_PRIORITY_MAP( deadline ) ); if ( _Priority_Node_is_active( priority_node ) ) { 4000a8f8: c4 02 a0 0c ld [ %o2 + 0xc ], %g2 <== NOT EXECUTED 4000a8fc: 80 a0 bf ff cmp %g2, -1 <== NOT EXECUTED 4000a900: 02 80 00 08 be 4000a920 <_Scheduler_EDF_Release_job+0x44> <== NOT EXECUTED 4000a904: 90 10 00 09 mov %o1, %o0 _Thread_Priority_changed( 4000a908: 96 10 00 0d mov %o5, %o3 4000a90c: 94 10 20 00 clr %o2 4000a910: 92 10 00 01 mov %g1, %o1 4000a914: 82 13 c0 00 mov %o7, %g1 4000a918: 40 00 01 95 call 4000af6c <_Thread_Priority_changed> 4000a91c: 9e 10 40 00 mov %g1, %o7 priority_node, false, queue_context ); } else { _Thread_Priority_add( the_thread, priority_node, queue_context ); 4000a920: 94 10 00 0d mov %o5, %o2 4000a924: 92 10 00 01 mov %g1, %o1 4000a928: 82 13 c0 00 mov %o7, %g1 4000a92c: 40 00 01 86 call 4000af44 <_Thread_Priority_add> 4000a930: 9e 10 40 00 mov %g1, %o7 =============================================================================== 4000a958 <_Scheduler_EDF_Schedule>: void _Scheduler_EDF_Schedule( const Scheduler_Control *scheduler, Thread_Control *the_thread ) { 4000a958: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED first = _RBTree_Minimum( &context->Ready ); 4000a95c: 40 00 11 e0 call 4000f0dc <_RBTree_Minimum> <== NOT EXECUTED 4000a960: d0 06 00 00 ld [ %i0 ], %o0 <== NOT EXECUTED _Scheduler_Update_heir( node->Base.owner, force_dispatch ); 4000a964: f6 02 3f c8 ld [ %o0 + -56 ], %i3 Thread_Control *heir = _Thread_Heir; 4000a968: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000a96c: 80 a6 c0 1d cmp %i3, %i5 4000a970: 02 80 00 06 be 4000a988 <_Scheduler_EDF_Schedule+0x30> <== ALWAYS TAKEN 4000a974: b8 10 00 06 mov %g6, %i4 4000a978: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1 <== NOT EXECUTED 4000a97c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000a980: 12 80 00 04 bne 4000a990 <_Scheduler_EDF_Schedule+0x38> <== NOT EXECUTED 4000a984: 01 00 00 00 nop <== NOT EXECUTED _Scheduler_EDF_Schedule_body( scheduler, the_thread, false ); } 4000a988: 81 c7 e0 08 ret 4000a98c: 81 e8 00 00 restore 4000a990: 7f ff f9 61 call 40008f14 <_Timecounter_Sbinuptime> <== NOT EXECUTED 4000a994: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 <== NOT EXECUTED 4000a998: d0 3f 20 28 std %o0, [ %i4 + 0x28 ] <== NOT EXECUTED *_result = *_end - *_start; 4000a99c: b2 a2 40 11 subcc %o1, %l1, %i1 <== NOT EXECUTED *_time += *_add; 4000a9a0: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4 <== NOT EXECUTED *_result = *_end - *_start; 4000a9a4: b0 62 00 10 subx %o0, %l0, %i0 <== NOT EXECUTED *_time += *_add; 4000a9a8: 86 83 40 19 addcc %o5, %i1, %g3 <== NOT EXECUTED 4000a9ac: 84 43 00 18 addx %o4, %i0, %g2 <== NOT EXECUTED 4000a9b0: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 4000a9b4: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = new_heir; 4000a9b8: f6 21 a0 24 st %i3, [ %g6 + 0x24 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 4000a9bc: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] <== NOT EXECUTED 4000a9c0: 81 c7 e0 08 ret <== NOT EXECUTED 4000a9c4: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000a9c8 <_Scheduler_EDF_Unblock>: void _Scheduler_EDF_Unblock( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 4000a9c8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Priority_Control insert_priority; context = _Scheduler_EDF_Get_context( scheduler ); the_node = _Scheduler_EDF_Node_downcast( node ); priority = _Scheduler_Node_get_priority( &the_node->Base ); priority = SCHEDULER_PRIORITY_PURIFY( priority ); 4000a9cc: fa 06 a0 30 ld [ %i2 + 0x30 ], %i5 <== NOT EXECUTED 4000a9d0: f8 06 a0 34 ld [ %i2 + 0x34 ], %i4 <== NOT EXECUTED 4000a9d4: d0 06 00 00 ld [ %i0 ], %o0 <== NOT EXECUTED 4000a9d8: b8 0f 3f fe and %i4, -2, %i4 <== NOT EXECUTED insert_priority = SCHEDULER_PRIORITY_APPEND( priority ); the_node->priority = priority; 4000a9dc: fa 26 a0 48 st %i5, [ %i2 + 0x48 ] <== NOT EXECUTED link = _RBTree_Root_reference( the_rbtree ); 4000a9e0: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED 4000a9e4: f8 26 a0 4c st %i4, [ %i2 + 0x4c ] <== NOT EXECUTED insert_priority = SCHEDULER_PRIORITY_APPEND( priority ); 4000a9e8: b6 17 20 01 or %i4, 1, %i3 <== NOT EXECUTED while ( *link != NULL ) { 4000a9ec: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED _RBTree_Insert_inline( 4000a9f0: 88 06 a0 38 add %i2, 0x38, %g4 <== NOT EXECUTED 4000a9f4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000a9f8: 02 80 00 12 be 4000aa40 <_Scheduler_EDF_Unblock+0x78> <== NOT EXECUTED 4000a9fc: 86 10 20 00 clr %g3 if ( ( *less )( key, parent ) ) { 4000aa00: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 4000aa04: 80 a0 80 1d cmp %g2, %i5 4000aa08: 0a 80 00 09 bcs 4000aa2c <_Scheduler_EDF_Unblock+0x64> 4000aa0c: 84 00 60 04 add %g1, 4, %g2 4000aa10: 12 80 00 1e bne 4000aa88 <_Scheduler_EDF_Unblock+0xc0> 4000aa14: 84 10 00 01 mov %g1, %g2 4000aa18: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 4000aa1c: 80 a0 80 1b cmp %g2, %i3 4000aa20: 1a 80 00 1a bcc 4000aa88 <_Scheduler_EDF_Unblock+0xc0> 4000aa24: 84 10 00 01 mov %g1, %g2 return &RB_RIGHT( the_node, Node ); 4000aa28: 84 00 60 04 add %g1, 4, %g2 { 4000aa2c: 86 10 00 01 mov %g1, %g3 while ( *link != NULL ) { 4000aa30: c2 00 80 00 ld [ %g2 ], %g1 4000aa34: 80 a0 60 00 cmp %g1, 0 4000aa38: 32 bf ff f3 bne,a 4000aa04 <_Scheduler_EDF_Unblock+0x3c> 4000aa3c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 RB_SET( child, parent, Node ); 4000aa40: c6 26 a0 40 st %g3, [ %i2 + 0x40 ] 4000aa44: 82 10 20 01 mov 1, %g1 4000aa48: c0 26 a0 3c clr [ %i2 + 0x3c ] _RBTree_Insert_color( the_rbtree, the_node ); 4000aa4c: 92 10 00 04 mov %g4, %o1 RB_SET( child, parent, Node ); 4000aa50: c2 26 a0 44 st %g1, [ %i2 + 0x44 ] 4000aa54: c0 26 a0 38 clr [ %i2 + 0x38 ] _RBTree_Insert_color( the_rbtree, the_node ); 4000aa58: 7f ff fd ee call 4000a210 <_RBTree_Insert_color> 4000aa5c: c8 20 80 00 st %g4, [ %g2 ] * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( priority < _Thread_Get_priority( _Thread_Heir ) ) { 4000aa60: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3 4000aa64: c2 06 e0 38 ld [ %i3 + 0x38 ], %g1 4000aa68: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 4000aa6c: 80 a0 80 1d cmp %g2, %i5 4000aa70: 18 80 00 0b bgu 4000aa9c <_Scheduler_EDF_Unblock+0xd4> 4000aa74: b4 10 00 06 mov %g6, %i2 4000aa78: 22 80 00 06 be,a 4000aa90 <_Scheduler_EDF_Unblock+0xc8> 4000aa7c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 _Scheduler_Update_heir( the_thread, priority == ( SCHEDULER_EDF_PRIO_MSB | PRIORITY_PSEUDO_ISR ) ); } } 4000aa80: 81 c7 e0 08 ret 4000aa84: 81 e8 00 00 restore { 4000aa88: 10 bf ff ea b 4000aa30 <_Scheduler_EDF_Unblock+0x68> 4000aa8c: 86 10 00 01 mov %g1, %g3 if ( priority < _Thread_Get_priority( _Thread_Heir ) ) { 4000aa90: 80 a0 40 1c cmp %g1, %i4 4000aa94: 08 80 00 19 bleu 4000aaf8 <_Scheduler_EDF_Unblock+0x130> 4000aa98: 01 00 00 00 nop if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000aa9c: 80 a6 c0 19 cmp %i3, %i1 4000aaa0: 02 bf ff f8 be 4000aa80 <_Scheduler_EDF_Unblock+0xb8> <== NEVER TAKEN 4000aaa4: 03 20 00 00 sethi %hi(0x80000000), %g1 _Scheduler_Update_heir( 4000aaa8: ba 1f 40 01 xor %i5, %g1, %i5 4000aaac: 80 97 40 1c orcc %i5, %i4, %g0 4000aab0: 02 80 00 06 be 4000aac8 <_Scheduler_EDF_Unblock+0x100> <== NEVER TAKEN 4000aab4: 01 00 00 00 nop 4000aab8: c2 0e e0 89 ldub [ %i3 + 0x89 ], %g1 4000aabc: 80 a0 60 00 cmp %g1, 0 4000aac0: 02 80 00 0e be 4000aaf8 <_Scheduler_EDF_Unblock+0x130> 4000aac4: 01 00 00 00 nop 4000aac8: 7f ff f9 13 call 40008f14 <_Timecounter_Sbinuptime> 4000aacc: e0 1e a0 28 ldd [ %i2 + 0x28 ], %l0 4000aad0: d0 3e a0 28 std %o0, [ %i2 + 0x28 ] *_result = *_end - *_start; 4000aad4: ba a2 40 11 subcc %o1, %l1, %i5 *_time += *_add; 4000aad8: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4 *_result = *_end - *_start; 4000aadc: b8 62 00 10 subx %o0, %l0, %i4 *_time += *_add; 4000aae0: 86 83 40 1d addcc %o5, %i5, %g3 4000aae4: 84 43 00 1c addx %o4, %i4, %g2 4000aae8: c4 3e e0 98 std %g2, [ %i3 + 0x98 ] _Thread_Dispatch_necessary = true; 4000aaec: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 4000aaf0: f2 21 a0 24 st %i1, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 4000aaf4: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] } 4000aaf8: 81 c7 e0 08 ret 4000aafc: 81 e8 00 00 restore =============================================================================== 4000a8c4 <_Scheduler_EDF_Unmap_priority>: Priority_Control _Scheduler_EDF_Unmap_priority( const Scheduler_Control *scheduler, Priority_Control priority ) { return SCHEDULER_PRIORITY_UNMAP( priority & ~SCHEDULER_EDF_PRIO_MSB ); 4000a8c4: 95 32 a0 01 srl %o2, 1, %o2 <== NOT EXECUTED 4000a8c8: 83 2a 60 1f sll %o1, 0x1f, %g1 <== NOT EXECUTED 4000a8cc: 91 2a 60 01 sll %o1, 1, %o0 <== NOT EXECUTED } 4000a8d0: 92 10 40 0a or %g1, %o2, %o1 <== NOT EXECUTED 4000a8d4: 81 c3 e0 08 retl <== NOT EXECUTED 4000a8d8: 91 32 20 02 srl %o0, 2, %o0 <== NOT EXECUTED =============================================================================== 4000a73c <_Scheduler_EDF_Update_priority>: void _Scheduler_EDF_Update_priority( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 4000a73c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Scheduler_EDF_Context *context; Scheduler_EDF_Node *the_node; Priority_Control priority; Priority_Control insert_priority; if ( !_Thread_Is_ready( the_thread ) ) { 4000a740: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED 4000a744: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000a748: 12 80 00 4d bne 4000a87c <_Scheduler_EDF_Update_priority+0x140> <== NOT EXECUTED 4000a74c: 01 00 00 00 nop 4000a750: fa 06 a0 30 ld [ %i2 + 0x30 ], %i5 4000a754: f8 06 a0 34 ld [ %i2 + 0x34 ], %i4 the_node = _Scheduler_EDF_Node_downcast( node ); insert_priority = _Scheduler_Node_get_priority( &the_node->Base ); priority = SCHEDULER_PRIORITY_PURIFY( insert_priority ); if ( priority == the_node->priority ) { 4000a758: c4 06 a0 48 ld [ %i2 + 0x48 ], %g2 4000a75c: 80 a0 80 1d cmp %g2, %i5 4000a760: 02 80 00 34 be 4000a830 <_Scheduler_EDF_Update_priority+0xf4> 4000a764: 82 0f 3f fe and %i4, -2, %g1 /* Nothing to do */ return; } the_node->priority = priority; 4000a768: c2 26 a0 4c st %g1, [ %i2 + 0x4c ] _RBTree_Extract( &context->Ready, &node->Node ); 4000a76c: b6 06 a0 38 add %i2, 0x38, %i3 4000a770: fa 26 a0 48 st %i5, [ %i2 + 0x48 ] 4000a774: 92 10 00 1b mov %i3, %o1 4000a778: f2 06 00 00 ld [ %i0 ], %i1 4000a77c: 7f ff fd 43 call 40009c88 <_RBTree_Extract> 4000a780: 90 10 00 19 mov %i1, %o0 link = _RBTree_Root_reference( the_rbtree ); 4000a784: 84 10 00 19 mov %i1, %g2 while ( *link != NULL ) { 4000a788: c2 00 80 00 ld [ %g2 ], %g1 4000a78c: 80 a0 60 00 cmp %g1, 0 4000a790: 02 80 00 12 be 4000a7d8 <_Scheduler_EDF_Update_priority+0x9c> <== NEVER TAKEN 4000a794: 86 10 20 00 clr %g3 if ( ( *less )( key, parent ) ) { 4000a798: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 4000a79c: 80 a0 80 1d cmp %g2, %i5 4000a7a0: 0a 80 00 09 bcs 4000a7c4 <_Scheduler_EDF_Update_priority+0x88> 4000a7a4: 84 00 60 04 add %g1, 4, %g2 4000a7a8: 12 80 00 28 bne 4000a848 <_Scheduler_EDF_Update_priority+0x10c> 4000a7ac: 84 10 00 01 mov %g1, %g2 4000a7b0: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 4000a7b4: 80 a0 80 1c cmp %g2, %i4 4000a7b8: 1a 80 00 24 bcc 4000a848 <_Scheduler_EDF_Update_priority+0x10c> 4000a7bc: 84 10 00 01 mov %g1, %g2 return &RB_RIGHT( the_node, Node ); 4000a7c0: 84 00 60 04 add %g1, 4, %g2 { 4000a7c4: 86 10 00 01 mov %g1, %g3 while ( *link != NULL ) { 4000a7c8: c2 00 80 00 ld [ %g2 ], %g1 4000a7cc: 80 a0 60 00 cmp %g1, 0 4000a7d0: 32 bf ff f3 bne,a 4000a79c <_Scheduler_EDF_Update_priority+0x60> 4000a7d4: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 RB_SET( child, parent, Node ); 4000a7d8: c6 26 a0 40 st %g3, [ %i2 + 0x40 ] 4000a7dc: a0 10 20 01 mov 1, %l0 4000a7e0: c0 26 a0 3c clr [ %i2 + 0x3c ] _RBTree_Insert_color( the_rbtree, the_node ); 4000a7e4: 92 10 00 1b mov %i3, %o1 RB_SET( child, parent, Node ); 4000a7e8: c0 26 a0 38 clr [ %i2 + 0x38 ] _RBTree_Insert_color( the_rbtree, the_node ); 4000a7ec: 90 10 00 19 mov %i1, %o0 RB_SET( child, parent, Node ); 4000a7f0: e0 26 a0 44 st %l0, [ %i2 + 0x44 ] _RBTree_Insert_color( the_rbtree, the_node ); 4000a7f4: 7f ff fe 87 call 4000a210 <_RBTree_Insert_color> 4000a7f8: f6 20 80 00 st %i3, [ %g2 ] first = _RBTree_Minimum( &context->Ready ); 4000a7fc: 40 00 12 38 call 4000f0dc <_RBTree_Minimum> 4000a800: d0 06 00 00 ld [ %i0 ], %o0 _Scheduler_Update_heir( node->Base.owner, force_dispatch ); 4000a804: f6 02 3f c8 ld [ %o0 + -56 ], %i3 Thread_Control *heir = _Thread_Heir; 4000a808: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000a80c: 80 a6 c0 1d cmp %i3, %i5 4000a810: 02 80 00 06 be 4000a828 <_Scheduler_EDF_Update_priority+0xec> 4000a814: b8 10 00 06 mov %g6, %i4 4000a818: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1 4000a81c: 80 a0 60 00 cmp %g1, 0 4000a820: 12 80 00 0c bne 4000a850 <_Scheduler_EDF_Update_priority+0x114> <== ALWAYS TAKEN 4000a824: 01 00 00 00 nop context = _Scheduler_EDF_Get_context( scheduler ); _Scheduler_EDF_Extract( context, the_node ); _Scheduler_EDF_Enqueue( context, the_node, insert_priority ); _Scheduler_EDF_Schedule_body( scheduler, the_thread, false ); } 4000a828: 81 c7 e0 08 ret 4000a82c: 81 e8 00 00 restore if ( priority == the_node->priority ) { 4000a830: c4 06 a0 4c ld [ %i2 + 0x4c ], %g2 4000a834: 80 a0 80 01 cmp %g2, %g1 4000a838: 32 bf ff cd bne,a 4000a76c <_Scheduler_EDF_Update_priority+0x30> <== ALWAYS TAKEN 4000a83c: c2 26 a0 4c st %g1, [ %i2 + 0x4c ] } 4000a840: 81 c7 e0 08 ret <== NOT EXECUTED 4000a844: 81 e8 00 00 restore <== NOT EXECUTED { 4000a848: 10 bf ff e0 b 4000a7c8 <_Scheduler_EDF_Update_priority+0x8c> 4000a84c: 86 10 00 01 mov %g1, %g3 4000a850: 7f ff f9 b1 call 40008f14 <_Timecounter_Sbinuptime> 4000a854: f0 19 a0 28 ldd [ %g6 + 0x28 ], %i0 4000a858: d0 3f 20 28 std %o0, [ %i4 + 0x28 ] *_result = *_end - *_start; 4000a85c: 9a a2 40 19 subcc %o1, %i1, %o5 4000a860: 98 62 00 18 subx %o0, %i0, %o4 *_time += *_add; 4000a864: f0 1f 60 98 ldd [ %i5 + 0x98 ], %i0 4000a868: 86 86 40 0d addcc %i1, %o5, %g3 4000a86c: 84 46 00 0c addx %i0, %o4, %g2 4000a870: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] _Thread_Heir = new_heir; 4000a874: f6 21 a0 24 st %i3, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 4000a878: e0 29 a0 1c stb %l0, [ %g6 + 0x1c ] } 4000a87c: 81 c7 e0 08 ret 4000a880: 81 e8 00 00 restore =============================================================================== 4000ab00 <_Scheduler_EDF_Yield>: void _Scheduler_EDF_Yield( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 4000ab00: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED _RBTree_Extract( &context->Ready, &node->Node ); 4000ab04: f8 06 00 00 ld [ %i0 ], %i4 <== NOT EXECUTED 4000ab08: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED 4000ab0c: ba 06 a0 38 add %i2, 0x38, %i5 <== NOT EXECUTED 4000ab10: 7f ff fc 5e call 40009c88 <_RBTree_Extract> <== NOT EXECUTED 4000ab14: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED link = _RBTree_Root_reference( the_rbtree ); 4000ab18: 84 10 00 1c mov %i4, %g2 while ( *link != NULL ) { 4000ab1c: c2 00 80 00 ld [ %g2 ], %g1 context = _Scheduler_EDF_Get_context( scheduler ); the_node = _Scheduler_EDF_Node_downcast( node ); _Scheduler_EDF_Extract( context, the_node ); _Scheduler_EDF_Enqueue( context, the_node, the_node->priority ); 4000ab20: c8 06 a0 48 ld [ %i2 + 0x48 ], %g4 4000ab24: f6 06 a0 4c ld [ %i2 + 0x4c ], %i3 4000ab28: 80 a0 60 00 cmp %g1, 0 4000ab2c: 02 80 00 12 be 4000ab74 <_Scheduler_EDF_Yield+0x74> <== NEVER TAKEN 4000ab30: 86 10 20 00 clr %g3 if ( ( *less )( key, parent ) ) { 4000ab34: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 4000ab38: 80 a0 80 04 cmp %g2, %g4 4000ab3c: 0a 80 00 09 bcs 4000ab60 <_Scheduler_EDF_Yield+0x60> <== NEVER TAKEN 4000ab40: 84 00 60 04 add %g1, 4, %g2 4000ab44: 12 80 00 29 bne 4000abe8 <_Scheduler_EDF_Yield+0xe8> <== NEVER TAKEN 4000ab48: 84 10 00 01 mov %g1, %g2 4000ab4c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 4000ab50: 80 a0 80 1b cmp %g2, %i3 4000ab54: 1a 80 00 25 bcc 4000abe8 <_Scheduler_EDF_Yield+0xe8> 4000ab58: 84 10 00 01 mov %g1, %g2 return &RB_RIGHT( the_node, Node ); 4000ab5c: 84 00 60 04 add %g1, 4, %g2 { 4000ab60: 86 10 00 01 mov %g1, %g3 while ( *link != NULL ) { 4000ab64: c2 00 80 00 ld [ %g2 ], %g1 4000ab68: 80 a0 60 00 cmp %g1, 0 4000ab6c: 32 bf ff f3 bne,a 4000ab38 <_Scheduler_EDF_Yield+0x38> 4000ab70: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 RB_SET( child, parent, Node ); 4000ab74: c6 26 a0 40 st %g3, [ %i2 + 0x40 ] 4000ab78: b6 10 20 01 mov 1, %i3 4000ab7c: c0 26 a0 3c clr [ %i2 + 0x3c ] _RBTree_Insert_color( the_rbtree, the_node ); 4000ab80: 92 10 00 1d mov %i5, %o1 RB_SET( child, parent, Node ); 4000ab84: c0 26 a0 38 clr [ %i2 + 0x38 ] _RBTree_Insert_color( the_rbtree, the_node ); 4000ab88: 90 10 00 1c mov %i4, %o0 RB_SET( child, parent, Node ); 4000ab8c: f6 26 a0 44 st %i3, [ %i2 + 0x44 ] _RBTree_Insert_color( the_rbtree, the_node ); 4000ab90: 7f ff fd a0 call 4000a210 <_RBTree_Insert_color> 4000ab94: fa 20 80 00 st %i5, [ %g2 ] first = _RBTree_Minimum( &context->Ready ); 4000ab98: 40 00 11 51 call 4000f0dc <_RBTree_Minimum> 4000ab9c: d0 06 00 00 ld [ %i0 ], %o0 _Scheduler_Update_heir( node->Base.owner, force_dispatch ); 4000aba0: f4 02 3f c8 ld [ %o0 + -56 ], %i2 Thread_Control *heir = _Thread_Heir; 4000aba4: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000aba8: 80 a6 80 1d cmp %i2, %i5 4000abac: 02 80 00 0d be 4000abe0 <_Scheduler_EDF_Yield+0xe0> <== NEVER TAKEN 4000abb0: b8 10 00 06 mov %g6, %i4 4000abb4: 7f ff f8 d8 call 40008f14 <_Timecounter_Sbinuptime> 4000abb8: f0 19 a0 28 ldd [ %g6 + 0x28 ], %i0 4000abbc: d0 3f 20 28 std %o0, [ %i4 + 0x28 ] *_result = *_end - *_start; 4000abc0: 9a a2 40 19 subcc %o1, %i1, %o5 4000abc4: 98 62 00 18 subx %o0, %i0, %o4 *_time += *_add; 4000abc8: f0 1f 60 98 ldd [ %i5 + 0x98 ], %i0 4000abcc: 86 86 40 0d addcc %i1, %o5, %g3 4000abd0: 84 46 00 0c addx %i0, %o4, %g2 4000abd4: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] _Thread_Heir = new_heir; 4000abd8: f4 21 a0 24 st %i2, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 4000abdc: f6 29 a0 1c stb %i3, [ %g6 + 0x1c ] _Scheduler_EDF_Schedule_body( scheduler, the_thread, true ); } 4000abe0: 81 c7 e0 08 ret 4000abe4: 81 e8 00 00 restore { 4000abe8: 10 bf ff df b 4000ab64 <_Scheduler_EDF_Yield+0x64> 4000abec: 86 10 00 01 mov %g1, %g3 =============================================================================== 4000aac8 <_Scheduler_Get_affinity>: bool _Scheduler_Get_affinity( Thread_Control *the_thread, size_t cpusetsize, cpu_set_t *cpuset ) { 4000aac8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED const Processor_mask *src, size_t dst_size, cpu_set_t *dst ) { return _Processor_mask_Copy( 4000aacc: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED 4000aad0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000aad4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 4000aad8: 15 10 00 4a sethi %hi(0x40012800), %o2 <== NOT EXECUTED 4000aadc: 7f ff fd 8b call 4000a108 <_Processor_mask_Copy> <== NOT EXECUTED 4000aae0: 94 12 a1 00 or %o2, 0x100, %o2 ! 40012900 <_Processor_mask_The_one_and_only> <== NOT EXECUTED #endif status = _Processor_mask_To_cpu_set_t( affinity, cpusetsize, cpuset ); _Scheduler_Release_critical( scheduler, &lock_context ); return status == PROCESSOR_MASK_COPY_LOSSLESS; } 4000aae4: 80 a0 00 08 cmp %g0, %o0 4000aae8: b0 60 3f ff subx %g0, -1, %i0 4000aaec: 81 c7 e0 08 ret 4000aaf0: 81 e8 00 00 restore =============================================================================== 40009c0c <_Scheduler_Handler_initialization>: #endif #include void _Scheduler_Handler_initialization(void) { 40009c0c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED scheduler = &_Scheduler_Table[ i ]; #if defined(RTEMS_SMP) context = _Scheduler_Get_context( scheduler ); #endif _ISR_lock_Initialize( &context->Lock, "Scheduler" ); ( *scheduler->Operations.initialize )( scheduler ); 40009c10: 11 10 00 63 sethi %hi(0x40018c00), %o0 <== NOT EXECUTED 40009c14: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 40018dc8 <_Scheduler_Table> 40009c18: c2 02 20 04 ld [ %o0 + 4 ], %g1 40009c1c: 9f c0 40 00 call %g1 40009c20: 01 00 00 00 nop } } 40009c24: 81 c7 e0 08 ret 40009c28: 81 e8 00 00 restore =============================================================================== 40024d1c <_Scheduler_Set_affinity>: bool _Scheduler_Set_affinity( Thread_Control *the_thread, size_t cpusetsize, const cpu_set_t *cpuset ) { 40024d1c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Processor_mask *dst, size_t src_size, const cpu_set_t *src ) { return _Processor_mask_Copy( 40024d20: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED 40024d24: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED 40024d28: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 40024d2c: 90 07 bf fc add %fp, -4, %o0 40024d30: 7f ff fb e2 call 40023cb8 <_Processor_mask_Copy> 40024d34: b0 10 20 00 clr %i0 Scheduler_Node *node; ISR_lock_Context lock_context; bool ok; status = _Processor_mask_From_cpu_set_t( &affinity, cpusetsize, cpuset ); if ( !_Processor_mask_Is_at_most_partial_loss( status ) ) { 40024d38: 80 a2 20 01 cmp %o0, 1 40024d3c: 38 80 00 09 bgu,a 40024d60 <_Scheduler_Set_affinity+0x44> <== NEVER TAKEN 40024d40: b0 0e 20 01 and %i0, 1, %i0 <== NOT EXECUTED BIT_AND2( CPU_MAXIMUM_PROCESSORS, a, b, c ); 40024d44: 03 10 01 91 sethi %hi(0x40064400), %g1 40024d48: c4 00 63 00 ld [ %g1 + 0x300 ], %g2 ! 40064700 <_Processor_mask_The_one_and_only> return BIT_SUBSET( CPU_MAXIMUM_PROCESSORS, big, small ); 40024d4c: c2 07 bf fc ld [ %fp + -4 ], %g1 40024d50: 82 28 80 01 andn %g2, %g1, %g1 40024d54: 80 a0 00 01 cmp %g0, %g1 40024d58: b0 60 3f ff subx %g0, -1, %i0 ); #endif _Scheduler_Release_critical( scheduler, &lock_context ); return ok; } 40024d5c: b0 0e 20 01 and %i0, 1, %i0 40024d60: 81 c7 e0 08 ret 40024d64: 81 e8 00 00 restore =============================================================================== 40009b3c <_Scheduler_default_Cancel_job>: { (void) scheduler; (void) the_thread; (void) priority_node; (void) queue_context; } 40009b3c: 81 c3 e0 08 retl <== NOT EXECUTED 40009b40: 01 00 00 00 nop =============================================================================== 40009b04 <_Scheduler_default_Map_priority>: Priority_Control _Scheduler_default_Map_priority( const Scheduler_Control *scheduler, Priority_Control priority ) { return SCHEDULER_PRIORITY_MAP( priority ); 40009b04: 83 2a 60 01 sll %o1, 1, %g1 <== NOT EXECUTED 40009b08: 91 32 a0 1f srl %o2, 0x1f, %o0 <== NOT EXECUTED } 40009b0c: 93 2a a0 01 sll %o2, 1, %o1 <== NOT EXECUTED 40009b10: 81 c3 e0 08 retl 40009b14: 90 12 00 01 or %o0, %g1, %o0 =============================================================================== 40009b2c <_Scheduler_default_Node_destroy>: Scheduler_Node *node ) { (void) scheduler; (void) node; } 40009b2c: 81 c3 e0 08 retl <== NOT EXECUTED 40009b30: 01 00 00 00 nop =============================================================================== 4000a4f0 <_Scheduler_default_Node_initialize>: const Scheduler_Control *scheduler, Scheduler_Node *node, Thread_Control *the_thread, Priority_Control priority ) { 4000a4f0: 84 10 00 0b mov %o3, %g2 <== NOT EXECUTED 4000a4f4: 86 10 00 0c mov %o4, %g3 <== NOT EXECUTED Scheduler_Node *node, Thread_Control *the_thread, Priority_Control priority ) { node->owner = the_thread; 4000a4f8: d4 22 40 00 st %o2, [ %o1 ] <== NOT EXECUTED _Scheduler_Node_do_initialize( scheduler, node, the_thread, priority ); } 4000a4fc: 81 c3 e0 08 retl <== NOT EXECUTED 4000a500: c4 3a 60 30 std %g2, [ %o1 + 0x30 ] =============================================================================== 40009b34 <_Scheduler_default_Release_job>: (void) scheduler; (void) the_thread; (void) priority_node; (void) deadline; (void) queue_context; } 40009b34: 81 c3 e0 08 retl <== NOT EXECUTED 40009b38: 01 00 00 00 nop =============================================================================== 40009b44 <_Scheduler_default_Start_idle>: void _Scheduler_default_Start_idle( const Scheduler_Control *scheduler, Thread_Control *the_thread, Per_CPU_Control *cpu ) { 40009b44: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED const Scheduler_Control *scheduler; ISR_lock_Context lock_context; scheduler = _Thread_Scheduler_get_home( the_thread ); _Scheduler_Acquire_critical( scheduler, &lock_context ); ( *scheduler->Operations.unblock )( 40009b48: 11 10 00 63 sethi %hi(0x40018c00), %o0 <== NOT EXECUTED 40009b4c: d4 06 60 38 ld [ %i1 + 0x38 ], %o2 40009b50: 90 12 21 c8 or %o0, 0x1c8, %o0 40009b54: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 40009b58: 9f c0 40 00 call %g1 40009b5c: 92 10 00 19 mov %i1, %o1 (void) scheduler; (void) cpu; _Scheduler_Unblock( the_thread ); } 40009b60: 81 c7 e0 08 ret 40009b64: 81 e8 00 00 restore =============================================================================== 40009b68 <_Scheduler_default_Tick>: void _Scheduler_default_Tick( const Scheduler_Control *scheduler, Thread_Control *executing ) { 40009b68: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 40009b6c: c2 0e 60 89 ldub [ %i1 + 0x89 ], %g1 <== NOT EXECUTED 40009b70: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009b74: 02 80 00 24 be 40009c04 <_Scheduler_default_Tick+0x9c> <== ALWAYS TAKEN 40009b78: 01 00 00 00 nop return; if ( !_States_Is_ready( executing->current_state ) ) 40009b7c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 40009b80: 80 a0 60 00 cmp %g1, 0 40009b84: 12 80 00 20 bne 40009c04 <_Scheduler_default_Tick+0x9c> 40009b88: 01 00 00 00 nop /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 40009b8c: c2 06 60 90 ld [ %i1 + 0x90 ], %g1 40009b90: 80 a0 60 01 cmp %g1, 1 40009b94: 0a 80 00 0e bcs 40009bcc <_Scheduler_default_Tick+0x64> 40009b98: 80 a0 60 02 cmp %g1, 2 40009b9c: 08 80 00 0e bleu 40009bd4 <_Scheduler_default_Tick+0x6c> 40009ba0: 80 a0 60 03 cmp %g1, 3 40009ba4: 12 80 00 18 bne 40009c04 <_Scheduler_default_Tick+0x9c> <== NEVER TAKEN 40009ba8: 01 00 00 00 nop } break; #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 40009bac: c2 06 60 8c ld [ %i1 + 0x8c ], %g1 40009bb0: 82 00 7f ff add %g1, -1, %g1 40009bb4: 80 a0 60 00 cmp %g1, 0 40009bb8: 12 80 00 05 bne 40009bcc <_Scheduler_default_Tick+0x64> 40009bbc: c2 26 60 8c st %g1, [ %i1 + 0x8c ] (*executing->budget_callout)( executing ); 40009bc0: c2 06 60 94 ld [ %i1 + 0x94 ], %g1 40009bc4: 9f c0 40 00 call %g1 40009bc8: 90 10 00 19 mov %i1, %o0 break; #endif } } 40009bcc: 81 c7 e0 08 ret 40009bd0: 81 e8 00 00 restore if ( (int)(--executing->cpu_time_budget) <= 0 ) { 40009bd4: c2 06 60 8c ld [ %i1 + 0x8c ], %g1 40009bd8: 82 00 7f ff add %g1, -1, %g1 40009bdc: 80 a0 60 00 cmp %g1, 0 40009be0: 14 bf ff fb bg 40009bcc <_Scheduler_default_Tick+0x64> 40009be4: c2 26 60 8c st %g1, [ %i1 + 0x8c ] _Thread_Yield( executing ); 40009be8: 40 00 07 fb call 4000bbd4 <_Thread_Yield> 40009bec: 90 10 00 19 mov %i1, %o0 rtems_configuration_get_ticks_per_timeslice(); 40009bf0: 03 10 00 63 sethi %hi(0x40018c00), %g1 executing->cpu_time_budget = 40009bf4: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 40018d00 40009bf8: c2 26 60 8c st %g1, [ %i1 + 0x8c ] 40009bfc: 81 c7 e0 08 ret 40009c00: 81 e8 00 00 restore 40009c04: 81 c7 e0 08 ret 40009c08: 81 e8 00 00 restore =============================================================================== 40009b18 <_Scheduler_default_Unmap_priority>: Priority_Control _Scheduler_default_Unmap_priority( const Scheduler_Control *scheduler, Priority_Control priority ) { return SCHEDULER_PRIORITY_UNMAP( priority ); 40009b18: 95 32 a0 01 srl %o2, 1, %o2 <== NOT EXECUTED 40009b1c: 83 2a 60 1f sll %o1, 0x1f, %g1 } 40009b20: 91 32 60 01 srl %o1, 1, %o0 40009b24: 81 c3 e0 08 retl 40009b28: 92 10 40 0a or %g1, %o2, %o1 =============================================================================== 40009c2c <_Scheduler_priority_Block>: void _Scheduler_priority_Block( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 40009c2c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Chain_Node *node, Scheduler_priority_Ready_queue *ready_queue, Priority_bit_map_Control *bit_map ) { Chain_Control *ready_chain = ready_queue->ready_chain; 40009c30: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1 if ( _Chain_Has_only_one_node( ready_chain ) ) { 40009c34: c6 00 40 00 ld [ %g1 ], %g3 40009c38: c4 00 60 08 ld [ %g1 + 8 ], %g2 40009c3c: 80 a0 c0 02 cmp %g3, %g2 40009c40: 22 80 00 31 be,a 40009d04 <_Scheduler_priority_Block+0xd8> 40009c44: c6 06 a0 40 ld [ %i2 + 0x40 ], %g3 next = the_node->next; 40009c48: c4 06 40 00 ld [ %i1 ], %g2 previous = the_node->previous; 40009c4c: c2 06 60 04 ld [ %i1 + 4 ], %g1 next->previous = previous; 40009c50: c2 20 a0 04 st %g1, [ %g2 + 4 ] previous->next = next; 40009c54: c4 20 40 00 st %g2, [ %g1 ] RTEMS_INLINE_ROUTINE bool _Thread_Is_executing ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Executing ); 40009c58: b8 10 00 06 mov %g6, %i4 { ( *extract )( scheduler, the_thread, node ); /* TODO: flash critical section? */ if ( _Thread_Is_executing( the_thread ) || _Thread_Is_heir( the_thread ) ) { 40009c5c: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1 40009c60: 80 a6 40 01 cmp %i1, %g1 40009c64: 02 80 00 07 be 40009c80 <_Scheduler_priority_Block+0x54> 40009c68: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3 40009c6c: 80 a6 40 1b cmp %i1, %i3 40009c70: 22 80 00 05 be,a 40009c84 <_Scheduler_priority_Block+0x58> <== NEVER TAKEN 40009c74: f4 06 00 00 ld [ %i0 ], %i2 <== NOT EXECUTED the_thread, node, _Scheduler_priority_Extract_body, _Scheduler_priority_Schedule_body ); } 40009c78: 81 c7 e0 08 ret 40009c7c: 81 e8 00 00 restore 40009c80: f4 06 00 00 ld [ %i0 ], %i2 unsigned int bit_number; #if ( CPU_USE_GENERIC_BITFIELD_CODE == FALSE ) _CPU_Bitfield_Find_first_bit( value, bit_number ); #elif defined(__GNUC__) bit_number = (unsigned int) __builtin_clz( value ) 40009c84: 40 00 37 5c call 400179f4 <__clzsi2> 40009c88: d0 16 80 00 lduh [ %i2 ], %o0 40009c8c: ba 02 3f f0 add %o0, -16, %i5 { unsigned int minor; unsigned int major; major = _Bitfield_Find_first_bit( bit_map->major_bit_map ); minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 40009c90: 83 2f 60 01 sll %i5, 1, %g1 return (_Priority_Bits_index( major ) << 4) + 40009c94: bb 2f 60 04 sll %i5, 4, %i5 minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 40009c98: 82 06 80 01 add %i2, %g1, %g1 bit_number = (unsigned int) __builtin_clz( value ) 40009c9c: 40 00 37 56 call 400179f4 <__clzsi2> 40009ca0: d0 10 60 02 lduh [ %g1 + 2 ], %o0 Priority_bit_map_Control *bit_map, Chain_Control *ready_queues ) { Priority_Control index = _Priority_bit_map_Get_highest( bit_map ); Chain_Node *first = _Chain_First( &ready_queues[ index ] ); 40009ca4: 90 02 00 1d add %o0, %i5, %o0 40009ca8: 90 02 3f f0 add %o0, -16, %o0 return _Chain_Immutable_head( the_chain )->next; 40009cac: bb 2a 20 01 sll %o0, 1, %i5 40009cb0: 90 07 40 08 add %i5, %o0, %o0 40009cb4: 91 2a 20 02 sll %o0, 2, %o0 40009cb8: b4 06 80 08 add %i2, %o0, %i2 40009cbc: fa 06 a0 24 ld [ %i2 + 0x24 ], %i5 bool force_dispatch ) { Thread_Control *heir = _Thread_Heir; if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40009cc0: 80 a7 40 1b cmp %i5, %i3 40009cc4: 02 80 00 0e be 40009cfc <_Scheduler_priority_Block+0xd0> 40009cc8: 01 00 00 00 nop *time = _Timecounter_Sbinuptime(); 40009ccc: 7f ff fa f1 call 40008890 <_Timecounter_Sbinuptime> 40009cd0: e0 1f 20 28 ldd [ %i4 + 0x28 ], %l0 40009cd4: d0 3f 20 28 std %o0, [ %i4 + 0x28 ] const Timestamp_Control *_start, const Timestamp_Control *_end, Timestamp_Control *_result ) { *_result = *_end - *_start; 40009cd8: b2 a2 40 11 subcc %o1, %l1, %i1 *_time += *_add; 40009cdc: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4 *_result = *_end - *_start; 40009ce0: b0 62 00 10 subx %o0, %l0, %i0 *_time += *_add; 40009ce4: 86 83 40 19 addcc %o5, %i1, %g3 40009ce8: 84 43 00 18 addx %o4, %i0, %g2 40009cec: c4 3e e0 98 std %g2, [ %i3 + 0x98 ] heir->Scheduler.state = THREAD_SCHEDULER_BLOCKED; new_heir->Scheduler.state = THREAD_SCHEDULER_SCHEDULED; #endif _Thread_Update_CPU_time_used( heir, _Thread_Get_CPU( heir ) ); _Thread_Heir = new_heir; _Thread_Dispatch_necessary = true; 40009cf0: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 40009cf4: fa 21 a0 24 st %i5, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 40009cf8: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] 40009cfc: 81 c7 e0 08 ret 40009d00: 81 e8 00 00 restore *bit_map_info->minor &= bit_map_info->block_minor; 40009d04: c4 10 c0 00 lduh [ %g3 ], %g2 40009d08: f8 16 a0 4a lduh [ %i2 + 0x4a ], %i4 40009d0c: c8 06 00 00 ld [ %i0 ], %g4 return &the_chain->Tail.Node; 40009d10: ba 00 60 04 add %g1, 4, %i5 head->previous = NULL; 40009d14: c0 20 60 04 clr [ %g1 + 4 ] 40009d18: 84 08 80 1c and %g2, %i4, %g2 head->next = tail; 40009d1c: fa 20 40 00 st %i5, [ %g1 ] if ( *bit_map_info->minor == 0 ) 40009d20: 80 a0 a0 00 cmp %g2, 0 tail->previous = head; 40009d24: c2 20 60 08 st %g1, [ %g1 + 8 ] 40009d28: 12 bf ff cc bne 40009c58 <_Scheduler_priority_Block+0x2c> 40009d2c: c4 30 c0 00 sth %g2, [ %g3 ] bit_map->major_bit_map &= bit_map_info->block_major; 40009d30: c2 11 00 00 lduh [ %g4 ], %g1 40009d34: c4 16 a0 48 lduh [ %i2 + 0x48 ], %g2 40009d38: 82 08 40 02 and %g1, %g2, %g1 40009d3c: 10 bf ff c7 b 40009c58 <_Scheduler_priority_Block+0x2c> 40009d40: c2 31 00 00 sth %g1, [ %g4 ] =============================================================================== 40009f2c <_Scheduler_priority_Initialize>: #endif #include void _Scheduler_priority_Initialize( const Scheduler_Control *scheduler ) { 40009f2c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 40009f30: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED memset( bit_map, 0, sizeof( *bit_map ) ); 40009f34: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED 40009f38: 94 10 20 22 mov 0x22, %o2 40009f3c: 40 00 14 b1 call 4000f200 40009f40: 92 10 20 00 clr %o1 40009f44: c4 06 20 44 ld [ %i0 + 0x44 ], %g2 Scheduler_priority_Context *context = _Scheduler_priority_Get_context( scheduler ); _Priority_bit_map_Initialize( &context->Bit_map ); _Scheduler_priority_Ready_queue_initialize( 40009f48: 90 02 20 24 add %o0, 0x24, %o0 40009f4c: 83 28 a0 01 sll %g2, 1, %g1 40009f50: 82 00 40 02 add %g1, %g2, %g1 40009f54: 83 28 60 02 sll %g1, 2, %g1 40009f58: 82 02 00 01 add %o0, %g1, %g1 head->next = tail; 40009f5c: 84 02 20 04 add %o0, 4, %g2 head->previous = NULL; 40009f60: c0 22 20 04 clr [ %o0 + 4 ] for ( index = 0 ; index <= (size_t) maximum_priority ; ++index ) { 40009f64: 80 a2 00 01 cmp %o0, %g1 head->next = tail; 40009f68: c4 22 00 00 st %g2, [ %o0 ] tail->previous = head; 40009f6c: d0 22 20 08 st %o0, [ %o0 + 8 ] 40009f70: 12 bf ff fb bne 40009f5c <_Scheduler_priority_Initialize+0x30> 40009f74: 90 02 20 0c add %o0, 0xc, %o0 &context->Ready[ 0 ], scheduler->maximum_priority ); } 40009f78: 81 c7 e0 08 ret 40009f7c: 81 e8 00 00 restore =============================================================================== 40009f80 <_Scheduler_priority_Node_initialize>: const Scheduler_Control *scheduler, Scheduler_Node *node, Thread_Control *the_thread, Priority_Control priority ) { 40009f80: da 02 00 00 ld [ %o0 ], %o5 <== NOT EXECUTED context = _Scheduler_priority_Get_context( scheduler ); the_node = _Scheduler_priority_Node_downcast( node ); _Scheduler_priority_Ready_queue_update( &the_node->Ready_queue, SCHEDULER_PRIORITY_UNMAP( priority ), 40009f84: 85 2a e0 1f sll %o3, 0x1f, %g2 _Scheduler_priority_Ready_queue_update( 40009f88: 90 03 60 24 add %o5, 0x24, %o0 return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 40009f8c: 07 00 00 20 sethi %hi(0x8000), %g3 SCHEDULER_PRIORITY_UNMAP( priority ), 40009f90: 83 33 20 01 srl %o4, 1, %g1 Scheduler_Node *node, Thread_Control *the_thread, Priority_Control priority ) { node->owner = the_thread; 40009f94: d4 22 40 00 st %o2, [ %o1 ] 40009f98: 82 10 80 01 or %g2, %g1, %g1 return the_priority / 16; 40009f9c: 85 30 60 04 srl %g1, 4, %g2 return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 40009fa0: 95 30 c0 02 srl %g3, %g2, %o2 bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 40009fa4: 84 00 a0 01 inc %g2 40009fa8: 85 28 a0 01 sll %g2, 1, %g2 40009fac: 84 03 40 02 add %o5, %g2, %g2 return the_priority % 16; 40009fb0: 9a 08 60 0f and %g1, 0xf, %o5 ready_queue->ready_chain = &ready_queues[ new_priority ]; 40009fb4: 89 28 60 01 sll %g1, 1, %g4 return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 40009fb8: 87 30 c0 0d srl %g3, %o5, %g3 40009fbc: 88 01 00 01 add %g4, %g1, %g4 bit_map_info->block_minor = (Priority_bit_map_Word) ~mask; 40009fc0: 9a 38 00 03 xnor %g0, %g3, %o5 40009fc4: 89 29 20 02 sll %g4, 2, %g4 node->Priority.value = priority; 40009fc8: d6 22 60 30 st %o3, [ %o1 + 0x30 ] 40009fcc: 88 02 00 04 add %o0, %g4, %g4 40009fd0: d8 22 60 34 st %o4, [ %o1 + 0x34 ] bit_map_info->block_major = (Priority_bit_map_Word) ~mask; 40009fd4: 90 38 00 0a xnor %g0, %o2, %o0 ready_queue->current_priority = new_priority; 40009fd8: c2 22 60 38 st %g1, [ %o1 + 0x38 ] ready_queue->ready_chain = &ready_queues[ new_priority ]; 40009fdc: c8 22 60 3c st %g4, [ %o1 + 0x3c ] bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 40009fe0: c4 22 60 40 st %g2, [ %o1 + 0x40 ] bit_map_info->ready_major = mask; 40009fe4: d4 32 60 44 sth %o2, [ %o1 + 0x44 ] bit_map_info->block_major = (Priority_bit_map_Word) ~mask; 40009fe8: d0 32 60 48 sth %o0, [ %o1 + 0x48 ] bit_map_info->ready_minor = mask; 40009fec: c6 32 60 46 sth %g3, [ %o1 + 0x46 ] &context->Bit_map, &context->Ready[ 0 ] ); } 40009ff0: 81 c3 e0 08 retl 40009ff4: da 32 60 4a sth %o5, [ %o1 + 0x4a ] =============================================================================== 40009ff8 <_Scheduler_priority_Schedule>: void _Scheduler_priority_Schedule( const Scheduler_Control *scheduler, Thread_Control *the_thread ) { 40009ff8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 40009ffc: f8 06 00 00 ld [ %i0 ], %i4 <== NOT EXECUTED bit_number = (unsigned int) __builtin_clz( value ) 4000a000: 40 00 36 7d call 400179f4 <__clzsi2> <== NOT EXECUTED 4000a004: d0 17 00 00 lduh [ %i4 ], %o0 <== NOT EXECUTED 4000a008: ba 02 3f f0 add %o0, -16, %i5 minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 4000a00c: 83 2f 60 01 sll %i5, 1, %g1 return (_Priority_Bits_index( major ) << 4) + 4000a010: bb 2f 60 04 sll %i5, 4, %i5 minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 4000a014: 82 07 00 01 add %i4, %g1, %g1 bit_number = (unsigned int) __builtin_clz( value ) 4000a018: 40 00 36 77 call 400179f4 <__clzsi2> 4000a01c: d0 10 60 02 lduh [ %g1 + 2 ], %o0 Chain_Node *first = _Chain_First( &ready_queues[ index ] ); 4000a020: 90 02 00 1d add %o0, %i5, %o0 4000a024: 90 02 3f f0 add %o0, -16, %o0 return _Chain_Immutable_head( the_chain )->next; 4000a028: bb 2a 20 01 sll %o0, 1, %i5 Thread_Control *heir = _Thread_Heir; 4000a02c: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3 4000a030: 90 07 40 08 add %i5, %o0, %o0 4000a034: 91 2a 20 02 sll %o0, 2, %o0 4000a038: b8 07 00 08 add %i4, %o0, %i4 4000a03c: fa 07 20 24 ld [ %i4 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000a040: 80 a7 40 1b cmp %i5, %i3 4000a044: 02 80 00 06 be 4000a05c <_Scheduler_priority_Schedule+0x64> 4000a048: b4 10 00 06 mov %g6, %i2 4000a04c: c2 0e e0 89 ldub [ %i3 + 0x89 ], %g1 4000a050: 80 a0 60 00 cmp %g1, 0 4000a054: 12 80 00 04 bne 4000a064 <_Scheduler_priority_Schedule+0x6c> <== ALWAYS TAKEN 4000a058: 01 00 00 00 nop _Scheduler_priority_Schedule_body( scheduler, the_thread, false ); } 4000a05c: 81 c7 e0 08 ret 4000a060: 81 e8 00 00 restore 4000a064: 7f ff fa 0b call 40008890 <_Timecounter_Sbinuptime> 4000a068: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 4000a06c: d0 3e a0 28 std %o0, [ %i2 + 0x28 ] *_result = *_end - *_start; 4000a070: b2 a2 40 11 subcc %o1, %l1, %i1 *_time += *_add; 4000a074: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4 *_result = *_end - *_start; 4000a078: b0 62 00 10 subx %o0, %l0, %i0 *_time += *_add; 4000a07c: 86 83 40 19 addcc %o5, %i1, %g3 4000a080: 84 43 00 18 addx %o4, %i0, %g2 4000a084: c4 3e e0 98 std %g2, [ %i3 + 0x98 ] _Thread_Dispatch_necessary = true; 4000a088: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 4000a08c: fa 21 a0 24 st %i5, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 4000a090: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] 4000a094: 81 c7 e0 08 ret 4000a098: 81 e8 00 00 restore =============================================================================== 4000a09c <_Scheduler_priority_Unblock>: void _Scheduler_priority_Unblock ( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 4000a09c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 4000a0a0: f6 06 a0 34 ld [ %i2 + 0x34 ], %i3 <== NOT EXECUTED context = _Scheduler_priority_Get_context( scheduler ); the_node = _Scheduler_priority_Node_downcast( node ); priority = (unsigned int ) _Scheduler_Node_get_priority( &the_node->Base ); unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority ); if ( unmapped_priority != the_node->Ready_queue.current_priority ) { 4000a0a4: c2 06 a0 38 ld [ %i2 + 0x38 ], %g1 <== NOT EXECUTED unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority ); 4000a0a8: 87 36 e0 01 srl %i3, 1, %g3 <== NOT EXECUTED if ( unmapped_priority != the_node->Ready_queue.current_priority ) { 4000a0ac: 80 a0 40 03 cmp %g1, %g3 4000a0b0: 02 80 00 4a be 4000a1d8 <_Scheduler_priority_Unblock+0x13c> <== ALWAYS TAKEN 4000a0b4: fa 06 00 00 ld [ %i0 ], %i5 ready_queue->ready_chain = &ready_queues[ new_priority ]; 4000a0b8: b9 28 e0 01 sll %g3, 1, %i4 4000a0bc: b8 07 00 03 add %i4, %g3, %i4 4000a0c0: b9 2f 20 02 sll %i4, 2, %i4 _Scheduler_priority_Ready_queue_update( 4000a0c4: 84 07 60 24 add %i5, 0x24, %g2 4000a0c8: 84 00 80 1c add %g2, %i4, %g2 return the_priority % 16; 4000a0cc: b8 08 e0 0f and %g3, 0xf, %i4 return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 4000a0d0: 09 00 00 20 sethi %hi(0x8000), %g4 return the_priority / 16; 4000a0d4: 83 36 e0 05 srl %i3, 5, %g1 ready_queue->current_priority = new_priority; 4000a0d8: c6 26 a0 38 st %g3, [ %i2 + 0x38 ] return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 4000a0dc: b1 31 00 01 srl %g4, %g1, %i0 4000a0e0: 87 31 00 1c srl %g4, %i4, %g3 bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 4000a0e4: 82 00 60 01 inc %g1 bit_map_info->block_major = (Priority_bit_map_Word) ~mask; 4000a0e8: 9e 38 00 18 xnor %g0, %i0, %o7 bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 4000a0ec: 83 28 60 01 sll %g1, 1, %g1 bit_map_info->block_minor = (Priority_bit_map_Word) ~mask; 4000a0f0: b8 38 00 03 xnor %g0, %g3, %i4 bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 4000a0f4: 82 07 40 01 add %i5, %g1, %g1 ready_queue->ready_chain = &ready_queues[ new_priority ]; 4000a0f8: c4 26 a0 3c st %g2, [ %i2 + 0x3c ] return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 4000a0fc: 88 10 00 03 mov %g3, %g4 bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 4000a100: c2 26 a0 40 st %g1, [ %i2 + 0x40 ] bit_map_info->ready_major = mask; 4000a104: f0 36 a0 44 sth %i0, [ %i2 + 0x44 ] bit_map_info->block_major = (Priority_bit_map_Word) ~mask; 4000a108: de 36 a0 48 sth %o7, [ %i2 + 0x48 ] bit_map_info->ready_minor = mask; 4000a10c: c6 36 a0 46 sth %g3, [ %i2 + 0x46 ] bit_map_info->block_minor = (Priority_bit_map_Word) ~mask; 4000a110: f8 36 a0 4a sth %i4, [ %i2 + 0x4a ] return &the_chain->Tail.Node; 4000a114: b8 00 a0 04 add %g2, 4, %i4 old_last = tail->previous; 4000a118: c6 00 a0 08 ld [ %g2 + 8 ], %g3 the_node->next = tail; 4000a11c: f8 26 40 00 st %i4, [ %i1 ] tail->previous = the_node; 4000a120: f2 20 a0 08 st %i1, [ %g2 + 8 ] old_last->next = the_node; 4000a124: f2 20 c0 00 st %i1, [ %g3 ] *bit_map_info->minor |= bit_map_info->ready_minor; 4000a128: c4 10 40 00 lduh [ %g1 ], %g2 the_node->previous = old_last; 4000a12c: c6 26 60 04 st %g3, [ %i1 + 4 ] 4000a130: 84 10 80 04 or %g2, %g4, %g2 4000a134: c4 30 40 00 sth %g2, [ %g1 ] * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( priority < _Thread_Get_priority( _Thread_Heir ) ) { 4000a138: f8 01 a0 24 ld [ %g6 + 0x24 ], %i4 bit_map->major_bit_map |= bit_map_info->ready_major; 4000a13c: c4 16 a0 44 lduh [ %i2 + 0x44 ], %g2 4000a140: c2 17 40 00 lduh [ %i5 ], %g1 4000a144: 82 10 40 02 or %g1, %g2, %g1 4000a148: c4 07 20 38 ld [ %i4 + 0x38 ], %g2 4000a14c: c2 37 40 00 sth %g1, [ %i5 ] 4000a150: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1 4000a154: 80 a0 60 00 cmp %g1, 0 4000a158: 18 80 00 09 bgu 4000a17c <_Scheduler_priority_Unblock+0xe0> <== NEVER TAKEN 4000a15c: b0 10 00 06 mov %g6, %i0 4000a160: 22 80 00 04 be,a 4000a170 <_Scheduler_priority_Unblock+0xd4> <== ALWAYS TAKEN 4000a164: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 _Scheduler_Update_heir( the_thread, priority == PRIORITY_PSEUDO_ISR ); } } 4000a168: 81 c7 e0 08 ret <== NOT EXECUTED 4000a16c: 81 e8 00 00 restore <== NOT EXECUTED if ( priority < _Thread_Get_priority( _Thread_Heir ) ) { 4000a170: 80 a0 40 1b cmp %g1, %i3 4000a174: 08 80 00 17 bleu 4000a1d0 <_Scheduler_priority_Unblock+0x134> 4000a178: 01 00 00 00 nop if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000a17c: 80 a7 00 19 cmp %i4, %i1 4000a180: 02 bf ff fa be 4000a168 <_Scheduler_priority_Unblock+0xcc> <== NEVER TAKEN 4000a184: 80 a6 e0 00 cmp %i3, 0 4000a188: 02 80 00 06 be 4000a1a0 <_Scheduler_priority_Unblock+0x104> 4000a18c: 01 00 00 00 nop 4000a190: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1 4000a194: 80 a0 60 00 cmp %g1, 0 4000a198: 02 80 00 0e be 4000a1d0 <_Scheduler_priority_Unblock+0x134> 4000a19c: 01 00 00 00 nop 4000a1a0: 7f ff f9 bc call 40008890 <_Timecounter_Sbinuptime> 4000a1a4: e0 1e 20 28 ldd [ %i0 + 0x28 ], %l0 4000a1a8: d0 3e 20 28 std %o0, [ %i0 + 0x28 ] *_result = *_end - *_start; 4000a1ac: b6 a2 40 11 subcc %o1, %l1, %i3 *_time += *_add; 4000a1b0: d8 1f 20 98 ldd [ %i4 + 0x98 ], %o4 *_result = *_end - *_start; 4000a1b4: b4 62 00 10 subx %o0, %l0, %i2 *_time += *_add; 4000a1b8: 86 83 40 1b addcc %o5, %i3, %g3 4000a1bc: 84 43 00 1a addx %o4, %i2, %g2 4000a1c0: c4 3f 20 98 std %g2, [ %i4 + 0x98 ] _Thread_Dispatch_necessary = true; 4000a1c4: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 4000a1c8: f2 21 a0 24 st %i1, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 4000a1cc: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] } 4000a1d0: 81 c7 e0 08 ret 4000a1d4: 81 e8 00 00 restore 4000a1d8: c4 06 a0 3c ld [ %i2 + 0x3c ], %g2 4000a1dc: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1 4000a1e0: 10 bf ff cd b 4000a114 <_Scheduler_priority_Unblock+0x78> 4000a1e4: c8 16 a0 46 lduh [ %i2 + 0x46 ], %g4 =============================================================================== 40009d44 <_Scheduler_priority_Update_priority>: void _Scheduler_priority_Update_priority( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 40009d44: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Scheduler_priority_Context *context; Scheduler_priority_Node *the_node; unsigned int new_priority; unsigned int unmapped_priority; if ( !_Thread_Is_ready( the_thread ) ) { 40009d48: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED 40009d4c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009d50: 12 80 00 5c bne 40009ec0 <_Scheduler_priority_Update_priority+0x17c> <== NOT EXECUTED 40009d54: 01 00 00 00 nop /* Nothing to do */ return; } the_node = _Scheduler_priority_Node_downcast( node ); new_priority = (unsigned int) 40009d58: f6 06 a0 34 ld [ %i2 + 0x34 ], %i3 _Scheduler_Node_get_priority( &the_node->Base ); unmapped_priority = SCHEDULER_PRIORITY_UNMAP( new_priority ); if ( unmapped_priority == the_node->Ready_queue.current_priority ) { 40009d5c: c2 06 a0 38 ld [ %i2 + 0x38 ], %g1 unmapped_priority = SCHEDULER_PRIORITY_UNMAP( new_priority ); 40009d60: 87 36 e0 01 srl %i3, 1, %g3 if ( unmapped_priority == the_node->Ready_queue.current_priority ) { 40009d64: 80 a0 40 03 cmp %g1, %g3 40009d68: 02 80 00 56 be 40009ec0 <_Scheduler_priority_Update_priority+0x17c> 40009d6c: 01 00 00 00 nop Chain_Control *ready_chain = ready_queue->ready_chain; 40009d70: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1 if ( _Chain_Has_only_one_node( ready_chain ) ) { 40009d74: c8 00 40 00 ld [ %g1 ], %g4 40009d78: c4 00 60 08 ld [ %g1 + 8 ], %g2 40009d7c: 80 a1 00 02 cmp %g4, %g2 40009d80: 02 80 00 52 be 40009ec8 <_Scheduler_priority_Update_priority+0x184> 40009d84: fa 06 00 00 ld [ %i0 ], %i5 next = the_node->next; 40009d88: c4 06 40 00 ld [ %i1 ], %g2 previous = the_node->previous; 40009d8c: c2 06 60 04 ld [ %i1 + 4 ], %g1 next->previous = previous; 40009d90: c2 20 a0 04 st %g1, [ %g2 + 4 ] previous->next = next; 40009d94: c4 20 40 00 st %g2, [ %g1 ] return the_priority / 16; 40009d98: 85 36 e0 05 srl %i3, 5, %g2 return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 40009d9c: 03 00 00 20 sethi %hi(0x8000), %g1 Priority_bit_map_Control *bit_map, Chain_Control *ready_queues ) { ready_queue->current_priority = new_priority; ready_queue->ready_chain = &ready_queues[ new_priority ]; 40009da0: 89 28 e0 01 sll %g3, 1, %g4 40009da4: 9f 30 40 02 srl %g1, %g2, %o7 40009da8: 88 01 00 03 add %g4, %g3, %g4 return the_priority % 16; 40009dac: 96 08 e0 0f and %g3, 0xf, %o3 &the_thread->Object.Node, &the_node->Ready_queue, &context->Bit_map ); _Scheduler_priority_Ready_queue_update( 40009db0: 9a 07 60 24 add %i5, 0x24, %o5 return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 40009db4: 83 30 40 0b srl %g1, %o3, %g1 Priority_bit_map_Word mask; major = _Priority_Major( new_priority ); minor = _Priority_Minor( new_priority ); bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 40009db8: b8 00 a0 01 add %g2, 1, %i4 40009dbc: 89 29 20 02 sll %g4, 2, %g4 40009dc0: b9 2f 20 01 sll %i4, 1, %i4 40009dc4: b0 03 40 04 add %o5, %g4, %i0 40009dc8: b8 07 40 1c add %i5, %i4, %i4 mask = _Priority_Mask( major ); bit_map_info->ready_major = mask; bit_map_info->block_major = (Priority_bit_map_Word) ~mask; 40009dcc: 98 38 00 0f xnor %g0, %o7, %o4 ready_queue->current_priority = new_priority; 40009dd0: c6 26 a0 38 st %g3, [ %i2 + 0x38 ] mask = _Priority_Mask( minor ); bit_map_info->ready_minor = mask; bit_map_info->block_minor = (Priority_bit_map_Word) ~mask; 40009dd4: 86 38 00 01 xnor %g0, %g1, %g3 ready_queue->ready_chain = &ready_queues[ new_priority ]; 40009dd8: f0 26 a0 3c st %i0, [ %i2 + 0x3c ] unmapped_priority, &context->Bit_map, &context->Ready[ 0 ] ); if ( SCHEDULER_PRIORITY_IS_APPEND( new_priority ) ) { 40009ddc: 80 8e e0 01 btst 1, %i3 bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 40009de0: f8 26 a0 40 st %i4, [ %i2 + 0x40 ] bit_map_info->ready_major = mask; 40009de4: de 36 a0 44 sth %o7, [ %i2 + 0x44 ] bit_map_info->block_major = (Priority_bit_map_Word) ~mask; 40009de8: d8 36 a0 48 sth %o4, [ %i2 + 0x48 ] bit_map_info->ready_minor = mask; 40009dec: c2 36 a0 46 sth %g1, [ %i2 + 0x46 ] 40009df0: 02 80 00 46 be 40009f08 <_Scheduler_priority_Update_priority+0x1c4> 40009df4: c6 36 a0 4a sth %g3, [ %i2 + 0x4a ] old_last = tail->previous; 40009df8: c6 06 20 08 ld [ %i0 + 8 ], %g3 return &the_chain->Tail.Node; 40009dfc: 88 06 20 04 add %i0, 4, %g4 the_node->next = tail; 40009e00: c8 26 40 00 st %g4, [ %i1 ] 40009e04: 85 28 a0 01 sll %g2, 1, %g2 tail->previous = the_node; 40009e08: f2 26 20 08 st %i1, [ %i0 + 8 ] 40009e0c: 84 07 40 02 add %i5, %g2, %g2 old_last->next = the_node; 40009e10: f2 20 c0 00 st %i1, [ %g3 ] *bit_map_info->minor |= bit_map_info->ready_minor; 40009e14: c8 10 a0 02 lduh [ %g2 + 2 ], %g4 the_node->previous = old_last; 40009e18: c6 26 60 04 st %g3, [ %i1 + 4 ] 40009e1c: 82 10 40 04 or %g1, %g4, %g1 40009e20: c2 30 a0 02 sth %g1, [ %g2 + 2 ] bit_map->major_bit_map |= bit_map_info->ready_major; 40009e24: c4 16 a0 44 lduh [ %i2 + 0x44 ], %g2 40009e28: c2 17 40 00 lduh [ %i5 ], %g1 40009e2c: 82 10 40 02 or %g1, %g2, %g1 40009e30: c2 37 40 00 sth %g1, [ %i5 ] bit_number = (unsigned int) __builtin_clz( value ) 40009e34: 40 00 36 f0 call 400179f4 <__clzsi2> 40009e38: d0 17 40 00 lduh [ %i5 ], %o0 40009e3c: b8 02 3f f0 add %o0, -16, %i4 minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 40009e40: 83 2f 20 01 sll %i4, 1, %g1 return (_Priority_Bits_index( major ) << 4) + 40009e44: b9 2f 20 04 sll %i4, 4, %i4 minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 40009e48: 82 07 40 01 add %i5, %g1, %g1 bit_number = (unsigned int) __builtin_clz( value ) 40009e4c: 40 00 36 ea call 400179f4 <__clzsi2> 40009e50: d0 10 60 02 lduh [ %g1 + 2 ], %o0 Chain_Node *first = _Chain_First( &ready_queues[ index ] ); 40009e54: 90 02 00 1c add %o0, %i4, %o0 Thread_Control *heir = _Thread_Heir; 40009e58: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3 40009e5c: 90 02 3f f0 add %o0, -16, %o0 return _Chain_Immutable_head( the_chain )->next; 40009e60: b9 2a 20 01 sll %o0, 1, %i4 40009e64: 90 07 00 08 add %i4, %o0, %o0 40009e68: 91 2a 20 02 sll %o0, 2, %o0 40009e6c: ba 07 40 08 add %i5, %o0, %i5 40009e70: fa 07 60 24 ld [ %i5 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40009e74: 80 a7 40 1b cmp %i5, %i3 40009e78: 02 80 00 12 be 40009ec0 <_Scheduler_priority_Update_priority+0x17c> 40009e7c: b4 10 00 06 mov %g6, %i2 40009e80: c2 0e e0 89 ldub [ %i3 + 0x89 ], %g1 40009e84: 80 a0 60 00 cmp %g1, 0 40009e88: 02 80 00 0e be 40009ec0 <_Scheduler_priority_Update_priority+0x17c> 40009e8c: 01 00 00 00 nop 40009e90: 7f ff fa 80 call 40008890 <_Timecounter_Sbinuptime> 40009e94: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 40009e98: d0 3e a0 28 std %o0, [ %i2 + 0x28 ] *_result = *_end - *_start; 40009e9c: b2 a2 40 11 subcc %o1, %l1, %i1 *_time += *_add; 40009ea0: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4 *_result = *_end - *_start; 40009ea4: b0 62 00 10 subx %o0, %l0, %i0 *_time += *_add; 40009ea8: 86 83 40 19 addcc %o5, %i1, %g3 40009eac: 84 43 00 18 addx %o4, %i0, %g2 40009eb0: c4 3e e0 98 std %g2, [ %i3 + 0x98 ] _Thread_Dispatch_necessary = true; 40009eb4: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 40009eb8: fa 21 a0 24 st %i5, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 40009ebc: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] &context->Bit_map ); } _Scheduler_priority_Schedule_body( scheduler, the_thread, false ); } 40009ec0: 81 c7 e0 08 ret 40009ec4: 81 e8 00 00 restore *bit_map_info->minor &= bit_map_info->block_minor; 40009ec8: c8 06 a0 40 ld [ %i2 + 0x40 ], %g4 40009ecc: c4 11 00 00 lduh [ %g4 ], %g2 40009ed0: f0 16 a0 4a lduh [ %i2 + 0x4a ], %i0 return &the_chain->Tail.Node; 40009ed4: b8 00 60 04 add %g1, 4, %i4 head->previous = NULL; 40009ed8: c0 20 60 04 clr [ %g1 + 4 ] 40009edc: 84 08 80 18 and %g2, %i0, %g2 head->next = tail; 40009ee0: f8 20 40 00 st %i4, [ %g1 ] if ( *bit_map_info->minor == 0 ) 40009ee4: 80 a0 a0 00 cmp %g2, 0 tail->previous = head; 40009ee8: c2 20 60 08 st %g1, [ %g1 + 8 ] 40009eec: 12 bf ff ab bne 40009d98 <_Scheduler_priority_Update_priority+0x54> 40009ef0: c4 31 00 00 sth %g2, [ %g4 ] bit_map->major_bit_map &= bit_map_info->block_major; 40009ef4: c2 17 40 00 lduh [ %i5 ], %g1 40009ef8: c4 16 a0 48 lduh [ %i2 + 0x48 ], %g2 40009efc: 82 08 40 02 and %g1, %g2, %g1 40009f00: 10 bf ff a6 b 40009d98 <_Scheduler_priority_Update_priority+0x54> 40009f04: c2 37 40 00 sth %g1, [ %i5 ] the_node->previous = after_node; 40009f08: f0 26 60 04 st %i0, [ %i1 + 4 ] 40009f0c: 85 28 a0 01 sll %g2, 1, %g2 before_node = after_node->next; 40009f10: c6 03 40 04 ld [ %o5 + %g4 ], %g3 after_node->next = the_node; 40009f14: f2 23 40 04 st %i1, [ %o5 + %g4 ] 40009f18: 84 07 40 02 add %i5, %g2, %g2 the_node->next = before_node; 40009f1c: c6 26 40 00 st %g3, [ %i1 ] *bit_map_info->minor |= bit_map_info->ready_minor; 40009f20: c8 10 a0 02 lduh [ %g2 + 2 ], %g4 before_node->previous = the_node; 40009f24: 10 bf ff be b 40009e1c <_Scheduler_priority_Update_priority+0xd8> 40009f28: f2 20 e0 04 st %i1, [ %g3 + 4 ] =============================================================================== 4000a1e8 <_Scheduler_priority_Yield>: void _Scheduler_priority_Yield( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 4000a1e8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Scheduler_priority_Node *the_node; Chain_Control *ready_chain; the_node = _Scheduler_priority_Node_downcast( node ); ready_chain = the_node->Ready_queue.ready_chain; 4000a1ec: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1 <== NOT EXECUTED if ( !_Chain_Has_only_one_node( ready_chain ) ) { 4000a1f0: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED 4000a1f4: c4 00 40 00 ld [ %g1 ], %g2 <== NOT EXECUTED 4000a1f8: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED 4000a1fc: 02 80 00 0b be 4000a228 <_Scheduler_priority_Yield+0x40> <== NOT EXECUTED 4000a200: 88 00 60 04 add %g1, 4, %g4 previous = the_node->previous; 4000a204: c4 06 60 04 ld [ %i1 + 4 ], %g2 next = the_node->next; 4000a208: c6 06 40 00 ld [ %i1 ], %g3 next->previous = previous; 4000a20c: c4 20 e0 04 st %g2, [ %g3 + 4 ] previous->next = next; 4000a210: c6 20 80 00 st %g3, [ %g2 ] old_last = tail->previous; 4000a214: c4 00 60 08 ld [ %g1 + 8 ], %g2 the_node->next = tail; 4000a218: c8 26 40 00 st %g4, [ %i1 ] tail->previous = the_node; 4000a21c: f2 20 60 08 st %i1, [ %g1 + 8 ] old_last->next = the_node; 4000a220: f2 20 80 00 st %i1, [ %g2 ] the_node->previous = old_last; 4000a224: c4 26 60 04 st %g2, [ %i1 + 4 ] 4000a228: f8 06 00 00 ld [ %i0 ], %i4 bit_number = (unsigned int) __builtin_clz( value ) 4000a22c: 40 00 35 f2 call 400179f4 <__clzsi2> 4000a230: d0 17 00 00 lduh [ %i4 ], %o0 4000a234: ba 02 3f f0 add %o0, -16, %i5 minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 4000a238: 83 2f 60 01 sll %i5, 1, %g1 return (_Priority_Bits_index( major ) << 4) + 4000a23c: bb 2f 60 04 sll %i5, 4, %i5 minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 4000a240: 82 07 00 01 add %i4, %g1, %g1 bit_number = (unsigned int) __builtin_clz( value ) 4000a244: 40 00 35 ec call 400179f4 <__clzsi2> 4000a248: d0 10 60 02 lduh [ %g1 + 2 ], %o0 Chain_Node *first = _Chain_First( &ready_queues[ index ] ); 4000a24c: 90 02 00 1d add %o0, %i5, %o0 4000a250: 90 02 3f f0 add %o0, -16, %o0 return _Chain_Immutable_head( the_chain )->next; 4000a254: bb 2a 20 01 sll %o0, 1, %i5 Thread_Control *heir = _Thread_Heir; 4000a258: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3 4000a25c: 90 07 40 08 add %i5, %o0, %o0 4000a260: 91 2a 20 02 sll %o0, 2, %o0 4000a264: b8 07 00 08 add %i4, %o0, %i4 4000a268: fa 07 20 24 ld [ %i4 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000a26c: 80 a7 40 1b cmp %i5, %i3 4000a270: 02 80 00 0e be 4000a2a8 <_Scheduler_priority_Yield+0xc0> 4000a274: b4 10 00 06 mov %g6, %i2 4000a278: 7f ff f9 86 call 40008890 <_Timecounter_Sbinuptime> 4000a27c: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 4000a280: d0 3e a0 28 std %o0, [ %i2 + 0x28 ] *_result = *_end - *_start; 4000a284: b2 a2 40 11 subcc %o1, %l1, %i1 *_time += *_add; 4000a288: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4 *_result = *_end - *_start; 4000a28c: b0 62 00 10 subx %o0, %l0, %i0 *_time += *_add; 4000a290: 86 83 40 19 addcc %o5, %i1, %g3 4000a294: 84 43 00 18 addx %o4, %i0, %g2 4000a298: c4 3e e0 98 std %g2, [ %i3 + 0x98 ] _Thread_Dispatch_necessary = true; 4000a29c: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 4000a2a0: fa 21 a0 24 st %i5, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 4000a2a4: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] _Chain_Extract_unprotected( &the_thread->Object.Node ); _Chain_Append_unprotected( ready_chain, &the_thread->Object.Node ); } _Scheduler_priority_Schedule_body( scheduler, the_thread, true ); } 4000a2a8: 81 c7 e0 08 ret 4000a2ac: 81 e8 00 00 restore =============================================================================== 4000a5fc <_Scheduler_simple_Block>: void _Scheduler_simple_Block( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 4000a5fc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED previous = the_node->previous; 4000a600: c2 06 60 04 ld [ %i1 + 4 ], %g1 <== NOT EXECUTED next = the_node->next; 4000a604: c4 06 40 00 ld [ %i1 ], %g2 <== NOT EXECUTED next->previous = previous; 4000a608: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED return ( the_thread == _Thread_Executing ); 4000a60c: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED previous->next = next; 4000a610: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED { ( *extract )( scheduler, the_thread, node ); /* TODO: flash critical section? */ if ( _Thread_Is_executing( the_thread ) || _Thread_Is_heir( the_thread ) ) { 4000a614: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1 <== NOT EXECUTED 4000a618: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED 4000a61c: 02 80 00 07 be 4000a638 <_Scheduler_simple_Block+0x3c> <== NOT EXECUTED 4000a620: f8 01 a0 24 ld [ %g6 + 0x24 ], %i4 4000a624: 80 a6 40 1c cmp %i1, %i4 4000a628: 22 80 00 05 be,a 4000a63c <_Scheduler_simple_Block+0x40> <== NEVER TAKEN 4000a62c: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED the_thread, node, _Scheduler_simple_Extract, _Scheduler_simple_Schedule_body ); } 4000a630: 81 c7 e0 08 ret 4000a634: 81 e8 00 00 restore return _Chain_Immutable_head( the_chain )->next; 4000a638: c2 06 00 00 ld [ %i0 ], %g1 4000a63c: f6 00 40 00 ld [ %g1 ], %i3 bool force_dispatch ) { Thread_Control *heir = _Thread_Heir; if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000a640: 80 a6 c0 1c cmp %i3, %i4 4000a644: 02 80 00 0e be 4000a67c <_Scheduler_simple_Block+0x80> <== NEVER TAKEN 4000a648: 01 00 00 00 nop *time = _Timecounter_Sbinuptime(); 4000a64c: 7f ff fa 6a call 40008ff4 <_Timecounter_Sbinuptime> 4000a650: e0 1f 60 28 ldd [ %i5 + 0x28 ], %l0 4000a654: d0 3f 60 28 std %o0, [ %i5 + 0x28 ] const Timestamp_Control *_start, const Timestamp_Control *_end, Timestamp_Control *_result ) { *_result = *_end - *_start; 4000a658: b2 a2 40 11 subcc %o1, %l1, %i1 *_time += *_add; 4000a65c: d8 1f 20 98 ldd [ %i4 + 0x98 ], %o4 *_result = *_end - *_start; 4000a660: b0 62 00 10 subx %o0, %l0, %i0 *_time += *_add; 4000a664: 86 83 40 19 addcc %o5, %i1, %g3 4000a668: 84 43 00 18 addx %o4, %i0, %g2 4000a66c: c4 3f 20 98 std %g2, [ %i4 + 0x98 ] heir->Scheduler.state = THREAD_SCHEDULER_BLOCKED; new_heir->Scheduler.state = THREAD_SCHEDULER_SCHEDULED; #endif _Thread_Update_CPU_time_used( heir, _Thread_Get_CPU( heir ) ); _Thread_Heir = new_heir; _Thread_Dispatch_necessary = true; 4000a670: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 4000a674: f6 21 a0 24 st %i3, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 4000a678: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] 4000a67c: 81 c7 e0 08 ret 4000a680: 81 e8 00 00 restore =============================================================================== 4000a794 <_Scheduler_simple_Initialize>: #include #include void _Scheduler_simple_Initialize( const Scheduler_Control *scheduler ) { 4000a794: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED return &the_chain->Tail.Node; 4000a798: 84 00 60 04 add %g1, 4, %g2 <== NOT EXECUTED head->previous = NULL; 4000a79c: c0 20 60 04 clr [ %g1 + 4 ] <== NOT EXECUTED head->next = tail; 4000a7a0: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED Scheduler_simple_Context *context = _Scheduler_simple_Get_context( scheduler ); _Chain_Initialize_empty( &context->Ready ); } 4000a7a4: 81 c3 e0 08 retl <== NOT EXECUTED 4000a7a8: c2 20 60 08 st %g1, [ %g1 + 8 ] =============================================================================== 4000a7ac <_Scheduler_simple_Schedule>: void _Scheduler_simple_Schedule( const Scheduler_Control *scheduler, Thread_Control *the_thread ) { 4000a7ac: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 4000a7b0: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED 4000a7b4: f6 00 40 00 ld [ %g1 ], %i3 <== NOT EXECUTED Thread_Control *heir = _Thread_Heir; 4000a7b8: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 <== NOT EXECUTED if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000a7bc: 80 a6 c0 1d cmp %i3, %i5 <== NOT EXECUTED 4000a7c0: 02 80 00 06 be 4000a7d8 <_Scheduler_simple_Schedule+0x2c> <== NOT EXECUTED 4000a7c4: b8 10 00 06 mov %g6, %i4 <== NOT EXECUTED 4000a7c8: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1 <== NOT EXECUTED 4000a7cc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000a7d0: 12 80 00 04 bne 4000a7e0 <_Scheduler_simple_Schedule+0x34> <== NOT EXECUTED 4000a7d4: 01 00 00 00 nop <== NOT EXECUTED _Scheduler_simple_Schedule_body( scheduler, the_thread, false ); } 4000a7d8: 81 c7 e0 08 ret <== NOT EXECUTED 4000a7dc: 81 e8 00 00 restore <== NOT EXECUTED 4000a7e0: 7f ff fa 05 call 40008ff4 <_Timecounter_Sbinuptime> <== NOT EXECUTED 4000a7e4: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 <== NOT EXECUTED 4000a7e8: d0 3f 20 28 std %o0, [ %i4 + 0x28 ] <== NOT EXECUTED *_result = *_end - *_start; 4000a7ec: b2 a2 40 11 subcc %o1, %l1, %i1 <== NOT EXECUTED *_time += *_add; 4000a7f0: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4 <== NOT EXECUTED *_result = *_end - *_start; 4000a7f4: b0 62 00 10 subx %o0, %l0, %i0 <== NOT EXECUTED *_time += *_add; 4000a7f8: 86 83 40 19 addcc %o5, %i1, %g3 <== NOT EXECUTED 4000a7fc: 84 43 00 18 addx %o4, %i0, %g2 <== NOT EXECUTED 4000a800: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 4000a804: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = new_heir; 4000a808: f6 21 a0 24 st %i3, [ %g6 + 0x24 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 4000a80c: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] <== NOT EXECUTED 4000a810: 81 c7 e0 08 ret <== NOT EXECUTED 4000a814: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000a818 <_Scheduler_simple_Unblock>: void _Scheduler_simple_Unblock( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 4000a818: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 4000a81c: c6 06 00 00 ld [ %i0 ], %g3 <== NOT EXECUTED 4000a820: c2 06 60 38 ld [ %i1 + 0x38 ], %g1 <== NOT EXECUTED 4000a824: f8 00 60 1c ld [ %g1 + 0x1c ], %i4 <== NOT EXECUTED 4000a828: c2 00 c0 00 ld [ %g3 ], %g1 <== NOT EXECUTED return &the_chain->Tail.Node; 4000a82c: 86 00 e0 04 add %g3, 4, %g3 <== NOT EXECUTED while ( next != tail && !( *order )( left, next ) ) { 4000a830: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 4000a834: 02 80 00 18 be 4000a894 <_Scheduler_simple_Unblock+0x7c> <== NOT EXECUTED 4000a838: b6 17 20 01 or %i4, 1, %i3 4000a83c: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 4000a840: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4 4000a844: 80 a1 20 00 cmp %g4, 0 4000a848: 12 80 00 12 bne 4000a890 <_Scheduler_simple_Unblock+0x78> <== NEVER TAKEN 4000a84c: ba 10 20 00 clr %i5 4000a850: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 4000a854: 80 a0 80 1b cmp %g2, %i3 4000a858: 3a 80 00 0f bcc,a 4000a894 <_Scheduler_simple_Unblock+0x7c> 4000a85c: 86 10 00 01 mov %g1, %g3 4000a860: c2 00 40 00 ld [ %g1 ], %g1 4000a864: 80 a0 c0 01 cmp %g3, %g1 4000a868: 22 80 00 0c be,a 4000a898 <_Scheduler_simple_Unblock+0x80> 4000a86c: c2 00 e0 04 ld [ %g3 + 4 ], %g1 4000a870: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 4000a874: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4 4000a878: 80 a7 40 04 cmp %i5, %g4 4000a87c: 12 80 00 05 bne 4000a890 <_Scheduler_simple_Unblock+0x78> <== NEVER TAKEN 4000a880: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 4000a884: 80 a6 c0 02 cmp %i3, %g2 4000a888: 38 bf ff f7 bgu,a 4000a864 <_Scheduler_simple_Unblock+0x4c> 4000a88c: c2 00 40 00 ld [ %g1 ], %g1 4000a890: 86 10 00 01 mov %g1, %g3 4000a894: c2 00 e0 04 ld [ %g3 + 4 ], %g1 the_node->previous = after_node; 4000a898: c2 26 60 04 st %g1, [ %i1 + 4 ] before_node = after_node->next; 4000a89c: c4 00 40 00 ld [ %g1 ], %g2 after_node->next = the_node; 4000a8a0: f2 20 40 00 st %i1, [ %g1 ] the_node->next = before_node; 4000a8a4: c4 26 40 00 st %g2, [ %i1 ] * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( priority < _Thread_Get_priority( _Thread_Heir ) ) { 4000a8a8: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 4000a8ac: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 before_node->previous = the_node; 4000a8b0: f2 20 a0 04 st %i1, [ %g2 + 4 ] 4000a8b4: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 4000a8b8: 80 a0 a0 00 cmp %g2, 0 4000a8bc: 18 80 00 09 bgu 4000a8e0 <_Scheduler_simple_Unblock+0xc8> <== NEVER TAKEN 4000a8c0: b6 10 00 06 mov %g6, %i3 4000a8c4: 22 80 00 04 be,a 4000a8d4 <_Scheduler_simple_Unblock+0xbc> <== ALWAYS TAKEN 4000a8c8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 _Scheduler_Update_heir( the_thread, priority == PRIORITY_PSEUDO_ISR ); } } 4000a8cc: 81 c7 e0 08 ret <== NOT EXECUTED 4000a8d0: 81 e8 00 00 restore <== NOT EXECUTED if ( priority < _Thread_Get_priority( _Thread_Heir ) ) { 4000a8d4: 80 a0 40 1c cmp %g1, %i4 4000a8d8: 08 80 00 17 bleu 4000a934 <_Scheduler_simple_Unblock+0x11c> 4000a8dc: 01 00 00 00 nop if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000a8e0: 80 a7 40 19 cmp %i5, %i1 4000a8e4: 02 bf ff fa be 4000a8cc <_Scheduler_simple_Unblock+0xb4> <== NEVER TAKEN 4000a8e8: 80 a7 20 00 cmp %i4, 0 4000a8ec: 02 80 00 06 be 4000a904 <_Scheduler_simple_Unblock+0xec> 4000a8f0: 01 00 00 00 nop 4000a8f4: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1 4000a8f8: 80 a0 60 00 cmp %g1, 0 4000a8fc: 02 80 00 0e be 4000a934 <_Scheduler_simple_Unblock+0x11c> 4000a900: 01 00 00 00 nop 4000a904: 7f ff f9 bc call 40008ff4 <_Timecounter_Sbinuptime> 4000a908: e0 1e e0 28 ldd [ %i3 + 0x28 ], %l0 4000a90c: d0 3e e0 28 std %o0, [ %i3 + 0x28 ] *_result = *_end - *_start; 4000a910: b6 a2 40 11 subcc %o1, %l1, %i3 *_time += *_add; 4000a914: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4 *_result = *_end - *_start; 4000a918: b4 62 00 10 subx %o0, %l0, %i2 *_time += *_add; 4000a91c: 86 83 40 1b addcc %o5, %i3, %g3 4000a920: 84 43 00 1a addx %o4, %i2, %g2 4000a924: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] _Thread_Dispatch_necessary = true; 4000a928: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 4000a92c: f2 21 a0 24 st %i1, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 4000a930: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] } 4000a934: 81 c7 e0 08 ret 4000a938: 81 e8 00 00 restore =============================================================================== 4000a684 <_Scheduler_simple_Update_priority>: void _Scheduler_simple_Update_priority( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 4000a684: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Scheduler_simple_Context *context; unsigned int new_priority; if ( !_Thread_Is_ready( the_thread ) ) { 4000a688: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED 4000a68c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000a690: 22 80 00 04 be,a 4000a6a0 <_Scheduler_simple_Update_priority+0x1c> <== NOT EXECUTED 4000a694: c2 06 60 04 ld [ %i1 + 4 ], %g1 new_priority = (unsigned int ) _Scheduler_Node_get_priority( node ); _Scheduler_simple_Extract( scheduler, the_thread, node ); _Scheduler_simple_Insert( &context->Ready, the_thread, new_priority ); _Scheduler_simple_Schedule_body( scheduler, the_thread, false ); } 4000a698: 81 c7 e0 08 ret 4000a69c: 81 e8 00 00 restore next = the_node->next; 4000a6a0: c4 06 40 00 ld [ %i1 ], %g2 4000a6a4: f8 06 00 00 ld [ %i0 ], %i4 4000a6a8: f6 06 a0 34 ld [ %i2 + 0x34 ], %i3 next->previous = previous; 4000a6ac: c2 20 a0 04 st %g1, [ %g2 + 4 ] return &the_chain->Tail.Node; 4000a6b0: 88 07 20 04 add %i4, 4, %g4 previous->next = next; 4000a6b4: c4 20 40 00 st %g2, [ %g1 ] return _Chain_Immutable_head( the_chain )->next; 4000a6b8: c2 07 00 00 ld [ %i4 ], %g1 ) { const Chain_Node *tail = _Chain_Immutable_tail( the_chain ); Chain_Node *next = _Chain_First( the_chain ); while ( next != tail && !( *order )( left, next ) ) { 4000a6bc: 80 a1 00 01 cmp %g4, %g1 4000a6c0: 22 80 00 19 be,a 4000a724 <_Scheduler_simple_Update_priority+0xa0> <== NEVER TAKEN 4000a6c4: c2 01 20 04 ld [ %g4 + 4 ], %g1 <== NOT EXECUTED 4000a6c8: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 4000a6cc: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 4000a6d0: 80 a0 e0 00 cmp %g3, 0 4000a6d4: 12 80 00 12 bne 4000a71c <_Scheduler_simple_Update_priority+0x98> <== NEVER TAKEN 4000a6d8: ba 10 20 00 clr %i5 4000a6dc: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 4000a6e0: 80 a0 80 1b cmp %g2, %i3 4000a6e4: 3a 80 00 0f bcc,a 4000a720 <_Scheduler_simple_Update_priority+0x9c> 4000a6e8: 88 10 00 01 mov %g1, %g4 4000a6ec: c2 00 40 00 ld [ %g1 ], %g1 4000a6f0: 80 a1 00 01 cmp %g4, %g1 4000a6f4: 22 80 00 0c be,a 4000a724 <_Scheduler_simple_Update_priority+0xa0> 4000a6f8: c2 01 20 04 ld [ %g4 + 4 ], %g1 4000a6fc: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 4000a700: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 4000a704: 80 a7 40 03 cmp %i5, %g3 4000a708: 12 80 00 05 bne 4000a71c <_Scheduler_simple_Update_priority+0x98> <== NEVER TAKEN 4000a70c: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 4000a710: 80 a6 c0 02 cmp %i3, %g2 4000a714: 38 bf ff f7 bgu,a 4000a6f0 <_Scheduler_simple_Update_priority+0x6c> 4000a718: c2 00 40 00 ld [ %g1 ], %g1 4000a71c: 88 10 00 01 mov %g1, %g4 4000a720: c2 01 20 04 ld [ %g4 + 4 ], %g1 the_node->previous = after_node; 4000a724: c2 26 60 04 st %g1, [ %i1 + 4 ] before_node = after_node->next; 4000a728: c4 00 40 00 ld [ %g1 ], %g2 after_node->next = the_node; 4000a72c: f2 20 40 00 st %i1, [ %g1 ] the_node->next = before_node; 4000a730: c4 26 40 00 st %g2, [ %i1 ] before_node->previous = the_node; 4000a734: f2 20 a0 04 st %i1, [ %g2 + 4 ] return _Chain_Immutable_head( the_chain )->next; 4000a738: f8 07 00 00 ld [ %i4 ], %i4 Thread_Control *heir = _Thread_Heir; 4000a73c: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000a740: 80 a7 00 1d cmp %i4, %i5 4000a744: 02 bf ff d5 be 4000a698 <_Scheduler_simple_Update_priority+0x14> 4000a748: b6 10 00 06 mov %g6, %i3 4000a74c: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1 4000a750: 80 a0 60 00 cmp %g1, 0 4000a754: 02 80 00 0e be 4000a78c <_Scheduler_simple_Update_priority+0x108> <== ALWAYS TAKEN 4000a758: 01 00 00 00 nop 4000a75c: 7f ff fa 26 call 40008ff4 <_Timecounter_Sbinuptime> <== NOT EXECUTED 4000a760: f0 19 a0 28 ldd [ %g6 + 0x28 ], %i0 <== NOT EXECUTED 4000a764: d0 3e e0 28 std %o0, [ %i3 + 0x28 ] <== NOT EXECUTED *_result = *_end - *_start; 4000a768: b6 a2 40 19 subcc %o1, %i1, %i3 <== NOT EXECUTED 4000a76c: b4 62 00 18 subx %o0, %i0, %i2 <== NOT EXECUTED *_time += *_add; 4000a770: f0 1f 60 98 ldd [ %i5 + 0x98 ], %i0 <== NOT EXECUTED 4000a774: 86 86 40 1b addcc %i1, %i3, %g3 <== NOT EXECUTED 4000a778: 84 46 00 1a addx %i0, %i2, %g2 <== NOT EXECUTED 4000a77c: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 4000a780: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = new_heir; 4000a784: f8 21 a0 24 st %i4, [ %g6 + 0x24 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 4000a788: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] <== NOT EXECUTED 4000a78c: 81 c7 e0 08 ret 4000a790: 81 e8 00 00 restore =============================================================================== 4000a93c <_Scheduler_simple_Yield>: void _Scheduler_simple_Yield( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 4000a93c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED next = the_node->next; 4000a940: c4 06 40 00 ld [ %i1 ], %g2 <== NOT EXECUTED previous = the_node->previous; 4000a944: c2 06 60 04 ld [ %i1 + 4 ], %g1 <== NOT EXECUTED 4000a948: f8 06 00 00 ld [ %i0 ], %i4 <== NOT EXECUTED next->previous = previous; 4000a94c: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED return &the_chain->Tail.Node; 4000a950: 88 07 20 04 add %i4, 4, %g4 <== NOT EXECUTED previous->next = next; 4000a954: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED context = _Scheduler_simple_Get_context( scheduler ); (void) node; _Chain_Extract_unprotected( &the_thread->Object.Node ); insert_priority = (unsigned int) _Thread_Get_priority( the_thread ); 4000a958: c2 06 60 38 ld [ %i1 + 0x38 ], %g1 <== NOT EXECUTED 4000a95c: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 4000a960: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED while ( next != tail && !( *order )( left, next ) ) { 4000a964: 80 a1 00 01 cmp %g4, %g1 <== NOT EXECUTED 4000a968: 02 80 00 18 be 4000a9c8 <_Scheduler_simple_Yield+0x8c> <== NOT EXECUTED 4000a96c: b6 10 a0 01 or %g2, 1, %i3 4000a970: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 4000a974: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 4000a978: 80 a0 e0 00 cmp %g3, 0 4000a97c: 12 80 00 12 bne 4000a9c4 <_Scheduler_simple_Yield+0x88> <== NEVER TAKEN 4000a980: ba 10 20 00 clr %i5 4000a984: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 4000a988: 80 a0 80 1b cmp %g2, %i3 4000a98c: 3a 80 00 0f bcc,a 4000a9c8 <_Scheduler_simple_Yield+0x8c> 4000a990: 88 10 00 01 mov %g1, %g4 4000a994: c2 00 40 00 ld [ %g1 ], %g1 4000a998: 80 a1 00 01 cmp %g4, %g1 4000a99c: 22 80 00 0c be,a 4000a9cc <_Scheduler_simple_Yield+0x90> <== NEVER TAKEN 4000a9a0: c2 01 20 04 ld [ %g4 + 4 ], %g1 <== NOT EXECUTED 4000a9a4: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 4000a9a8: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 4000a9ac: 80 a7 40 03 cmp %i5, %g3 4000a9b0: 12 80 00 05 bne 4000a9c4 <_Scheduler_simple_Yield+0x88> <== NEVER TAKEN 4000a9b4: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 4000a9b8: 80 a6 c0 02 cmp %i3, %g2 4000a9bc: 38 bf ff f7 bgu,a 4000a998 <_Scheduler_simple_Yield+0x5c> 4000a9c0: c2 00 40 00 ld [ %g1 ], %g1 4000a9c4: 88 10 00 01 mov %g1, %g4 4000a9c8: c2 01 20 04 ld [ %g4 + 4 ], %g1 the_node->previous = after_node; 4000a9cc: c2 26 60 04 st %g1, [ %i1 + 4 ] before_node = after_node->next; 4000a9d0: c4 00 40 00 ld [ %g1 ], %g2 after_node->next = the_node; 4000a9d4: f2 20 40 00 st %i1, [ %g1 ] the_node->next = before_node; 4000a9d8: c4 26 40 00 st %g2, [ %i1 ] before_node->previous = the_node; 4000a9dc: f2 20 a0 04 st %i1, [ %g2 + 4 ] return _Chain_Immutable_head( the_chain )->next; 4000a9e0: f8 07 00 00 ld [ %i4 ], %i4 Thread_Control *heir = _Thread_Heir; 4000a9e4: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000a9e8: 80 a7 00 1d cmp %i4, %i5 4000a9ec: 02 80 00 06 be 4000aa04 <_Scheduler_simple_Yield+0xc8> 4000a9f0: b6 10 00 06 mov %g6, %i3 4000a9f4: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1 4000a9f8: 80 a0 60 00 cmp %g1, 0 4000a9fc: 12 80 00 04 bne 4000aa0c <_Scheduler_simple_Yield+0xd0> <== NEVER TAKEN 4000aa00: 01 00 00 00 nop insert_priority = SCHEDULER_PRIORITY_APPEND( insert_priority ); _Scheduler_simple_Insert( &context->Ready, the_thread, insert_priority ); _Scheduler_simple_Schedule_body( scheduler, the_thread, false ); } 4000aa04: 81 c7 e0 08 ret 4000aa08: 81 e8 00 00 restore 4000aa0c: 7f ff f9 7a call 40008ff4 <_Timecounter_Sbinuptime> <== NOT EXECUTED 4000aa10: f0 19 a0 28 ldd [ %g6 + 0x28 ], %i0 <== NOT EXECUTED 4000aa14: d0 3e e0 28 std %o0, [ %i3 + 0x28 ] <== NOT EXECUTED *_result = *_end - *_start; 4000aa18: b6 a2 40 19 subcc %o1, %i1, %i3 <== NOT EXECUTED 4000aa1c: b4 62 00 18 subx %o0, %i0, %i2 <== NOT EXECUTED *_time += *_add; 4000aa20: f0 1f 60 98 ldd [ %i5 + 0x98 ], %i0 <== NOT EXECUTED 4000aa24: 86 86 40 1b addcc %i1, %i3, %g3 <== NOT EXECUTED 4000aa28: 84 46 00 1a addx %i0, %i2, %g2 <== NOT EXECUTED 4000aa2c: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 4000aa30: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = new_heir; 4000aa34: f8 21 a0 24 st %i4, [ %g6 + 0x24 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 4000aa38: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] <== NOT EXECUTED 4000aa3c: 81 c7 e0 08 ret <== NOT EXECUTED 4000aa40: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4001da94 <_Semaphore_Post>: _Sem_Queue_release( sem, level, &queue_context ); return eno; } void _Semaphore_Post( struct _Semaphore_Control *_sem ) { 4001da94: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4001da98: 91 d0 20 09 ta 9 <== NOT EXECUTED sem = _Sem_Get( _sem ); _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_ISR_disable( &queue_context, level ); _Sem_Queue_acquire_critical( sem, &queue_context ); heads = sem->Queue.Queue.heads; 4001da9c: d0 06 20 08 ld [ %i0 + 8 ], %o0 if ( __predict_true( heads == NULL ) ) { 4001daa0: 80 a2 20 00 cmp %o0, 0 4001daa4: 32 80 00 09 bne,a 4001dac8 <_Semaphore_Post+0x34> 4001daa8: c2 27 bf dc st %g1, [ %fp + -36 ] ++sem->count; 4001daac: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED 4001dab0: 84 00 a0 01 inc %g2 <== NOT EXECUTED 4001dab4: c4 26 20 14 st %g2, [ %i0 + 0x14 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4001dab8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4001dabc: 01 00 00 00 nop 4001dac0: 81 c7 e0 08 ret 4001dac4: 81 e8 00 00 restore const Thread_queue_Operations *operations; Thread_Control *first; _Thread_queue_Context_set_ISR_level( &queue_context, level ); operations = SEMAPHORE_TQ_OPERATIONS; first = ( *operations->first )( heads ); 4001dac8: 3b 10 01 5c sethi %hi(0x40057000), %i5 4001dacc: ba 17 60 2c or %i5, 0x2c, %i5 ! 4005702c <_Thread_queue_Operations_priority> 4001dad0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 4001dad4: 9f c0 40 00 call %g1 4001dad8: 01 00 00 00 nop _Thread_queue_Extract_critical( 4001dadc: 96 07 bf dc add %fp, -36, %o3 4001dae0: 94 10 00 08 mov %o0, %o2 4001dae4: 92 10 00 1d mov %i5, %o1 4001dae8: 40 00 03 a5 call 4001e97c <_Thread_queue_Extract_critical> 4001daec: 90 06 20 08 add %i0, 8, %o0 operations, first, &queue_context ); } } 4001daf0: 81 c7 e0 08 ret 4001daf4: 81 e8 00 00 restore =============================================================================== 40012ed8 <_Semaphore_Post_binary>: ); } } void _Semaphore_Post_binary( struct _Semaphore_Control *_sem ) { 40012ed8: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40012edc: 91 d0 20 09 ta 9 <== NOT EXECUTED sem = _Sem_Get( _sem ); _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_ISR_disable( &queue_context, level ); _Sem_Queue_acquire_critical( sem, &queue_context ); heads = sem->Queue.Queue.heads; 40012ee0: d0 06 20 08 ld [ %i0 + 8 ], %o0 if ( __predict_true( heads == NULL ) ) { 40012ee4: 80 a2 20 00 cmp %o0, 0 40012ee8: 12 80 00 07 bne 40012f04 <_Semaphore_Post_binary+0x2c> 40012eec: 84 10 20 01 mov 1, %g2 sem->count = 1; 40012ef0: c4 26 20 14 st %g2, [ %i0 + 0x14 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40012ef4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40012ef8: 01 00 00 00 nop 40012efc: 81 c7 e0 08 ret 40012f00: 81 e8 00 00 restore 40012f04: c2 27 bf dc st %g1, [ %fp + -36 ] const Thread_queue_Operations *operations; Thread_Control *first; _Thread_queue_Context_set_ISR_level( &queue_context, level ); operations = SEMAPHORE_TQ_OPERATIONS; first = ( *operations->first )( heads ); 40012f08: 3b 10 00 4e sethi %hi(0x40013800), %i5 40012f0c: ba 17 62 04 or %i5, 0x204, %i5 ! 40013a04 <_Thread_queue_Operations_priority> 40012f10: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 40012f14: 9f c0 40 00 call %g1 40012f18: 01 00 00 00 nop _Thread_queue_Extract_critical( 40012f1c: 96 07 bf dc add %fp, -36, %o3 40012f20: 94 10 00 08 mov %o0, %o2 40012f24: 92 10 00 1d mov %i5, %o1 40012f28: 7f ff db bb call 40009e14 <_Thread_queue_Extract_critical> 40012f2c: 90 06 20 08 add %i0, 8, %o0 operations, first, &queue_context ); } } 40012f30: 81 c7 e0 08 ret 40012f34: 81 e8 00 00 restore =============================================================================== 40012e94 <_Semaphore_Try_wait>: int _Semaphore_Try_wait( struct _Semaphore_Control *_sem ) { 40012e94: 86 10 00 08 mov %o0, %g3 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40012e98: 91 d0 20 09 ta 9 <== NOT EXECUTED sem = _Sem_Get( _sem ); _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_ISR_disable( &queue_context, level ); _Sem_Queue_acquire_critical( sem, &queue_context ); count = sem->count; 40012e9c: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 if ( __predict_true( count > 0 ) ) { 40012ea0: 80 a0 a0 00 cmp %g2, 0 40012ea4: 02 80 00 08 be 40012ec4 <_Semaphore_Try_wait+0x30> 40012ea8: 84 00 bf ff add %g2, -1, %g2 sem->count = count - 1; eno = 0; 40012eac: 90 10 20 00 clr %o0 <== NOT EXECUTED sem->count = count - 1; 40012eb0: c4 20 e0 14 st %g2, [ %g3 + 0x14 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40012eb4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40012eb8: 01 00 00 00 nop eno = EAGAIN; } _Sem_Queue_release( sem, level, &queue_context ); return eno; } 40012ebc: 81 c3 e0 08 retl 40012ec0: 01 00 00 00 nop eno = EAGAIN; 40012ec4: 90 10 20 0b mov 0xb, %o0 ! b <_TLS_Alignment+0xa> <== NOT EXECUTED 40012ec8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40012ecc: 01 00 00 00 nop } 40012ed0: 81 c3 e0 08 retl 40012ed4: 01 00 00 00 nop =============================================================================== 40012db4 <_Semaphore_Wait>: sizeof( Sem_Control ) == sizeof( struct _Semaphore_Control ), SEMAPHORE_CONTROL_SIZE ); void _Semaphore_Wait( struct _Semaphore_Control *_sem ) { 40012db4: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40012db8: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 40012dbc: 86 10 00 01 mov %g1, %g3 sem = _Sem_Get( _sem ); _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_ISR_disable( &queue_context, level ); executing = _Sem_Queue_acquire_critical( sem, &queue_context ); count = sem->count; 40012dc0: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 if ( __predict_true( count > 0 ) ) { 40012dc4: 80 a0 a0 00 cmp %g2, 0 40012dc8: 02 80 00 07 be 40012de4 <_Semaphore_Wait+0x30> 40012dcc: 84 00 bf ff add %g2, -1, %g2 sem->count = count - 1; 40012dd0: c4 26 20 14 st %g2, [ %i0 + 0x14 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40012dd4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40012dd8: 01 00 00 00 nop 40012ddc: 81 c7 e0 08 ret 40012de0: 81 e8 00 00 restore queue_context->thread_state = thread_state; 40012de4: 82 10 20 02 mov 2, %g1 Thread_queue_Context *queue_context ) { Thread_Control *executing; executing = _Thread_Executing; 40012de8: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2 40012dec: c2 27 bf e0 st %g1, [ %fp + -32 ] queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra; 40012df0: 03 10 00 27 sethi %hi(0x40009c00), %g1 40012df4: 82 10 60 24 or %g1, 0x24, %g1 ! 40009c24 <_Thread_queue_Enqueue_do_nothing_extra> &queue_context, STATES_WAITING_FOR_SEMAPHORE ); _Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context ); _Thread_queue_Context_set_ISR_level( &queue_context, level ); _Thread_queue_Enqueue( 40012df8: 96 07 bf dc add %fp, -36, %o3 40012dfc: c2 27 bf e4 st %g1, [ %fp + -28 ] 40012e00: 13 10 00 4e sethi %hi(0x40013800), %o1 40012e04: c6 27 bf dc st %g3, [ %fp + -36 ] 40012e08: 92 12 62 04 or %o1, 0x204, %o1 40012e0c: 7f ff db 8c call 40009c3c <_Thread_queue_Enqueue> 40012e10: 90 06 20 08 add %i0, 8, %o0 SEMAPHORE_TQ_OPERATIONS, executing, &queue_context ); } } 40012e14: 81 c7 e0 08 ret 40012e18: 81 e8 00 00 restore =============================================================================== 40012e1c <_Semaphore_Wait_timed_ticks>: int _Semaphore_Wait_timed_ticks( struct _Semaphore_Control *_sem, uint32_t ticks ) { 40012e1c: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40012e20: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 40012e24: 86 10 00 01 mov %g1, %g3 sem = _Sem_Get( _sem ); _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_ISR_disable( &queue_context, level ); executing = _Sem_Queue_acquire_critical( sem, &queue_context ); count = sem->count; 40012e28: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 if ( __predict_true( count > 0 ) ) { 40012e2c: 80 a0 a0 00 cmp %g2, 0 40012e30: 02 80 00 07 be 40012e4c <_Semaphore_Wait_timed_ticks+0x30> 40012e34: 84 00 bf ff add %g2, -1, %g2 sem->count = count - 1; 40012e38: c4 26 20 14 st %g2, [ %i0 + 0x14 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40012e3c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40012e40: 01 00 00 00 nop _Sem_Queue_release( sem, level, &queue_context ); return 0; 40012e44: 81 c7 e0 08 ret 40012e48: 91 e8 20 00 restore %g0, 0, %o0 queue_context->thread_state = thread_state; 40012e4c: 82 10 20 02 mov 2, %g1 40012e50: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5 40012e54: c2 27 bf e0 st %g1, [ %fp + -32 ] queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks; 40012e58: 03 10 00 2a sethi %hi(0x4000a800), %g1 40012e5c: 82 10 60 74 or %g1, 0x74, %g1 ! 4000a874 <_Thread_queue_Add_timeout_ticks> &queue_context, STATES_WAITING_FOR_SEMAPHORE ); _Thread_queue_Context_set_enqueue_timeout_ticks( &queue_context, ticks ); _Thread_queue_Context_set_ISR_level( &queue_context, level ); _Thread_queue_Enqueue( 40012e60: 90 06 20 08 add %i0, 8, %o0 queue_context->Timeout.ticks = ticks; 40012e64: f2 27 bf e8 st %i1, [ %fp + -24 ] 40012e68: 96 07 bf dc add %fp, -36, %o3 40012e6c: c6 27 bf dc st %g3, [ %fp + -36 ] 40012e70: 94 10 00 1d mov %i5, %o2 queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks; 40012e74: c2 27 bf e4 st %g1, [ %fp + -28 ] 40012e78: 13 10 00 4e sethi %hi(0x40013800), %o1 40012e7c: 7f ff db 70 call 40009c3c <_Thread_queue_Enqueue> 40012e80: 92 12 62 04 or %o1, 0x204, %o1 ! 40013a04 <_Thread_queue_Operations_priority> &sem->Queue.Queue, SEMAPHORE_TQ_OPERATIONS, executing, &queue_context ); return STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) ); 40012e84: f0 07 60 4c ld [ %i5 + 0x4c ], %i0 40012e88: b1 3e 20 08 sra %i0, 8, %i0 } } 40012e8c: 81 c7 e0 08 ret 40012e90: 81 e8 00 00 restore =============================================================================== 40006a7c <_TOD_Adjust>: #include void _TOD_Adjust( const struct timespec *delta ) { 40006a7c: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED * enhancement would be to adjust the time in smaller increments * at each clock tick. Until then, there is no outstanding * adjustment. */ _TOD_Lock(); 40006a80: 40 00 00 10 call 40006ac0 <_TOD_Lock> <== NOT EXECUTED 40006a84: 01 00 00 00 nop <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40006a88: 91 d0 20 09 ta 9 <== NOT EXECUTED _Timecounter_Acquire( lock_context ); 40006a8c: c2 27 bf ec st %g1, [ %fp + -20 ] _Timecounter_Nanotime( tod ); 40006a90: 40 00 06 b0 call 40008550 <_Timecounter_Nanotime> 40006a94: 90 07 bf f0 add %fp, -16, %o0 _TOD_Acquire( &lock_context ); _TOD_Get( &tod ); _Timespec_Add_to( &tod, delta ); 40006a98: 92 10 00 18 mov %i0, %o1 40006a9c: 40 00 14 16 call 4000baf4 <_Timespec_Add_to> 40006aa0: 90 07 bf f0 add %fp, -16, %o0 _TOD_Set( &tod, &lock_context ); 40006aa4: 92 07 bf ec add %fp, -20, %o1 40006aa8: 40 00 00 10 call 40006ae8 <_TOD_Set> 40006aac: 90 07 bf f0 add %fp, -16, %o0 _TOD_Unlock(); 40006ab0: 40 00 00 09 call 40006ad4 <_TOD_Unlock> 40006ab4: 01 00 00 00 nop } 40006ab8: 81 c7 e0 08 ret 40006abc: 81 e8 00 00 restore =============================================================================== 4000816c <_TOD_Lock>: static API_Mutex_Control _TOD_Mutex = API_MUTEX_INITIALIZER( "_TOD" ); void _TOD_Lock( void ) { _API_Mutex_Lock( &_TOD_Mutex ); 4000816c: 11 10 00 4f sethi %hi(0x40013c00), %o0 <== NOT EXECUTED 40008170: 90 12 23 04 or %o0, 0x304, %o0 ! 40013f04 <_TOD_Mutex> <== NOT EXECUTED 40008174: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 40008178: 7f ff ff d1 call 400080bc <_API_Mutex_Lock> <== NOT EXECUTED 4000817c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 40008194 <_TOD_Set>: void _TOD_Set( const struct timespec *tod, ISR_lock_Context *lock_context ) { 40008194: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED _bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL; 40008198: c4 06 20 08 ld [ %i0 + 8 ], %g2 <== NOT EXECUTED 4000819c: 89 28 a0 02 sll %g2, 2, %g4 <== NOT EXECUTED _bt->sec = _ts->tv_sec; 400081a0: f8 1e 00 00 ldd [ %i0 ], %i4 _bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL; 400081a4: 83 38 a0 1f sra %g2, 0x1f, %g1 400081a8: 07 12 e0 be sethi %hi(0x4b82f800), %g3 400081ac: 86 10 e2 09 or %g3, 0x209, %g3 ! 4b82fa09 400081b0: 82 58 40 03 smul %g1, %g3, %g1 400081b4: 86 50 80 03 umul %g2, %g3, %g3 400081b8: 85 40 00 00 rd %y, %g2 400081bc: 82 00 40 04 add %g1, %g4, %g1 400081c0: 84 00 40 02 add %g1, %g2, %g2 _bt->sec = _ts->tv_sec; 400081c4: f8 3f bf f0 std %i4, [ %fp + -16 ] uint32_t cpu_index; _Assert( _TOD_Is_owner() ); timespec2bintime( tod, &tod_as_bintime ); _Timecounter_Set_clock( &tod_as_bintime, lock_context ); 400081c8: 92 10 00 19 mov %i1, %o1 _bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL; 400081cc: c4 3f bf f8 std %g2, [ %fp + -8 ] 400081d0: 40 00 06 cc call 40009d00 <_Timecounter_Set_clock> 400081d4: 90 07 bf f0 add %fp, -16, %o0 _Assert( _Watchdog_Is_valid_timespec( ts ) ); _Assert( ts->tv_sec >= 0 ); _Assert( !_Watchdog_Is_far_future_timespec( ts ) ); ticks = (uint64_t) ts->tv_sec; 400081d8: c6 06 00 00 ld [ %i0 ], %g3 <== NOT EXECUTED 400081dc: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS; ticks |= (uint32_t) ts->tv_nsec; 400081e0: d6 06 20 08 ld [ %i0 + 8 ], %o3 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400081e4: 91 d0 20 09 ta 9 <== NOT EXECUTED Watchdog_Control *first; cpu = _Per_CPU_Get_by_index( cpu_index ); header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_REALTIME ]; _ISR_lock_ISR_disable_and_acquire( &cpu->Watchdog.Lock, &lock_context ); 400081e8: c2 27 bf ec st %g1, [ %fp + -20 ] 400081ec: 11 10 00 57 sethi %hi(0x40015c00), %o0 400081f0: 90 12 22 80 or %o0, 0x280, %o0 ! 40015e80 <_Per_CPU_Information> 400081f4: d2 02 20 44 ld [ %o0 + 0x44 ], %o1 first = _Watchdog_Header_first( header ); if ( first != NULL ) { 400081f8: 80 a2 60 00 cmp %o1, 0 400081fc: 02 80 00 09 be 40008220 <_TOD_Set+0x8c> 40008200: 95 30 a0 02 srl %g2, 2, %o2 ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS; 40008204: 87 28 e0 1e sll %g3, 0x1e, %g3 40008208: 85 28 a0 1e sll %g2, 0x1e, %g2 _Watchdog_Tickle( 4000820c: 98 07 bf ec add %fp, -20, %o4 40008210: 94 12 80 03 or %o2, %g3, %o2 40008214: 96 12 c0 02 or %o3, %g2, %o3 40008218: 40 00 15 9a call 4000d880 <_Watchdog_Do_tickle> 4000821c: 90 02 20 40 add %o0, 0x40, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40008220: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40008224: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40008228: 01 00 00 00 nop } _ISR_lock_Release_and_ISR_enable( &cpu->Watchdog.Lock, &lock_context ); } _TOD.is_set = true; 4000822c: 03 10 00 56 sethi %hi(0x40015800), %g1 40008230: 84 10 20 01 mov 1, %g2 40008234: c4 28 62 55 stb %g2, [ %g1 + 0x255 ] } 40008238: 81 c7 e0 08 ret 4000823c: 81 e8 00 00 restore =============================================================================== 40008180 <_TOD_Unlock>: } void _TOD_Unlock( void ) { _API_Mutex_Unlock( &_TOD_Mutex ); 40008180: 11 10 00 4f sethi %hi(0x40013c00), %o0 <== NOT EXECUTED 40008184: 90 12 23 04 or %o0, 0x304, %o0 ! 40013f04 <_TOD_Mutex> <== NOT EXECUTED 40008188: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4000818c: 7f ff ff d8 call 400080ec <_API_Mutex_Unlock> <== NOT EXECUTED 40008190: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 40007858 <_Terminate>: void _Terminate( Internal_errors_Source the_source, Internal_errors_t the_error ) { 40007858: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Internal_errors_t error ) { User_extensions_Fatal_context ctx = { source, error }; _User_extensions_Iterate( 4000785c: 94 10 20 00 clr %o2 40007860: 90 07 bf f8 add %fp, -8, %o0 User_extensions_Fatal_context ctx = { source, error }; 40007864: f0 27 bf f8 st %i0, [ %fp + -8 ] _User_extensions_Iterate( 40007868: 13 10 00 2f sethi %hi(0x4000bc00), %o1 User_extensions_Fatal_context ctx = { source, error }; 4000786c: f2 27 bf fc st %i1, [ %fp + -4 ] _User_extensions_Iterate( 40007870: 40 00 11 58 call 4000bdd0 <_User_extensions_Iterate> 40007874: 92 12 61 80 or %o1, 0x180, %o1 _User_extensions_Fatal( the_source, the_error ); _Internal_errors_What_happened.the_source = the_source; 40007878: 03 10 00 7d sethi %hi(0x4001f400), %g1 4000787c: 84 10 61 30 or %g1, 0x130, %g2 ! 4001f530 <_Internal_errors_What_happened> 40007880: f0 20 61 30 st %i0, [ %g1 + 0x130 ] 40007884: 03 10 00 7d sethi %hi(0x4001f400), %g1 _Internal_errors_What_happened.the_error = the_error; 40007888: f2 20 a0 04 st %i1, [ %g2 + 4 ] 4000788c: 84 10 20 03 mov 3, %g2 _System_state_Set( SYSTEM_STATE_TERMINATED ); _SMP_Request_shutdown(); _CPU_Fatal_halt( the_source, the_error ); 40007890: 92 10 00 19 mov %i1, %o1 40007894: 90 10 00 18 mov %i0, %o0 40007898: 40 00 42 96 call 400182f0 <_CPU_Fatal_halt> 4000789c: c4 20 61 38 st %g2, [ %g1 + 0x138 ] 400078a0: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 4000e984 <_Thread_Cancel>: void _Thread_Cancel( Thread_Control *the_thread, Thread_Control *executing, void *exit_value ) { 4000e984: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000e988: 91 d0 20 09 ta 9 <== NOT EXECUTED previous = the_thread->Life.state; 4000e98c: c4 06 21 70 ld [ %i0 + 0x170 ], %g2 state |= set; 4000e990: 86 10 a0 04 or %g2, 4, %g3 the_thread->Life.exit_value = exit_value; 4000e994: f4 26 21 78 st %i2, [ %i0 + 0x178 ] if ( 4000e998: 80 88 a0 09 btst 9, %g2 4000e99c: 02 80 00 36 be 4000ea74 <_Thread_Cancel+0xf0> 4000e9a0: c6 26 21 70 st %g3, [ %i0 + 0x170 ] disable_level = cpu_self->thread_dispatch_disable_level; 4000e9a4: c4 01 a0 18 ld [ %g6 + 0x18 ], %g2 cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000e9a8: 84 00 a0 01 inc %g2 4000e9ac: c4 21 a0 18 st %g2, [ %g6 + 0x18 ] ); cpu_self = _Thread_Dispatch_disable_critical( &lock_context ); priority = _Thread_Get_priority( executing ); if ( _States_Is_dormant( the_thread->current_state ) ) { 4000e9b0: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 4000e9b4: 80 a0 a0 00 cmp %g2, 0 4000e9b8: 06 80 00 1d bl 4000ea2c <_Thread_Cancel+0xa8> <== NEVER TAKEN 4000e9bc: ba 10 00 06 mov %g6, %i5 pending_requests = the_thread->Life.pending_life_change_requests; 4000e9c0: c4 06 21 74 ld [ %i0 + 0x174 ], %g2 4000e9c4: c6 06 60 38 ld [ %i1 + 0x38 ], %g3 4000e9c8: f4 18 e0 18 ldd [ %g3 + 0x18 ], %i2 the_thread->Life.pending_life_change_requests = pending_requests + 1; 4000e9cc: 86 00 a0 01 add %g2, 1, %g3 if ( pending_requests == 0 ) { 4000e9d0: 80 a0 a0 00 cmp %g2, 0 4000e9d4: 02 80 00 44 be 4000eae4 <_Thread_Cancel+0x160> <== ALWAYS TAKEN 4000e9d8: c6 26 21 74 st %g3, [ %i0 + 0x174 ] 4000e9dc: c2 27 bf fc st %g1, [ %fp + -4 ] _Thread_State_release( the_thread, &lock_context ); _Thread_Finalize_life_change( the_thread, priority ); } else { _Thread_Add_life_change_request( the_thread ); _Thread_Clear_state_locked( the_thread, STATES_SUSPENDED ); 4000e9e0: 13 00 00 20 sethi %hi(0x8000), %o1 4000e9e4: 40 00 18 20 call 40014a64 <_Thread_Clear_state_locked> 4000e9e8: 90 10 00 18 mov %i0, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e9ec: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e9f0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e9f4: 01 00 00 00 nop _Thread_State_release( the_thread, &lock_context ); _Thread_Raise_real_priority( the_thread, priority ); 4000e9f8: 92 10 00 1a mov %i2, %o1 4000e9fc: 94 10 00 1b mov %i3, %o2 4000ea00: 7f ff fe da call 4000e568 <_Thread_Raise_real_priority> 4000ea04: 90 10 00 18 mov %i0, %o0 _Thread_Remove_life_change_request( the_thread ); 4000ea08: 7f ff fe c3 call 4000e514 <_Thread_Remove_life_change_request> 4000ea0c: 90 10 00 18 mov %i0, %o0 uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000ea10: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 if ( disable_level == 1 ) { 4000ea14: 80 a0 60 01 cmp %g1, 1 4000ea18: 02 80 00 0d be 4000ea4c <_Thread_Cancel+0xc8> <== NEVER TAKEN 4000ea1c: 82 00 7f ff add %g1, -1, %g1 cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000ea20: c2 27 60 18 st %g1, [ %i5 + 0x18 ] } _Thread_Dispatch_enable( cpu_self ); } 4000ea24: 81 c7 e0 08 ret 4000ea28: 81 e8 00 00 restore 4000ea2c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ea30: 01 00 00 00 nop _Thread_Make_zombie( the_thread ); 4000ea34: 7f ff ff 09 call 4000e658 <_Thread_Make_zombie> 4000ea38: 90 10 00 18 mov %i0, %o0 uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000ea3c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 if ( disable_level == 1 ) { 4000ea40: 80 a0 60 01 cmp %g1, 1 4000ea44: 12 bf ff f7 bne 4000ea20 <_Thread_Cancel+0x9c> <== ALWAYS TAKEN 4000ea48: 82 00 7f ff add %g1, -1, %g1 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000ea4c: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000ea50: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2 <== NOT EXECUTED 4000ea54: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000ea58: 12 80 00 2f bne 4000eb14 <_Thread_Cancel+0x190> <== NOT EXECUTED 4000ea5c: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = 0; 4000ea60: c0 27 60 18 clr [ %i5 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000ea64: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ea68: 01 00 00 00 nop <== NOT EXECUTED 4000ea6c: 81 c7 e0 08 ret <== NOT EXECUTED 4000ea70: 81 e8 00 00 restore <== NOT EXECUTED 4000ea74: c2 27 bf fc st %g1, [ %fp + -4 ] 4000ea78: 7f ff fe e0 call 4000e5f8 <_Thread_Change_life_locked.part.37> 4000ea7c: 90 10 00 18 mov %i0, %o0 disable_level = cpu_self->thread_dispatch_disable_level; 4000ea80: c4 01 a0 18 ld [ %g6 + 0x18 ], %g2 cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000ea84: 84 00 a0 01 inc %g2 4000ea88: c4 21 a0 18 st %g2, [ %g6 + 0x18 ] return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000ea8c: ba 10 00 06 mov %g6, %i5 4000ea90: c6 06 60 38 ld [ %i1 + 0x38 ], %g3 if ( _States_Is_dormant( the_thread->current_state ) ) { 4000ea94: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 4000ea98: f4 18 e0 18 ldd [ %g3 + 0x18 ], %i2 4000ea9c: 80 a0 a0 00 cmp %g2, 0 4000eaa0: 06 bf ff e3 bl 4000ea2c <_Thread_Cancel+0xa8> 4000eaa4: c2 07 bf fc ld [ %fp + -4 ], %g1 pending_requests = the_thread->Life.pending_life_change_requests; 4000eaa8: c4 06 21 74 ld [ %i0 + 0x174 ], %g2 the_thread->Life.pending_life_change_requests = pending_requests + 1; 4000eaac: 86 00 a0 01 add %g2, 1, %g3 if ( pending_requests == 0 ) { 4000eab0: 80 a0 a0 00 cmp %g2, 0 4000eab4: 02 80 00 12 be 4000eafc <_Thread_Cancel+0x178> <== ALWAYS TAKEN 4000eab8: c6 26 21 74 st %g3, [ %i0 + 0x174 ] 4000eabc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000eac0: 01 00 00 00 nop _Thread_queue_Extract_with_proxy( the_thread ); 4000eac4: 40 00 18 5d call 40014c38 <_Thread_queue_Extract_with_proxy> 4000eac8: 90 10 00 18 mov %i0, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000eacc: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000ead0: c2 27 bf fc st %g1, [ %fp + -4 ] 4000ead4: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 4000ead8: 40 00 02 40 call 4000f3d8 <_Watchdog_Remove> 4000eadc: 92 06 20 68 add %i0, 0x68, %o1 4000eae0: 30 bf ff c3 b,a 4000e9ec <_Thread_Cancel+0x68> 4000eae4: c2 27 bf fc st %g1, [ %fp + -4 ] _Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING ); 4000eae8: 13 00 00 80 sethi %hi(0x20000), %o1 4000eaec: 40 00 00 65 call 4000ec80 <_Thread_Set_state_locked> 4000eaf0: 90 10 00 18 mov %i0, %o0 4000eaf4: 10 bf ff ba b 4000e9dc <_Thread_Cancel+0x58> 4000eaf8: c2 07 bf fc ld [ %fp + -4 ], %g1 4000eafc: c2 27 bf fc st %g1, [ %fp + -4 ] 4000eb00: 13 00 00 80 sethi %hi(0x20000), %o1 4000eb04: 40 00 00 5f call 4000ec80 <_Thread_Set_state_locked> 4000eb08: 90 10 00 18 mov %i0, %o0 4000eb0c: 10 bf ff ec b 4000eabc <_Thread_Cancel+0x138> 4000eb10: c2 07 bf fc ld [ %fp + -4 ], %g1 _Thread_Do_dispatch( cpu_self, level ); 4000eb14: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED 4000eb18: 40 00 17 f5 call 40014aec <_Thread_Do_dispatch> <== NOT EXECUTED 4000eb1c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 4000eb20: 10 bf ff d1 b 4000ea64 <_Thread_Cancel+0xe0> <== NOT EXECUTED 4000eb24: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED =============================================================================== 4000b91c <_Thread_Change_life>: Thread_Life_state _Thread_Change_life( Thread_Life_state clear, Thread_Life_state set, Thread_Life_state ignore ) { 4000b91c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b920: 91 d0 20 09 ta 9 <== NOT EXECUTED executing = _Thread_Executing; 4000b924: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0 previous = the_thread->Life.state; 4000b928: fa 02 21 70 ld [ %o0 + 0x170 ], %i5 state &= ~clear; 4000b92c: 84 2f 40 18 andn %i5, %i0, %g2 state |= set; 4000b930: b2 16 40 02 or %i1, %g2, %i1 the_thread->Life.state = state; 4000b934: f2 22 21 70 st %i1, [ %o0 + 0x170 ] state &= ~ignore; 4000b938: b2 2e 40 1a andn %i1, %i2, %i1 if ( 4000b93c: 80 8e 60 09 btst 9, %i1 4000b940: 12 80 00 07 bne 4000b95c <_Thread_Change_life+0x40> 4000b944: 80 8e 60 06 btst 6, %i1 && _Thread_Is_life_changing( state ) 4000b948: 02 80 00 05 be 4000b95c <_Thread_Change_life+0x40> 4000b94c: 01 00 00 00 nop 4000b950: 7f ff ff 10 call 4000b590 <_Thread_Change_life_locked.part.37> 4000b954: c2 27 bf fc st %g1, [ %fp + -4 ] 4000b958: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 4000b95c: c4 01 a0 18 ld [ %g6 + 0x18 ], %g2 cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000b960: 84 00 a0 01 inc %g2 return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000b964: 90 10 00 06 mov %g6, %o0 cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000b968: c4 21 a0 18 st %g2, [ %g6 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b96c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b970: 01 00 00 00 nop uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000b974: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 if ( disable_level == 1 ) { 4000b978: 80 a0 60 01 cmp %g1, 1 4000b97c: 02 80 00 06 be 4000b994 <_Thread_Change_life+0x78> 4000b980: 82 00 7f ff add %g1, -1, %g1 cpu_self = _Thread_Dispatch_disable_critical( &lock_context ); _Thread_State_release( executing, &lock_context ); _Thread_Dispatch_enable( cpu_self ); return previous; } 4000b984: b0 10 00 1d mov %i5, %i0 cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000b988: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] 4000b98c: 81 c7 e0 08 ret 4000b990: 81 e8 00 00 restore __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b994: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000b998: c4 09 a0 1c ldub [ %g6 + 0x1c ], %g2 4000b99c: 80 a0 a0 00 cmp %g2, 0 4000b9a0: 12 80 00 07 bne 4000b9bc <_Thread_Change_life+0xa0> 4000b9a4: 92 10 00 01 mov %g1, %o1 cpu_self->thread_dispatch_disable_level = 0; 4000b9a8: c0 21 a0 18 clr [ %g6 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b9ac: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b9b0: 01 00 00 00 nop 4000b9b4: 81 c7 e0 08 ret 4000b9b8: 91 e8 00 1d restore %g0, %i5, %o0 _Thread_Do_dispatch( cpu_self, level ); 4000b9bc: 40 00 0b 06 call 4000e5d4 <_Thread_Do_dispatch> 4000b9c0: c2 27 bf fc st %g1, [ %fp + -4 ] 4000b9c4: 10 bf ff fa b 4000b9ac <_Thread_Change_life+0x90> <== NOT EXECUTED 4000b9c8: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED =============================================================================== 4000e57c <_Thread_Clear_state>: States_Control _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 4000e57c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000e580: 91 d0 20 09 ta 9 <== NOT EXECUTED previous_state = the_thread->current_state; 4000e584: fa 06 20 1c ld [ %i0 + 0x1c ], %i5 if ( ( previous_state & state ) != 0 ) { 4000e588: 80 8e 40 1d btst %i1, %i5 4000e58c: 02 80 00 06 be 4000e5a4 <_Thread_Clear_state+0x28> 4000e590: 01 00 00 00 nop RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 4000e594: b2 2f 40 19 andn %i5, %i1, %i1 if ( _States_Is_ready( next_state ) ) { 4000e598: 80 a6 60 00 cmp %i1, 0 4000e59c: 02 80 00 06 be 4000e5b4 <_Thread_Clear_state+0x38> 4000e5a0: f2 26 20 1c st %i1, [ %i0 + 0x1c ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e5a4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e5a8: 01 00 00 00 nop _Thread_State_acquire( the_thread, &lock_context ); previous_state = _Thread_Clear_state_locked( the_thread, state ); _Thread_State_release( the_thread, &lock_context ); return previous_state; } 4000e5ac: 81 c7 e0 08 ret 4000e5b0: 91 e8 00 1d restore %g0, %i5, %o0 4000e5b4: c2 27 bf fc st %g1, [ %fp + -4 ] 4000e5b8: 7f ff ff dc call 4000e528 <_Thread_Clear_state_locked.part.10> 4000e5bc: 90 10 00 18 mov %i0, %o0 4000e5c0: c2 07 bf fc ld [ %fp + -4 ], %g1 4000e5c4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e5c8: 01 00 00 00 nop 4000e5cc: 81 c7 e0 08 ret 4000e5d0: 91 e8 00 1d restore %g0, %i5, %o0 =============================================================================== 4000e54c <_Thread_Clear_state_locked>: { 4000e54c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED previous_state = the_thread->current_state; 4000e550: fa 06 20 1c ld [ %i0 + 0x1c ], %i5 <== NOT EXECUTED if ( ( previous_state & state ) != 0 ) { 4000e554: 80 8f 40 19 btst %i5, %i1 <== NOT EXECUTED 4000e558: 02 80 00 07 be 4000e574 <_Thread_Clear_state_locked+0x28> <== NOT EXECUTED 4000e55c: b2 2f 40 19 andn %i5, %i1, %i1 <== NOT EXECUTED if ( _States_Is_ready( next_state ) ) { 4000e560: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4000e564: 12 80 00 04 bne 4000e574 <_Thread_Clear_state_locked+0x28> <== NOT EXECUTED 4000e568: f2 26 20 1c st %i1, [ %i0 + 0x1c ] <== NOT EXECUTED 4000e56c: 7f ff ff ef call 4000e528 <_Thread_Clear_state_locked.part.10> <== NOT EXECUTED 4000e570: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED } 4000e574: 81 c7 e0 08 ret <== NOT EXECUTED 4000e578: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED =============================================================================== 4000eb3c <_Thread_Close>: Thread_Control *the_thread, Thread_Control *executing, Thread_Close_context *context ) { context->cancel = the_thread; 4000eb3c: d0 22 a0 24 st %o0, [ %o2 + 0x24 ] queue_context->enqueue_callout = enqueue_callout; 4000eb40: 03 10 00 3a sethi %hi(0x4000e800), %g1 4000eb44: 82 10 63 28 or %g1, 0x328, %g1 ! 4000eb28 <_Thread_Close_enqueue_callout> 4000eb48: c2 22 a0 08 st %g1, [ %o2 + 8 ] { 4000eb4c: 96 10 00 0a mov %o2, %o3 executing->Wait.return_argument = NULL; 4000eb50: c0 22 60 40 clr [ %o1 + 0x40 ] queue_context->thread_state = thread_state; 4000eb54: 03 00 00 10 sethi %hi(0x4000), %g1 4000eb58: c2 22 e0 04 st %g1, [ %o3 + 4 ] { 4000eb5c: 94 10 00 09 mov %o1, %o2 _Thread_queue_Enqueue( 4000eb60: 90 02 20 10 add %o0, 0x10, %o0 4000eb64: 13 10 00 8d sethi %hi(0x40023400), %o1 4000eb68: 92 12 61 a4 or %o1, 0x1a4, %o1 ! 400235a4 <_Thread_queue_Operations_priority> 4000eb6c: 82 13 c0 00 mov %o7, %g1 4000eb70: 7f ff fb 30 call 4000d830 <_Thread_queue_Enqueue> 4000eb74: 9e 10 40 00 mov %g1, %o7 =============================================================================== 4000ee70 <_Thread_Continue>: #include #include void _Thread_Continue( Thread_Control *the_thread, Status_Control status ) { 4000ee70: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED queue_context->Priority.update_count = 0; 4000ee74: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000ee78: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 4000ee7c: c2 27 bf dc st %g1, [ %fp + -36 ] 4000ee80: fa 06 20 50 ld [ %i0 + 0x50 ], %i5 _Thread_queue_Context_clear_priority_updates( &queue_context ); _Thread_Wait_acquire( the_thread, &queue_context ); wait_flags = _Thread_Wait_flags_get( the_thread ); if ( ( wait_flags & THREAD_WAIT_STATE_READY_AGAIN ) == 0 ) { 4000ee84: 80 8f 60 04 btst 4, %i5 4000ee88: 12 80 00 20 bne 4000ef08 <_Thread_Continue+0x98> 4000ee8c: 92 10 00 18 mov %i0, %o1 ( *the_thread->Wait.operations->extract )( 4000ee90: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 4000ee94: c2 00 60 08 ld [ %g1 + 8 ], %g1 4000ee98: d0 06 20 54 ld [ %i0 + 0x54 ], %o0 4000ee9c: 9f c0 40 00 call %g1 4000eea0: 94 07 bf dc add %fp, -36, %o2 the_thread->Wait.operations = &_Thread_queue_Operations_default; 4000eea4: 03 10 00 8d sethi %hi(0x40023400), %g1 4000eea8: 82 10 61 cc or %g1, 0x1cc, %g1 ! 400235cc <_Thread_queue_Operations_default> 4000eeac: c2 26 20 58 st %g1, [ %i0 + 0x58 ] _Thread_Wait_cancel( the_thread, &queue_context ); the_thread->Wait.return_code = status; wait_class = wait_flags & THREAD_WAIT_CLASS_MASK; 4000eeb0: 03 00 00 3f sethi %hi(0xfc00), %g1 4000eeb4: 82 10 63 00 or %g1, 0x300, %g1 ! ff00 <_Configuration_Interrupt_stack_size+0xef00> if ( success ) { 4000eeb8: c4 06 20 50 ld [ %i0 + 0x50 ], %g2 4000eebc: ba 0f 40 01 and %i5, %g1, %i5 the_thread->Wait.queue = NULL; 4000eec0: c0 26 20 54 clr [ %i0 + 0x54 ] ready_again = wait_class | THREAD_WAIT_STATE_READY_AGAIN; success = _Thread_Wait_flags_try_change_release( 4000eec4: 82 17 60 01 or %i5, 1, %g1 the_thread->Wait.return_code = status; 4000eec8: f4 26 20 4c st %i2, [ %i0 + 0x4c ] ready_again = wait_class | THREAD_WAIT_STATE_READY_AGAIN; 4000eecc: ba 17 60 04 or %i5, 4, %i5 if ( success ) { 4000eed0: 80 a0 40 02 cmp %g1, %g2 4000eed4: 02 80 00 0d be 4000ef08 <_Thread_Continue+0x98> 4000eed8: fa 26 20 50 st %i5, [ %i0 + 0x50 ] register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000eedc: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000eee0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000eee4: 01 00 00 00 nop } else { unblock = false; } _Thread_Wait_release( the_thread, &queue_context ); _Thread_Priority_update( &queue_context ); 4000eee8: 40 00 16 be call 400149e0 <_Thread_Priority_update> 4000eeec: 90 07 bf dc add %fp, -36, %o0 _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000eef0: 90 10 00 18 mov %i0, %o0 4000eef4: 13 0c 00 57 sethi %hi(0x30015c00), %o1 4000eef8: 40 00 16 e7 call 40014a94 <_Thread_Clear_state> 4000eefc: 92 12 63 ff or %o1, 0x3ff, %o1 ! 30015fff if ( !_Objects_Is_local_id( the_thread->Object.id ) ) { _Thread_MP_Free_proxy( the_thread ); } #endif } } 4000ef00: 81 c7 e0 08 ret 4000ef04: 81 e8 00 00 restore register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000ef08: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000ef0c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ef10: 01 00 00 00 nop _Thread_Priority_update( &queue_context ); 4000ef14: 40 00 16 b3 call 400149e0 <_Thread_Priority_update> 4000ef18: 90 07 bf dc add %fp, -36, %o0 } 4000ef1c: 81 c7 e0 08 ret 4000ef20: 81 e8 00 00 restore =============================================================================== 4000a2b0 <_Thread_Create_idle>: _Scheduler_Start_idle( scheduler, idle, cpu ); _User_extensions_Thread_start( idle ); } void _Thread_Create_idle( void ) { 4000a2b0: 9d e3 bf 70 save %sp, -144, %sp <== NOT EXECUTED 4000a2b4: 03 10 00 7d sethi %hi(0x4001f400), %g1 <== NOT EXECUTED 4000a2b8: 84 10 20 01 mov 1, %g2 return maximum_internal_threads; } RTEMS_INLINE_ROUTINE Thread_Control *_Thread_Internal_allocate( void ) { return (Thread_Control *) 4000a2bc: 31 10 00 7e sethi %hi(0x4001f800), %i0 4000a2c0: c4 20 61 38 st %g2, [ %g1 + 0x138 ] 4000a2c4: 7f ff fa ac call 40008d74 <_Objects_Allocate_unprotected> 4000a2c8: 90 16 21 94 or %i0, 0x194, %o0 _Stack_Ensure_minimum( rtems_configuration_get_idle_task_stack_size() ), 4000a2cc: 37 10 00 63 sethi %hi(0x40018c00), %i3 4000a2d0: 03 10 00 6c sethi %hi(0x4001b000), %g1 4000a2d4: b6 16 e0 e8 or %i3, 0xe8, %i3 4000a2d8: c2 00 63 40 ld [ %g1 + 0x340 ], %g1 4000a2dc: f4 06 e0 20 ld [ %i3 + 0x20 ], %i2 4000a2e0: 80 a6 80 01 cmp %i2, %g1 4000a2e4: 1a 80 00 03 bcc 4000a2f0 <_Thread_Create_idle+0x40> <== ALWAYS TAKEN 4000a2e8: b8 10 00 08 mov %o0, %i4 4000a2ec: b4 10 00 01 mov %g1, %i2 <== NOT EXECUTED _Thread_Initialize( 4000a2f0: 3b 10 00 63 sethi %hi(0x40018c00), %i5 4000a2f4: ba 17 61 c8 or %i5, 0x1c8, %i5 ! 40018dc8 <_Scheduler_Table> return ( *scheduler->Operations.map_priority )( scheduler, priority ); 4000a2f8: d4 07 60 44 ld [ %i5 + 0x44 ], %o2 4000a2fc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 4000a300: d2 07 60 40 ld [ %i5 + 0x40 ], %o1 4000a304: 9f c0 40 00 call %g1 4000a308: 90 10 00 1d mov %i5, %o0 4000a30c: d0 3f bf f0 std %o0, [ %fp + -16 ] 4000a310: 82 07 bf fc add %fp, -4, %g1 4000a314: c2 23 a0 74 st %g1, [ %sp + 0x74 ] 4000a318: b2 10 20 01 mov 1, %i1 4000a31c: c2 07 bf f0 ld [ %fp + -16 ], %g1 4000a320: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 4000a324: 98 10 00 1a mov %i2, %o4 4000a328: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000a32c: f2 23 a0 64 st %i1, [ %sp + 0x64 ] 4000a330: 9a 10 20 00 clr %o5 4000a334: c2 23 a0 60 st %g1, [ %sp + 0x60 ] 4000a338: 03 12 51 13 sethi %hi(0x49444c00), %g1 4000a33c: c0 23 a0 70 clr [ %sp + 0x70 ] 4000a340: 82 10 60 45 or %g1, 0x45, %g1 4000a344: c0 23 a0 6c clr [ %sp + 0x6c ] 4000a348: 96 10 20 00 clr %o3 4000a34c: c0 23 a0 68 clr [ %sp + 0x68 ] 4000a350: 94 10 00 1d mov %i5, %o2 4000a354: 92 10 00 1c mov %i4, %o1 4000a358: 90 16 21 94 or %i0, 0x194, %o0 4000a35c: 40 00 00 62 call 4000a4e4 <_Thread_Initialize> 4000a360: c2 27 bf fc st %g1, [ %fp + -4 ] idle->Start.Entry.Kinds.Idle.entry = rtems_configuration_get_idle_task(); 4000a364: c4 06 e0 1c ld [ %i3 + 0x1c ], %g2 cpu->executing = idle; 4000a368: 37 10 00 7e sethi %hi(0x4001f800), %i3 4000a36c: b6 16 e1 40 or %i3, 0x140, %i3 ! 4001f940 <_Per_CPU_Information> 4000a370: f8 26 e0 20 st %i4, [ %i3 + 0x20 ] idle->Start.Entry.adaptor = _Thread_Entry_adaptor_idle; 4000a374: 03 10 00 28 sethi %hi(0x4000a000), %g1 cpu->heir = 4000a378: f8 26 e0 24 st %i4, [ %i3 + 0x24 ] idle->Start.Entry.adaptor = _Thread_Entry_adaptor_idle; 4000a37c: 82 10 63 c0 or %g1, 0x3c0, %g1 idle->is_idle = true; 4000a380: f2 2f 20 88 stb %i1, [ %i4 + 0x88 ] _Thread_Load_environment( idle ); 4000a384: 90 10 00 1c mov %i4, %o0 idle->Start.Entry.adaptor = _Thread_Entry_adaptor_idle; 4000a388: c2 27 20 a0 st %g1, [ %i4 + 0xa0 ] _User_extensions_Iterate( 4000a38c: 33 10 00 2f sethi %hi(0x4000bc00), %i1 idle->Start.Entry.Kinds.Idle.entry = rtems_configuration_get_idle_task(); 4000a390: c4 27 20 a4 st %g2, [ %i4 + 0xa4 ] _Thread_Load_environment( idle ); 4000a394: 40 00 01 14 call 4000a7e4 <_Thread_Load_environment> 4000a398: b4 10 20 00 clr %i2 idle->current_state = STATES_READY; 4000a39c: c0 27 20 1c clr [ %i4 + 0x1c ] ( *scheduler->Operations.start_idle )( scheduler, the_thread, cpu ); 4000a3a0: 94 10 00 1b mov %i3, %o2 4000a3a4: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 4000a3a8: 92 10 00 1c mov %i4, %o1 4000a3ac: 90 10 00 1d mov %i5, %o0 4000a3b0: 9f c0 40 00 call %g1 4000a3b4: b0 10 00 1c mov %i4, %i0 4000a3b8: 40 00 06 86 call 4000bdd0 <_User_extensions_Iterate> 4000a3bc: 93 ee 60 f0 restore %i1, 0xf0, %o1 =============================================================================== 4000b344 <_Thread_Dispatch>: __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b344: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000b348: 92 10 00 01 mov %g1, %o1 _ISR_Local_disable( level ); cpu_self = _Per_CPU_Get(); if ( cpu_self->dispatch_necessary ) { 4000b34c: c4 09 a0 1c ldub [ %g6 + 0x1c ], %g2 4000b350: 80 a0 a0 00 cmp %g2, 0 4000b354: 12 80 00 06 bne 4000b36c <_Thread_Dispatch+0x28> <== NEVER TAKEN 4000b358: 90 10 00 06 mov %g6, %o0 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b35c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b360: 01 00 00 00 nop cpu_self->thread_dispatch_disable_level = 1; _Thread_Do_dispatch( cpu_self, level ); } else { _ISR_Local_enable( level ); } } 4000b364: 81 c3 e0 08 retl 4000b368: 01 00 00 00 nop cpu_self->thread_dispatch_disable_level = 1; 4000b36c: 82 10 20 01 mov 1, %g1 ! 1 <_TLS_Alignment> <== NOT EXECUTED 4000b370: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED _Thread_Do_dispatch( cpu_self, level ); 4000b374: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4000b378: 7f ff ff ab call 4000b224 <_Thread_Do_dispatch> <== NOT EXECUTED 4000b37c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 4000e6f4 <_Thread_Dispatch_direct>: _ISR_Local_enable( level ); } } void _Thread_Dispatch_direct( Per_CPU_Control *cpu_self ) { 4000e6f4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED ISR_Level level; if ( cpu_self->thread_dispatch_disable_level != 1 ) { 4000e6f8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED 4000e6fc: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000e700: 12 80 00 05 bne 4000e714 <_Thread_Dispatch_direct+0x20> <== NOT EXECUTED 4000e704: 01 00 00 00 nop __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000e708: 91 d0 20 09 ta 9 <== NOT EXECUTED _Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_DISABLE_LEVEL ); } _ISR_Local_disable( level ); _Thread_Do_dispatch( cpu_self, level ); 4000e70c: 7f ff ff b2 call 4000e5d4 <_Thread_Do_dispatch> 4000e710: 93 e8 00 01 restore %g0, %g1, %o1 _Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_DISABLE_LEVEL ); 4000e714: 7f ff e4 64 call 400078a4 <_Internal_error> 4000e718: 90 10 20 1e mov 0x1e, %o0 4000e71c: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 4000e5d4 <_Thread_Do_dispatch>: _Thread_State_release( executing, &lock_context ); } void _Thread_Do_dispatch( Per_CPU_Control *cpu_self, ISR_Level level ) { 4000e5d4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED ) { _Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT ); } #endif executing = cpu_self->executing; 4000e5d8: f6 06 20 20 ld [ %i0 + 0x20 ], %i3 { 4000e5dc: 82 10 00 19 mov %i1, %g1 /* * Since heir and executing are not the same, we need to do a real * context switch. */ if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) heir->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice(); 4000e5e0: 23 10 00 63 sethi %hi(0x40018c00), %l1 return _Chain_Immutable_head( the_chain )->next; 4000e5e4: 33 10 00 6d sethi %hi(0x4001b400), %i1 4000e5e8: a2 14 60 e8 or %l1, 0xe8, %l1 4000e5ec: b2 16 62 3c or %i1, 0x23c, %i1 _ISR_Local_enable( level ); _User_extensions_Thread_switch( executing, heir ); _Thread_Save_fp( executing ); _Context_Switch( &executing->Registers, &heir->Registers ); 4000e5f0: a0 06 e0 f0 add %i3, 0xf0, %l0 if ( node != tail ) { 4000e5f4: b4 06 60 04 add %i1, 4, %i2 heir = cpu_self->heir; 4000e5f8: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 cpu_self->dispatch_necessary = false; 4000e5fc: c0 2e 20 1c clrb [ %i0 + 0x1c ] if ( heir == executing ) 4000e600: 80 a6 c0 1c cmp %i3, %i4 4000e604: 02 80 00 1f be 4000e680 <_Thread_Do_dispatch+0xac> 4000e608: f8 26 20 20 st %i4, [ %i0 + 0x20 ] if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) 4000e60c: c4 07 20 90 ld [ %i4 + 0x90 ], %g2 4000e610: 80 a0 a0 01 cmp %g2, 1 4000e614: 12 80 00 04 bne 4000e624 <_Thread_Do_dispatch+0x50> 4000e618: 01 00 00 00 nop heir->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice(); 4000e61c: c4 04 60 18 ld [ %l1 + 0x18 ], %g2 <== NOT EXECUTED 4000e620: c4 27 20 8c st %g2, [ %i4 + 0x8c ] <== NOT EXECUTED 4000e624: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e628: 01 00 00 00 nop 4000e62c: fa 06 40 00 ld [ %i1 ], %i5 4000e630: 80 a7 40 1a cmp %i5, %i2 4000e634: 02 80 00 0b be 4000e660 <_Thread_Do_dispatch+0x8c> 4000e638: 92 07 20 f0 add %i4, 0xf0, %o1 (*extension->thread_switch)( executing, heir ); 4000e63c: c2 07 60 08 ld [ %i5 + 8 ], %g1 4000e640: 92 10 00 1c mov %i4, %o1 4000e644: 9f c0 40 00 call %g1 4000e648: 90 10 00 1b mov %i3, %o0 4000e64c: fa 07 40 00 ld [ %i5 ], %i5 while ( node != tail ) { 4000e650: 80 a7 40 1a cmp %i5, %i2 4000e654: 32 bf ff fb bne,a 4000e640 <_Thread_Do_dispatch+0x6c> 4000e658: c2 07 60 08 ld [ %i5 + 8 ], %g1 _Context_Switch( &executing->Registers, &heir->Registers ); 4000e65c: 92 07 20 f0 add %i4, 0xf0, %o1 4000e660: 7f ff f8 6e call 4000c818 <_CPU_Context_switch> 4000e664: 90 10 00 10 mov %l0, %o0 /* * We have to obtain this value again after the context switch since the * heir thread may have migrated from another processor. Values from the * stack or non-volatile registers reflect the old execution environment. */ cpu_self = _Per_CPU_Get(); 4000e668: b0 10 00 06 mov %g6, %i0 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000e66c: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_Local_disable( level ); } while ( cpu_self->dispatch_necessary ); 4000e670: c4 09 a0 1c ldub [ %g6 + 0x1c ], %g2 4000e674: 80 a0 a0 00 cmp %g2, 0 4000e678: 32 bf ff e1 bne,a 4000e5fc <_Thread_Do_dispatch+0x28> 4000e67c: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 post_switch: _Assert( cpu_self->thread_dispatch_disable_level == 1 ); cpu_self->thread_dispatch_disable_level = 0; 4000e680: c0 26 20 18 clr [ %i0 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e684: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e688: 01 00 00 00 nop __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000e68c: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( lock_context ); 4000e690: c2 27 bf fc st %g1, [ %fp + -4 ] 4000e694: d2 06 e0 e0 ld [ %i3 + 0xe0 ], %o1 return &the_chain->Tail.Node; 4000e698: ba 06 e0 e4 add %i3, 0xe4, %i5 if ( !_Chain_Is_empty(the_chain)) 4000e69c: 80 a2 40 1d cmp %o1, %i5 4000e6a0: 02 80 00 10 be 4000e6e0 <_Thread_Do_dispatch+0x10c> 4000e6a4: b8 06 e0 e0 add %i3, 0xe0, %i4 new_first = old_first->next; 4000e6a8: c2 02 40 00 ld [ %o1 ], %g1 head->next = new_first; 4000e6ac: c2 26 e0 e0 st %g1, [ %i3 + 0xe0 ] ( *action->handler )( executing, action, &lock_context ); 4000e6b0: 94 07 bf fc add %fp, -4, %o2 new_first->previous = head; 4000e6b4: f8 20 60 04 st %i4, [ %g1 + 4 ] node->next = NULL; 4000e6b8: c0 22 40 00 clr [ %o1 ] 4000e6bc: c2 02 60 08 ld [ %o1 + 8 ], %g1 4000e6c0: 9f c0 40 00 call %g1 4000e6c4: 90 10 00 1b mov %i3, %o0 4000e6c8: 91 d0 20 09 ta 9 <== NOT EXECUTED 4000e6cc: c2 27 bf fc st %g1, [ %fp + -4 ] return _Chain_Immutable_head( the_chain )->next; 4000e6d0: d2 06 e0 e0 ld [ %i3 + 0xe0 ], %o1 if ( !_Chain_Is_empty(the_chain)) 4000e6d4: 80 a7 40 09 cmp %i5, %o1 4000e6d8: 32 bf ff f5 bne,a 4000e6ac <_Thread_Do_dispatch+0xd8> <== NEVER TAKEN 4000e6dc: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e6e0: c2 07 bf fc ld [ %fp + -4 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e6e4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e6e8: 01 00 00 00 nop _Profiling_Thread_dispatch_enable( cpu_self, 0 ); _ISR_Local_enable( level ); _Thread_Run_post_switch_actions( executing ); } 4000e6ec: 81 c7 e0 08 ret 4000e6f0: 81 e8 00 00 restore =============================================================================== 4000a3c0 <_Thread_Entry_adaptor_idle>: #endif #include void _Thread_Entry_adaptor_idle( Thread_Control *executing ) { 4000a3c0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED const Thread_Entry_idle *idle = &executing->Start.Entry.Kinds.Idle; ( *idle->entry )( 0 ); 4000a3c4: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 4000a3c8: 9f c0 40 00 call %g1 4000a3cc: 90 10 20 00 clr %o0 } 4000a3d0: 81 c7 e0 08 ret <== NOT EXECUTED 4000a3d4: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000a3d8 <_Thread_Entry_adaptor_numeric>: #endif #include void _Thread_Entry_adaptor_numeric( Thread_Control *executing ) { 4000a3d8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED const Thread_Entry_numeric *numeric = &executing->Start.Entry.Kinds.Numeric; ( *numeric->entry )( numeric->argument ); 4000a3dc: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED 4000a3e0: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000a3e4: d0 06 20 a8 ld [ %i0 + 0xa8 ], %o0 } 4000a3e8: 81 c7 e0 08 ret 4000a3ec: 81 e8 00 00 restore =============================================================================== 400253b0 <_Thread_Entry_adaptor_pointer>: #endif #include void _Thread_Entry_adaptor_pointer( Thread_Control *executing ) { 400253b0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED const Thread_Entry_pointer *pointer = &executing->Start.Entry.Kinds.Pointer; executing->Wait.return_argument = ( *pointer->entry )( pointer->argument ); 400253b4: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED 400253b8: 9f c0 40 00 call %g1 <== NOT EXECUTED 400253bc: d0 06 20 a8 ld [ %i0 + 0xa8 ], %o0 400253c0: d0 26 20 40 st %o0, [ %i0 + 0x40 ] } 400253c4: 81 c7 e0 08 ret 400253c8: 81 e8 00 00 restore =============================================================================== 4000eb78 <_Thread_Exit>: void _Thread_Exit( Thread_Control *executing, Thread_Life_state set, void *exit_value ) { 4000eb78: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000eb7c: 91 d0 20 09 ta 9 <== NOT EXECUTED state |= set; 4000eb80: c4 06 21 70 ld [ %i0 + 0x170 ], %g2 4000eb84: b2 16 40 02 or %i1, %g2, %i1 the_thread->Life.exit_value = exit_value; 4000eb88: f4 26 21 78 st %i2, [ %i0 + 0x178 ] && _Thread_Is_life_changing( state ) 4000eb8c: 80 8e 60 06 btst 6, %i1 4000eb90: 02 80 00 06 be 4000eba8 <_Thread_Exit+0x30> <== NEVER TAKEN 4000eb94: f2 26 21 70 st %i1, [ %i0 + 0x170 ] 4000eb98: c2 27 bf fc st %g1, [ %fp + -4 ] 4000eb9c: 7f ff fe 97 call 4000e5f8 <_Thread_Change_life_locked.part.37> 4000eba0: 90 10 00 18 mov %i0, %o0 4000eba4: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000eba8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ebac: 01 00 00 00 nop 0, set, THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED ); _Thread_State_release( executing, &lock_context ); } 4000ebb0: 81 c7 e0 08 ret 4000ebb4: 81 e8 00 00 restore =============================================================================== 4000a3f0 <_Thread_Get>: ISR_lock_Context *lock_context ) { Objects_Information *information; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 4000a3f0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000a3f4: 02 80 00 11 be 4000a438 <_Thread_Get+0x48> <== NEVER TAKEN 4000a3f8: 83 32 20 18 srl %o0, 0x18, %g1 return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 4000a3fc: 82 08 60 07 and %g1, 7, %g1 if ( !the_api || the_api > OBJECTS_APIS_LAST ) 4000a400: 84 00 7f ff add %g1, -1, %g2 4000a404: 80 a0 a0 02 cmp %g2, 2 4000a408: 18 80 00 10 bgu 4000a448 <_Thread_Get+0x58> 4000a40c: 83 28 60 02 sll %g1, 2, %g1 return _Objects_Information_table[ the_api ][ 1 ]; 4000a410: 05 10 00 66 sethi %hi(0x40019800), %g2 4000a414: 84 10 a0 c0 or %g2, 0xc0, %g2 ! 400198c0 <_Objects_Information_table> 4000a418: c2 00 80 01 ld [ %g2 + %g1 ], %g1 4000a41c: d4 00 60 04 ld [ %g1 + 4 ], %o2 _ISR_lock_ISR_disable( lock_context ); return _Thread_Executing; } information = _Thread_Get_objects_information( id ); if ( information == NULL ) { 4000a420: 80 a2 a0 00 cmp %o2, 0 4000a424: 02 80 00 09 be 4000a448 <_Thread_Get+0x58> 4000a428: 01 00 00 00 nop return NULL; } return (Thread_Control *) 4000a42c: 82 13 c0 00 mov %o7, %g1 4000a430: 40 00 0e ff call 4000e02c <_Objects_Get> 4000a434: 9e 10 40 00 mov %g1, %o7 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000a438: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( lock_context ); 4000a43c: c2 22 40 00 st %g1, [ %o1 ] return _Thread_Executing; 4000a440: 81 c3 e0 08 retl 4000a444: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0 _Objects_Get( id, lock_context, information ); } 4000a448: 81 c3 e0 08 retl 4000a44c: 90 10 20 00 clr %o0 =============================================================================== 4000ba04 <_Thread_Get_CPU_time_used>: void _Thread_Get_CPU_time_used( Thread_Control *the_thread, Timestamp_Control *cpu_time_used ) { 4000ba04: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED 4000ba08: 91 d0 20 09 ta 9 <== NOT EXECUTED _Thread_State_acquire( the_thread, &state_lock_context ); scheduler = _Thread_Scheduler_get_home( the_thread ); _Scheduler_Acquire_critical( scheduler, &scheduler_lock_context ); if ( _Thread_Is_scheduled( the_thread ) ) { 4000ba0c: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2 4000ba10: 80 a6 00 02 cmp %i0, %g2 4000ba14: 02 80 00 08 be 4000ba34 <_Thread_Get_CPU_time_used+0x30> 4000ba18: ba 10 00 06 mov %g6, %i5 4000ba1c: c4 1e 20 98 ldd [ %i0 + 0x98 ], %g2 <== NOT EXECUTED _Thread_Update_CPU_time_used( the_thread, _Thread_Get_CPU( the_thread ) ); } *cpu_time_used = the_thread->cpu_time_used; 4000ba20: c4 3e 40 00 std %g2, [ %i1 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000ba24: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ba28: 01 00 00 00 nop _Scheduler_Release_critical( scheduler, &scheduler_lock_context ); _Thread_State_release( the_thread, &state_lock_context ); } 4000ba2c: 81 c7 e0 08 ret 4000ba30: 81 e8 00 00 restore last = cpu->cpu_usage_timestamp; 4000ba34: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 4000ba38: 7f ff f8 07 call 40009a54 <_Timecounter_Sbinuptime> 4000ba3c: c2 27 bf fc st %g1, [ %fp + -4 ] 4000ba40: d0 3f 60 28 std %o0, [ %i5 + 0x28 ] <== NOT EXECUTED *_result = *_end - *_start; 4000ba44: b6 a2 40 11 subcc %o1, %l1, %i3 <== NOT EXECUTED *_time += *_add; 4000ba48: f8 1e 20 98 ldd [ %i0 + 0x98 ], %i4 <== NOT EXECUTED *_result = *_end - *_start; 4000ba4c: b4 62 00 10 subx %o0, %l0, %i2 <== NOT EXECUTED *_time += *_add; 4000ba50: 86 86 c0 1d addcc %i3, %i5, %g3 <== NOT EXECUTED 4000ba54: 84 46 80 1c addx %i2, %i4, %g2 <== NOT EXECUTED 4000ba58: c4 3e 20 98 std %g2, [ %i0 + 0x98 ] <== NOT EXECUTED 4000ba5c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED *cpu_time_used = the_thread->cpu_time_used; 4000ba60: c4 3e 40 00 std %g2, [ %i1 ] <== NOT EXECUTED 4000ba64: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ba68: 01 00 00 00 nop } 4000ba6c: 81 c7 e0 08 ret 4000ba70: 81 e8 00 00 restore =============================================================================== 4000bf68 <_Thread_Get_name>: size_t _Thread_Get_name( const Thread_Control *the_thread, char *buffer, size_t buffer_size ) { 4000bf68: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED const char *name; name = the_thread->Join_queue.Queue.name; 4000bf6c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED { 4000bf70: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED if ( name != NULL && name[ 0 ] != '\0' ) { 4000bf74: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000bf78: 02 80 00 06 be 4000bf90 <_Thread_Get_name+0x28> <== NOT EXECUTED 4000bf7c: 96 10 00 1a mov %i2, %o3 4000bf80: c4 48 40 00 ldsb [ %g1 ], %g2 4000bf84: 80 a0 a0 00 cmp %g2, 0 4000bf88: 12 80 00 09 bne 4000bfac <_Thread_Get_name+0x44> 4000bf8c: b2 10 00 01 mov %g1, %i1 return strlcpy( buffer, name, buffer_size ); } else { return _Objects_Name_to_string( 4000bf90: c2 06 20 0c ld [ %i0 + 0xc ], %g1 4000bf94: c2 27 bf fc st %g1, [ %fp + -4 ] 4000bf98: 92 10 20 00 clr %o1 4000bf9c: 40 00 0d 91 call 4000f5e0 <_Objects_Name_to_string> 4000bfa0: 90 07 bf fc add %fp, -4, %o0 false, buffer, buffer_size ); } } 4000bfa4: 81 c7 e0 08 ret 4000bfa8: 91 e8 00 08 restore %g0, %o0, %o0 return strlcpy( buffer, name, buffer_size ); 4000bfac: 40 00 11 40 call 400104ac 4000bfb0: 91 e8 00 0a restore %g0, %o2, %o0 =============================================================================== 4000a450 <_Thread_Handler>: } #endif } void _Thread_Handler( void ) { 4000a450: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED /* * Some CPUs need to tinker with the call frame or registers when the * thread actually begins to execute for the first time. This is a * hook point where the port gets a shot at doing whatever it requires. */ _Context_Initialization_at_thread_begin(); 4000a454: 3f 10 00 29 sethi %hi(0x4000a400), %i7 <== NOT EXECUTED 4000a458: be 17 e0 50 or %i7, 0x50, %i7 ! 4000a450 <_Thread_Handler> <== NOT EXECUTED executing = _Thread_Executing; 4000a45c: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5 <== NOT EXECUTED 4000a460: 90 10 00 06 mov %g6, %o0 <== NOT EXECUTED /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 4000a464: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED _ISR_Set_level( level ); 4000a468: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000a46c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000a470: 01 00 00 00 nop __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000a474: 91 d0 20 09 ta 9 <== NOT EXECUTED * Make sure we lose no thread dispatch necessary update and execute the * post-switch actions. As a side-effect change the thread dispatch level * from one to zero. Do not use _Thread_Enable_dispatch() since there is no * valid thread dispatch necessary indicator in this context. */ _Thread_Do_dispatch( cpu_self, level ); 4000a478: 40 00 10 57 call 4000e5d4 <_Thread_Do_dispatch> 4000a47c: 92 10 00 01 mov %g1, %o1 _User_extensions_Iterate( 4000a480: 94 10 20 00 clr %o2 4000a484: 90 10 00 1d mov %i5, %o0 4000a488: 13 10 00 2f sethi %hi(0x4000bc00), %o1 4000a48c: 40 00 06 51 call 4000bdd0 <_User_extensions_Iterate> 4000a490: 92 12 61 38 or %o1, 0x138, %o1 ! 4000bd38 <_User_extensions_Thread_begin_visitor> if ( executing->Object.id == _Thread_Global_constructor ) { 4000a494: 03 10 00 7e sethi %hi(0x4001f800), %g1 4000a498: c6 07 60 08 ld [ %i5 + 8 ], %g3 4000a49c: c4 00 61 90 ld [ %g1 + 0x190 ], %g2 4000a4a0: 80 a0 c0 02 cmp %g3, %g2 4000a4a4: 02 80 00 0c be 4000a4d4 <_Thread_Handler+0x84> 4000a4a8: 01 00 00 00 nop /* * RTEMS supports multiple APIs and each API can define a different * thread/task prototype. The following code supports invoking the * user thread entry point using the prototype expected. */ ( *executing->Start.Entry.adaptor )( executing ); 4000a4ac: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 4000a4b0: 9f c0 40 00 call %g1 4000a4b4: 90 10 00 1d mov %i5, %o0 _User_extensions_Iterate( 4000a4b8: 90 10 00 1d mov %i5, %o0 4000a4bc: 94 10 20 00 clr %o2 4000a4c0: 13 10 00 2f sethi %hi(0x4000bc00), %o1 4000a4c4: 40 00 06 43 call 4000bdd0 <_User_extensions_Iterate> 4000a4c8: 92 12 61 5c or %o1, 0x15c, %o1 ! 4000bd5c <_User_extensions_Thread_exitted_visitor> * able to fit in a (void *). */ _User_extensions_Thread_exitted( executing ); _Internal_error( INTERNAL_ERROR_THREAD_EXITTED ); 4000a4cc: 7f ff f4 f6 call 400078a4 <_Internal_error> 4000a4d0: 90 10 20 05 mov 5, %o0 INIT_NAME(); 4000a4d4: 40 00 3f 71 call 4001a298 <_init> 4000a4d8: c0 20 61 90 clr [ %g1 + 0x190 ] ( *executing->Start.Entry.adaptor )( executing ); 4000a4dc: 10 bf ff f5 b 4000a4b0 <_Thread_Handler+0x60> 4000a4e0: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 =============================================================================== 4000a88c <_Thread_Handler_initialization>: THREAD_QUEUE_HEADS_SIZE( _Scheduler_Count ) ); } void _Thread_Handler_initialization(void) { 4000a88c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED rtems_stack_allocate_init_hook stack_allocate_init_hook = 4000a890: 03 10 00 63 sethi %hi(0x40018c00), %g1 4000a894: 82 10 60 e8 or %g1, 0xe8, %g1 ! 40018ce8 #if defined(RTEMS_MULTIPROCESSING) uint32_t maximum_proxies = _Configuration_MP_table->maximum_proxies; #endif if ( rtems_configuration_get_stack_allocate_hook() == NULL || 4000a898: c6 00 60 28 ld [ %g1 + 0x28 ], %g3 4000a89c: 80 a0 e0 00 cmp %g3, 0 4000a8a0: 02 80 00 12 be 4000a8e8 <_Thread_Handler_initialization+0x5c> <== NEVER TAKEN 4000a8a4: c4 00 60 24 ld [ %g1 + 0x24 ], %g2 4000a8a8: c6 00 60 2c ld [ %g1 + 0x2c ], %g3 4000a8ac: 80 a0 e0 00 cmp %g3, 0 4000a8b0: 02 80 00 0e be 4000a8e8 <_Thread_Handler_initialization+0x5c> 4000a8b4: 80 a0 a0 00 cmp %g2, 0 rtems_configuration_get_stack_free_hook() == NULL) _Internal_error( INTERNAL_ERROR_BAD_STACK_HOOK ); if ( stack_allocate_init_hook != NULL ) 4000a8b8: 22 80 00 05 be,a 4000a8cc <_Thread_Handler_initialization+0x40> 4000a8bc: 31 10 00 7e sethi %hi(0x4001f800), %i0 (*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() ); 4000a8c0: 9f c0 80 00 call %g2 4000a8c4: d0 00 60 04 ld [ %g1 + 4 ], %o0 /* * Initialize the internal class of threads. We need an IDLE thread * per CPU in an SMP system. In addition, if this is a loosely * coupled multiprocessing system, account for the MPCI Server Thread. */ _Thread_Initialize_information( 4000a8c8: 31 10 00 7e sethi %hi(0x4001f800), %i0 4000a8cc: ba 10 20 08 mov 8, %i5 4000a8d0: b8 10 20 00 clr %i4 4000a8d4: b6 10 20 01 mov 1, %i3 4000a8d8: b4 10 20 01 mov 1, %i2 4000a8dc: b2 10 20 01 mov 1, %i1 4000a8e0: 7f ff ff d8 call 4000a840 <_Thread_Initialize_information> 4000a8e4: 91 ee 21 94 restore %i0, 0x194, %o0 _Internal_error( INTERNAL_ERROR_BAD_STACK_HOOK ); 4000a8e8: 7f ff f3 ef call 400078a4 <_Internal_error> 4000a8ec: 90 10 20 0e mov 0xe, %o0 4000a8f0: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 4000a4e4 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 4000a4e4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED 4000a4e8: c2 07 a0 74 ld [ %fp + 0x74 ], %g1 <== NOT EXECUTED return false; } } #endif memset( 4000a4ec: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 <== NOT EXECUTED { 4000a4f0: e8 00 40 00 ld [ %g1 ], %l4 return (uintptr_t) _TLS_BSS_end - (uintptr_t) _TLS_Data_begin; 4000a4f4: 03 10 00 68 sethi %hi(0x4001a000), %g1 4000a4f8: 82 10 62 d0 or %g1, 0x2d0, %g1 ! 4001a2d0 <_Linker_set__Sysinit_bsp_work_area_initialize> 4000a4fc: e4 07 a0 5c ld [ %fp + 0x5c ], %l2 4000a500: e6 07 a0 60 ld [ %fp + 0x60 ], %l3 4000a504: e2 07 a0 68 ld [ %fp + 0x68 ], %l1 4000a508: ea 0f a0 67 ldub [ %fp + 0x67 ], %l5 memset( 4000a50c: 94 02 bf f0 add %o2, -16, %o2 4000a510: 21 10 00 68 sethi %hi(0x4001a000), %l0 4000a514: 92 10 20 00 clr %o1 4000a518: a0 14 22 d0 or %l0, 0x2d0, %l0 4000a51c: 90 06 60 10 add %i1, 0x10, %o0 4000a520: 40 00 13 38 call 4000f200 4000a524: a0 24 00 01 sub %l0, %g1, %l0 &the_thread->Join_queue, 0, information->Objects.size - offsetof( Thread_Control, Join_queue ) ); for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) { 4000a528: 03 10 00 63 sethi %hi(0x40018c00), %g1 4000a52c: de 00 61 24 ld [ %g1 + 0x124 ], %o7 ! 40018d24 <_Thread_Control_add_on_count> 4000a530: 80 a3 e0 00 cmp %o7, 0 4000a534: 02 80 00 0e be 4000a56c <_Thread_Initialize+0x88> <== NEVER TAKEN 4000a538: 80 a6 e0 00 cmp %i3, 0 4000a53c: 03 10 00 63 sethi %hi(0x40018c00), %g1 4000a540: 86 10 20 00 clr %g3 4000a544: 82 10 61 28 or %g1, 0x128, %g1 const Thread_Control_add_on *add_on = &_Thread_Control_add_ons[ i ]; *(void **) ( (char *) the_thread + add_on->destination_offset ) = (char *) the_thread + add_on->source_offset; 4000a548: c4 00 60 04 ld [ %g1 + 4 ], %g2 *(void **) ( (char *) the_thread + add_on->destination_offset ) = 4000a54c: c8 00 40 00 ld [ %g1 ], %g4 (char *) the_thread + add_on->source_offset; 4000a550: 84 06 40 02 add %i1, %g2, %g2 *(void **) ( (char *) the_thread + add_on->destination_offset ) = 4000a554: c4 26 40 04 st %g2, [ %i1 + %g4 ] for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) { 4000a558: 86 00 e0 01 inc %g3 4000a55c: 80 a0 c0 0f cmp %g3, %o7 4000a560: 12 bf ff fa bne 4000a548 <_Thread_Initialize+0x64> 4000a564: 82 00 60 08 add %g1, 8, %g1 if ( !actual_stack_size || actual_stack_size < stack_size ) return false; /* stack allocation failed */ stack = the_thread->Start.stack; #else if ( !stack_area ) { 4000a568: 80 a6 e0 00 cmp %i3, 0 4000a56c: 02 80 00 93 be 4000a7b8 <_Thread_Initialize+0x2d4> 4000a570: 92 10 00 1c mov %i4, %o1 stack = the_thread->Start.stack; the_thread->Start.core_allocated_stack = true; } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = false; 4000a574: c0 2e 60 c8 clrb [ %i1 + 0xc8 ] 4000a578: ac 06 20 3c add %i0, 0x3c, %l6 the_stack->area = starting_address; 4000a57c: f6 26 60 d0 st %i3, [ %i1 + 0xd0 ] ); scheduler_index = 0; /* Thread-local storage (TLS) area allocation */ if ( tls_size > 0 ) { 4000a580: 80 a4 20 00 cmp %l0, 0 4000a584: 12 80 00 6a bne 4000a72c <_Thread_Initialize+0x248> 4000a588: f8 26 60 cc st %i4, [ %i1 + 0xcc ] /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 4000a58c: 80 a7 60 00 cmp %i5, 0 4000a590: 12 80 00 79 bne 4000a774 <_Thread_Initialize+0x290> 4000a594: b8 10 20 00 clr %i4 fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) goto failed; } the_thread->fp_context = fp_area; 4000a598: f8 26 61 50 st %i4, [ %i1 + 0x150 ] the_thread->Start.fp_context = fp_area; 4000a59c: f8 26 60 d4 st %i4, [ %i1 + 0xd4 ] return information->auto_extend ? information->allocation_size : 0; 4000a5a0: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1 4000a5a4: 80 a0 60 00 cmp %g1, 0 4000a5a8: 12 80 00 5f bne 4000a724 <_Thread_Initialize+0x240> 4000a5ac: 94 10 20 00 clr %o2 #endif /* * Get thread queue heads */ the_thread->Wait.spare_heads = _Freechain_Get( 4000a5b0: 96 10 20 48 mov 0x48, %o3 4000a5b4: 90 10 00 16 mov %l6, %o0 4000a5b8: 13 10 00 30 sethi %hi(0x4000c000), %o1 4000a5bc: 7f ff f2 eb call 40007168 <_Freechain_Get> 4000a5c0: 92 12 63 b8 or %o1, 0x3b8, %o1 ! 4000c3b8 <_Workspace_Allocate> &information->Free_thread_queue_heads, _Workspace_Allocate, _Objects_Extend_size( &information->Objects ), THREAD_QUEUE_HEADS_SIZE( _Scheduler_Count ) ); if ( the_thread->Wait.spare_heads == NULL ) { 4000a5c4: 80 a2 20 00 cmp %o0, 0 4000a5c8: 02 80 00 48 be 4000a6e8 <_Thread_Initialize+0x204> <== NEVER TAKEN 4000a5cc: d0 26 60 5c st %o0, [ %i1 + 0x5c ] return &the_chain->Tail.Node; 4000a5d0: 82 02 20 34 add %o0, 0x34, %g1 head->previous = NULL; 4000a5d4: c0 22 20 34 clr [ %o0 + 0x34 ] return &the_chain->Tail.Node; 4000a5d8: 84 02 20 30 add %o0, 0x30, %g2 head->next = tail; 4000a5dc: c2 22 20 30 st %g1, [ %o0 + 0x30 ] the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout; _Thread_Timer_initialize( &the_thread->Timer, cpu ); switch ( budget_algorithm ) { 4000a5e0: 80 a4 60 02 cmp %l1, 2 tail->previous = head; 4000a5e4: c4 22 20 38 st %g2, [ %o0 + 0x38 ] the_thread->Start.isr_level = isr_level; 4000a5e8: c2 07 a0 70 ld [ %fp + 0x70 ], %g1 4000a5ec: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ] the_thread->Start.budget_callout = budget_callout; 4000a5f0: c2 07 a0 6c ld [ %fp + 0x6c ], %g1 4000a5f4: c2 26 60 b4 st %g1, [ %i1 + 0xb4 ] Thread_Timer_information *timer, Per_CPU_Control *cpu ) { _ISR_lock_Initialize( &timer->Lock, "Thread Timer" ); timer->header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ]; 4000a5f8: 03 10 00 7e sethi %hi(0x4001f800), %g1 4000a5fc: 82 10 61 78 or %g1, 0x178, %g1 ! 4001f978 <_Per_CPU_Information+0x38> the_thread->is_fp = is_fp; 4000a600: fa 2e 60 8a stb %i5, [ %i1 + 0x8a ] 4000a604: c2 26 60 60 st %g1, [ %i1 + 0x60 ] RTEMS_INLINE_ROUTINE void _Watchdog_Set_state( Watchdog_Control *the_watchdog, Watchdog_State state ) { RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 4000a608: 82 10 20 02 mov 2, %g1 the_thread->Start.is_preemptible = is_preemptible; 4000a60c: ea 2e 60 ac stb %l5, [ %i1 + 0xac ] the_thread->Start.budget_algorithm = budget_algorithm; 4000a610: e2 26 60 b0 st %l1, [ %i1 + 0xb0 ] switch ( budget_algorithm ) { 4000a614: 12 80 00 05 bne 4000a628 <_Thread_Initialize+0x144> 4000a618: c2 26 60 74 st %g1, [ %i1 + 0x74 ] case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: break; #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE) case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: the_thread->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice(); 4000a61c: 03 10 00 63 sethi %hi(0x40018c00), %g1 the_thread->cpu_time_budget = 4000a620: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 40018d00 4000a624: c2 26 60 8c st %g1, [ %i1 + 0x8c ] ( *scheduler->Operations.node_initialize )( 4000a628: 96 10 00 12 mov %l2, %o3 4000a62c: fa 06 60 38 ld [ %i1 + 0x38 ], %i5 4000a630: c2 06 a0 24 ld [ %i2 + 0x24 ], %g1 4000a634: 98 10 00 13 mov %l3, %o4 4000a638: 94 10 00 19 mov %i1, %o2 4000a63c: 92 10 00 1d mov %i5, %o1 4000a640: 9f c0 40 00 call %g1 4000a644: 90 10 00 1a mov %i2, %o0 RTEMS_INLINE_ROUTINE void _Priority_Node_initialize( Priority_Node *node, Priority_Control priority ) { node->priority = priority; 4000a648: e4 3e 60 30 std %l2, [ %i1 + 0x30 ] #endif aggregation->Action.node = NULL; aggregation->Action.type = PRIORITY_ACTION_INVALID; #endif _Priority_Node_initialize( &aggregation->Node, node->priority ); _RBTree_Initialize_one( &aggregation->Contributors, &node->Node.RBTree ); 4000a64c: 82 06 60 20 add %i1, 0x20, %g1 node->priority = priority; 4000a650: e4 3f 60 18 std %l2, [ %i5 + 0x18 ] #endif /* Initialize the CPU for the non-SMP schedulers */ _Thread_Set_CPU( the_thread, cpu ); the_thread->current_state = STATES_DORMANT; 4000a654: 05 20 00 00 sethi %hi(0x80000000), %g2 RB_ROOT( the_rbtree ) = the_node; 4000a658: c2 27 60 20 st %g1, [ %i5 + 0x20 ] return &the_chain->Tail.Node; 4000a65c: 86 06 60 e0 add %i1, 0xe0, %g3 4000a660: c4 26 60 1c st %g2, [ %i1 + 0x1c ] the_thread->Wait.operations = &_Thread_queue_Operations_default; 4000a664: 05 10 00 66 sethi %hi(0x40019800), %g2 4000a668: 84 10 a1 50 or %g2, 0x150, %g2 ! 40019950 <_Thread_queue_Operations_default> information->local_table[ index ] = the_object; 4000a66c: c2 16 60 0a lduh [ %i1 + 0xa ], %g1 4000a670: c4 26 60 58 st %g2, [ %i1 + 0x58 ] 4000a674: 88 06 60 e4 add %i1, 0xe4, %g4 4000a678: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 RB_PARENT( the_node, Node ) = NULL; 4000a67c: c0 26 60 28 clr [ %i1 + 0x28 ] 4000a680: 83 28 60 02 sll %g1, 2, %g1 RB_LEFT( the_node, Node ) = NULL; 4000a684: c0 26 60 20 clr [ %i1 + 0x20 ] _User_extensions_Iterate( 4000a688: 94 10 20 00 clr %o2 RB_RIGHT( the_node, Node ) = NULL; 4000a68c: c0 26 60 24 clr [ %i1 + 0x24 ] 4000a690: 13 10 00 2f sethi %hi(0x4000bc00), %o1 RB_COLOR( the_node, Node ) = RB_BLACK; 4000a694: c0 26 60 2c clr [ %i1 + 0x2c ] 4000a698: 92 12 60 90 or %o1, 0x90, %o1 the_thread->Start.initial_priority = priority; 4000a69c: e4 3e 60 c0 std %l2, [ %i1 + 0xc0 ] 4000a6a0: 90 07 bf f8 add %fp, -8, %o0 RB_INIT( the_rbtree ); 4000a6a4: c0 26 61 60 clr [ %i1 + 0x160 ] head->next = tail; 4000a6a8: c8 26 60 e0 st %g4, [ %i1 + 0xe0 ] head->previous = NULL; 4000a6ac: c0 26 60 e4 clr [ %i1 + 0xe4 ] tail->previous = head; 4000a6b0: c6 26 60 e8 st %g3, [ %i1 + 0xe8 ] the_object->name = name; 4000a6b4: e8 26 60 0c st %l4, [ %i1 + 0xc ] information->local_table[ index ] = the_object; 4000a6b8: f2 20 80 01 st %i1, [ %g2 + %g1 ] User_extensions_Thread_create_context ctx = { created, true }; 4000a6bc: 82 10 20 01 mov 1, %g1 4000a6c0: f2 27 bf f8 st %i1, [ %fp + -8 ] _User_extensions_Iterate( 4000a6c4: 40 00 05 c3 call 4000bdd0 <_User_extensions_Iterate> 4000a6c8: c2 2f bf fc stb %g1, [ %fp + -4 ] * user extensions with dispatching enabled. The Allocator * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) 4000a6cc: f0 0f bf fc ldub [ %fp + -4 ], %i0 4000a6d0: 80 a6 20 00 cmp %i0, 0 4000a6d4: 12 80 00 0f bne 4000a710 <_Thread_Initialize+0x22c> 4000a6d8: 92 10 00 1d mov %i5, %o1 ( *scheduler->Operations.node_destroy )( scheduler, node ); 4000a6dc: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1 4000a6e0: 9f c0 40 00 call %g1 4000a6e4: 90 10 00 1a mov %i2, %o0 4000a6e8: d0 06 60 dc ld [ %i1 + 0xdc ], %o0 if ( scheduler_index > 0 ) { _Scheduler_Node_destroy( scheduler, scheduler_node ); } #endif _Workspace_Free( the_thread->Start.tls_area ); 4000a6ec: 40 00 07 43 call 4000c3f8 <_Workspace_Free> 4000a6f0: b0 10 20 00 clr %i0 _Freechain_Put( 4000a6f4: d2 06 60 5c ld [ %i1 + 0x5c ], %o1 4000a6f8: 7f ff f2 ba call 400071e0 <_Freechain_Put> 4000a6fc: 90 10 00 16 mov %l6, %o0 &information->Free_thread_queue_heads, the_thread->Wait.spare_heads ); #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Workspace_Free( fp_area ); 4000a700: 40 00 07 3e call 4000c3f8 <_Workspace_Free> 4000a704: 90 10 00 1c mov %i4, %o0 #endif _Thread_Stack_Free( the_thread ); 4000a708: 40 00 04 e8 call 4000baa8 <_Thread_Stack_Free> 4000a70c: 90 10 00 19 mov %i1, %o0 return false; 4000a710: 81 c7 e0 08 ret 4000a714: 81 e8 00 00 restore 4000a718: b0 10 20 00 clr %i0 } 4000a71c: 81 c7 e0 08 ret 4000a720: 81 e8 00 00 restore 4000a724: 10 bf ff a3 b 4000a5b0 <_Thread_Initialize+0xcc> 4000a728: d4 16 20 14 lduh [ %i0 + 0x14 ], %o2 return (val + msk) & ~msk; 4000a72c: 90 04 20 07 add %l0, 7, %o0 4000a730: 13 00 00 00 sethi %hi(0), %o1 4000a734: 90 0a 3f f8 and %o0, -8, %o0 4000a738: 92 12 60 01 or %o1, 1, %o1 4000a73c: 92 02 60 07 add %o1, 7, %o1 4000a740: 92 0a 7f f8 and %o1, -8, %o1 sizeof(TLS_Thread_control_block) : alignment; 4000a744: 80 a2 60 08 cmp %o1, 8 4000a748: 0a 80 00 12 bcs 4000a790 <_Thread_Initialize+0x2ac> <== NEVER TAKEN 4000a74c: 82 10 00 09 mov %o1, %g1 allocation_size += _TLS_Get_thread_control_block_area_size( alignment ); 4000a750: 90 02 00 01 add %o0, %g1, %o0 _Workspace_Allocate_aligned( tls_alloc, tls_align ); 4000a754: 40 00 07 21 call 4000c3d8 <_Workspace_Allocate_aligned> 4000a758: 90 02 20 08 add %o0, 8, %o0 the_thread->Start.tls_area = 4000a75c: d0 26 60 dc st %o0, [ %i1 + 0xdc ] if ( the_thread->Start.tls_area == NULL ) { 4000a760: 80 a2 20 00 cmp %o0, 0 4000a764: 12 bf ff 8a bne 4000a58c <_Thread_Initialize+0xa8> <== ALWAYS TAKEN 4000a768: b8 10 00 08 mov %o0, %i4 failed: 4000a76c: 10 bf ff e0 b 4000a6ec <_Thread_Initialize+0x208> <== NOT EXECUTED 4000a770: 90 10 20 00 clr %o0 <== NOT EXECUTED fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 4000a774: 40 00 07 11 call 4000c3b8 <_Workspace_Allocate> 4000a778: 90 10 20 88 mov 0x88, %o0 if ( !fp_area ) 4000a77c: b8 92 20 00 orcc %o0, 0, %i4 4000a780: 32 bf ff 87 bne,a 4000a59c <_Thread_Initialize+0xb8> 4000a784: f8 26 61 50 st %i4, [ %i1 + 0x150 ] failed: 4000a788: 10 bf ff d9 b 4000a6ec <_Thread_Initialize+0x208> 4000a78c: d0 06 60 dc ld [ %i1 + 0xdc ], %o0 sizeof(TLS_Thread_control_block) : alignment; 4000a790: 82 10 20 08 mov 8, %g1 <== NOT EXECUTED allocation_size += _TLS_Get_thread_control_block_area_size( alignment ); 4000a794: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED _Workspace_Allocate_aligned( tls_alloc, tls_align ); 4000a798: 40 00 07 10 call 4000c3d8 <_Workspace_Allocate_aligned> <== NOT EXECUTED 4000a79c: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED the_thread->Start.tls_area = 4000a7a0: d0 26 60 dc st %o0, [ %i1 + 0xdc ] <== NOT EXECUTED if ( the_thread->Start.tls_area == NULL ) { 4000a7a4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000a7a8: 12 bf ff 79 bne 4000a58c <_Thread_Initialize+0xa8> <== NOT EXECUTED 4000a7ac: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED 4000a7b0: 10 bf ff cf b 4000a6ec <_Thread_Initialize+0x208> <== NOT EXECUTED 4000a7b4: 90 10 20 00 clr %o0 <== NOT EXECUTED actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 4000a7b8: 40 00 04 ac call 4000ba68 <_Thread_Stack_Allocate> 4000a7bc: 90 10 00 19 mov %i1, %o0 if ( !actual_stack_size || actual_stack_size < stack_size ) 4000a7c0: 80 a2 20 00 cmp %o0, 0 4000a7c4: 02 bf ff d5 be 4000a718 <_Thread_Initialize+0x234> 4000a7c8: 80 a2 00 1c cmp %o0, %i4 4000a7cc: 0a bf ff d3 bcs 4000a718 <_Thread_Initialize+0x234> <== NEVER TAKEN 4000a7d0: 82 10 20 01 mov 1, %g1 stack = the_thread->Start.stack; 4000a7d4: f6 06 60 d8 ld [ %i1 + 0xd8 ], %i3 the_thread->Start.core_allocated_stack = true; 4000a7d8: c2 2e 60 c8 stb %g1, [ %i1 + 0xc8 ] 4000a7dc: 10 bf ff 67 b 4000a578 <_Thread_Initialize+0x94> 4000a7e0: b8 10 00 08 mov %o0, %i4 =============================================================================== 4000a840 <_Thread_Initialize_information>: uint16_t the_class, uint32_t maximum, bool is_string, uint32_t maximum_name_length ) { 4000a840: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _Objects_Initialize_information( 4000a844: fa 23 a0 5c st %i5, [ %sp + 0x5c ] <== NOT EXECUTED 4000a848: 03 10 00 63 sethi %hi(0x40018c00), %g1 4000a84c: d8 10 61 52 lduh [ %g1 + 0x152 ], %o4 ! 40018d52 <_Thread_Control_size+0x2> { 4000a850: ba 10 00 1b mov %i3, %i5 _Objects_Initialize_information( 4000a854: 94 10 00 1a mov %i2, %o2 4000a858: 92 10 00 19 mov %i1, %o1 4000a85c: 96 10 00 1b mov %i3, %o3 4000a860: 90 10 00 18 mov %i0, %o0 4000a864: 9a 10 00 1c mov %i4, %o5 is_string, maximum_name_length, NULL ); _Freechain_Initialize( 4000a868: 33 10 00 31 sethi %hi(0x4000c400), %i1 4000a86c: 35 00 00 3f sethi %hi(0xfc00), %i2 4000a870: b6 10 20 48 mov 0x48, %i3 _Objects_Initialize_information( 4000a874: 7f ff fa 4d call 400091a8 <_Objects_Do_initialize_information> 4000a878: b4 16 a3 ff or %i2, 0x3ff, %i2 _Freechain_Initialize( 4000a87c: b0 06 20 3c add %i0, 0x3c, %i0 4000a880: b4 0f 40 1a and %i5, %i2, %i2 4000a884: 7f ff f2 2c call 40007134 <_Freechain_Initialize> 4000a888: 93 ee 60 10 restore %i1, 0x10, %o1 =============================================================================== 4000e830 <_Thread_Iterate>: void _Thread_Iterate( Thread_Visitor visitor, void *arg ) { 4000e830: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 4000e834: 37 10 00 77 sethi %hi(0x4001dc00), %i3 <== NOT EXECUTED 4000e838: b6 16 e3 1c or %i3, 0x31c, %i3 ! 4001df1c <_Objects_Information_table> <== NOT EXECUTED 4000e83c: b4 06 e0 0c add %i3, 0xc, %i2 <== NOT EXECUTED if ( _Objects_Information_table[ api_index ] == NULL ) { continue; } #endif information = _Objects_Information_table[ api_index ][ 1 ]; 4000e840: c2 06 e0 04 ld [ %i3 + 4 ], %g1 <== NOT EXECUTED 4000e844: f8 00 60 04 ld [ %g1 + 4 ], %i4 if ( information == NULL ) { 4000e848: 80 a7 20 00 cmp %i4, 0 4000e84c: 22 80 00 1d be,a 4000e8c0 <_Thread_Iterate+0x90> 4000e850: b6 06 e0 04 add %i3, 4, %i3 continue; } for ( i = 1 ; i <= information->maximum ; ++i ) { 4000e854: c4 17 20 10 lduh [ %i4 + 0x10 ], %g2 4000e858: 82 90 a0 00 orcc %g2, 0, %g1 4000e85c: 02 80 00 18 be 4000e8bc <_Thread_Iterate+0x8c> <== NEVER TAKEN 4000e860: ba 10 20 01 mov 1, %i5 Thread_Control *the_thread; the_thread = (Thread_Control *) information->local_table[ i ]; 4000e864: 10 80 00 09 b 4000e888 <_Thread_Iterate+0x58> 4000e868: c6 07 20 1c ld [ %i4 + 0x1c ], %g3 for ( i = 1 ; i <= information->maximum ; ++i ) { 4000e86c: ba 07 60 01 inc %i5 4000e870: 83 28 a0 10 sll %g2, 0x10, %g1 4000e874: 87 2f 60 10 sll %i5, 0x10, %g3 4000e878: 80 a0 c0 01 cmp %g3, %g1 4000e87c: 38 80 00 11 bgu,a 4000e8c0 <_Thread_Iterate+0x90> 4000e880: b6 06 e0 04 add %i3, 4, %i3 the_thread = (Thread_Control *) information->local_table[ i ]; 4000e884: c6 07 20 1c ld [ %i4 + 0x1c ], %g3 4000e888: 83 2f 60 10 sll %i5, 0x10, %g1 4000e88c: 83 30 60 0e srl %g1, 0xe, %g1 4000e890: d0 00 c0 01 ld [ %g3 + %g1 ], %o0 if ( the_thread != NULL ) { 4000e894: 80 a2 20 00 cmp %o0, 0 4000e898: 22 bf ff f6 be,a 4000e870 <_Thread_Iterate+0x40> 4000e89c: ba 07 60 01 inc %i5 bool done; done = (* visitor )( the_thread, arg ); 4000e8a0: 9f c6 00 00 call %i0 4000e8a4: 92 10 00 19 mov %i1, %o1 if ( done ) { 4000e8a8: 80 a2 20 00 cmp %o0, 0 4000e8ac: 22 bf ff f0 be,a 4000e86c <_Thread_Iterate+0x3c> <== ALWAYS TAKEN 4000e8b0: c4 17 20 10 lduh [ %i4 + 0x10 ], %g2 return; } } } } } 4000e8b4: 81 c7 e0 08 ret <== NOT EXECUTED 4000e8b8: 81 e8 00 00 restore <== NOT EXECUTED 4000e8bc: b6 06 e0 04 add %i3, 4, %i3 <== NOT EXECUTED for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; ++api_index ) { 4000e8c0: 80 a6 80 1b cmp %i2, %i3 4000e8c4: 32 bf ff e0 bne,a 4000e844 <_Thread_Iterate+0x14> 4000e8c8: c2 06 e0 04 ld [ %i3 + 4 ], %g1 } 4000e8cc: 81 c7 e0 08 ret 4000e8d0: 81 e8 00 00 restore =============================================================================== 400105a0 <_Thread_Join>: { _Assert( the_thread != executing ); _Assert( _Thread_State_is_owner( the_thread ) ); #if defined(RTEMS_POSIX_API) executing->Wait.return_argument = NULL; 400105a0: c0 22 a0 40 clr [ %o2 + 0x40 ] <== NOT EXECUTED #endif _Thread_queue_Context_set_thread_state( queue_context, waiting_for_join ); _Thread_queue_Enqueue( 400105a4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED queue_context->thread_state = thread_state; 400105a8: d2 22 e0 04 st %o1, [ %o3 + 4 ] <== NOT EXECUTED 400105ac: 13 10 00 6f sethi %hi(0x4001bc00), %o1 <== NOT EXECUTED 400105b0: 92 12 61 68 or %o1, 0x168, %o1 ! 4001bd68 <_Thread_queue_Operations_priority> <== NOT EXECUTED 400105b4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 400105b8: 7f ff fb 73 call 4000f384 <_Thread_queue_Enqueue> <== NOT EXECUTED 400105bc: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 4000b7fc <_Thread_Kill_zombies>: { 4000b7fc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b800: 91 d0 20 09 ta 9 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 4000b804: 05 10 00 6d sethi %hi(0x4001b400), %g2 4000b808: fa 00 a1 cc ld [ %g2 + 0x1cc ], %i5 ! 4001b5cc <_Thread_Zombies> 4000b80c: b8 10 a1 cc or %g2, 0x1cc, %i4 if ( !_Chain_Is_empty(the_chain)) 4000b810: b0 07 20 04 add %i4, 4, %i0 4000b814: 80 a7 40 18 cmp %i5, %i0 4000b818: 02 80 00 3d be 4000b90c <_Thread_Kill_zombies+0x110> 4000b81c: 33 10 00 2f sethi %hi(0x4000bc00), %i1 new_first = old_first->next; 4000b820: c6 07 40 00 ld [ %i5 ], %g3 <== NOT EXECUTED head->next = new_first; 4000b824: c6 20 a1 cc st %g3, [ %g2 + 0x1cc ] <== NOT EXECUTED new_first->previous = head; 4000b828: f8 20 e0 04 st %i4, [ %g3 + 4 ] <== NOT EXECUTED 4000b82c: 35 10 00 63 sethi %hi(0x40018c00), %i2 <== NOT EXECUTED _User_extensions_Iterate( 4000b830: b2 16 60 cc or %i1, 0xcc, %i1 <== NOT EXECUTED 4000b834: b4 16 a1 c8 or %i2, 0x1c8, %i2 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b838: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b83c: 01 00 00 00 nop Thread_Information *information = (Thread_Information *) 4000b840: 40 00 09 d8 call 4000dfa0 <_Objects_Get_information_id> 4000b844: d0 07 60 08 ld [ %i5 + 8 ], %o0 4000b848: 94 10 20 01 mov 1, %o2 4000b84c: b6 10 00 08 mov %o0, %i3 4000b850: 92 10 00 19 mov %i1, %o1 4000b854: 40 00 01 5f call 4000bdd0 <_User_extensions_Iterate> 4000b858: 90 10 00 1d mov %i5, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b85c: 91 d0 20 09 ta 9 <== NOT EXECUTED iter = the_thread->last_user_extensions_iterator; 4000b860: c4 07 61 88 ld [ %i5 + 0x188 ], %g2 while ( iter != NULL ) { 4000b864: 80 a0 a0 00 cmp %g2, 0 4000b868: 02 80 00 0a be 4000b890 <_Thread_Kill_zombies+0x94> 4000b86c: 01 00 00 00 nop next = the_node->next; 4000b870: c8 00 80 00 ld [ %g2 ], %g4 previous = the_node->previous; 4000b874: c6 00 a0 04 ld [ %g2 + 4 ], %g3 next->previous = previous; 4000b878: c6 21 20 04 st %g3, [ %g4 + 4 ] previous->next = next; 4000b87c: c8 20 c0 00 st %g4, [ %g3 ] iter = iter->previous; 4000b880: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 while ( iter != NULL ) { 4000b884: 80 a0 a0 00 cmp %g2, 0 4000b888: 32 bf ff fb bne,a 4000b874 <_Thread_Kill_zombies+0x78> <== NEVER TAKEN 4000b88c: c8 00 80 00 ld [ %g2 ], %g4 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b890: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b894: 01 00 00 00 nop 4000b898: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1 4000b89c: d2 07 60 38 ld [ %i5 + 0x38 ], %o1 4000b8a0: 9f c0 40 00 call %g1 4000b8a4: 90 10 00 1a mov %i2, %o0 _Workspace_Free( the_thread->Start.fp_context ); 4000b8a8: 40 00 02 d4 call 4000c3f8 <_Workspace_Free> 4000b8ac: d0 07 60 d4 ld [ %i5 + 0xd4 ], %o0 _Freechain_Put( 4000b8b0: d2 07 60 5c ld [ %i5 + 0x5c ], %o1 4000b8b4: 7f ff ee 4b call 400071e0 <_Freechain_Put> 4000b8b8: 90 06 e0 3c add %i3, 0x3c, %o0 _Thread_Stack_Free( the_thread ); 4000b8bc: 40 00 00 7b call 4000baa8 <_Thread_Stack_Free> 4000b8c0: 90 10 00 1d mov %i5, %o0 _Workspace_Free( the_thread->Start.tls_area ); 4000b8c4: 40 00 02 cd call 4000c3f8 <_Workspace_Free> 4000b8c8: d0 07 60 dc ld [ %i5 + 0xdc ], %o0 _Context_Destroy( the_thread, &the_thread->Registers ); 4000b8cc: c4 01 a0 04 ld [ %g6 + 4 ], %g2 4000b8d0: 80 a0 80 1d cmp %g2, %i5 4000b8d4: 22 80 00 02 be,a 4000b8dc <_Thread_Kill_zombies+0xe0> 4000b8d8: c0 21 a0 04 clr [ %g6 + 4 ] _Objects_Free( &information->Objects, &the_thread->Object ); 4000b8dc: 92 10 00 1d mov %i5, %o1 4000b8e0: 40 00 09 84 call 4000def0 <_Objects_Free> 4000b8e4: 90 10 00 1b mov %i3, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b8e8: 91 d0 20 09 ta 9 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 4000b8ec: fa 07 00 00 ld [ %i4 ], %i5 if ( !_Chain_Is_empty(the_chain)) 4000b8f0: 80 a7 40 18 cmp %i5, %i0 4000b8f4: 02 80 00 06 be 4000b90c <_Thread_Kill_zombies+0x110> 4000b8f8: 01 00 00 00 nop new_first = old_first->next; 4000b8fc: c4 07 40 00 ld [ %i5 ], %g2 head->next = new_first; 4000b900: c4 27 00 00 st %g2, [ %i4 ] new_first->previous = head; 4000b904: 10 bf ff cd b 4000b838 <_Thread_Kill_zombies+0x3c> 4000b908: f8 20 a0 04 st %i4, [ %g2 + 4 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b90c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b910: 01 00 00 00 nop } 4000b914: 81 c7 e0 08 ret 4000b918: 81 e8 00 00 restore =============================================================================== 4000a7e4 <_Thread_Load_environment>: #include void _Thread_Load_environment( Thread_Control *the_thread ) { 4000a7e4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( the_thread->Start.fp_context ) { 4000a7e8: c2 06 20 d4 ld [ %i0 + 0xd4 ], %g1 4000a7ec: 80 a0 60 00 cmp %g1, 0 4000a7f0: 32 80 00 02 bne,a 4000a7f8 <_Thread_Load_environment+0x14> 4000a7f4: c2 26 21 50 st %g1, [ %i0 + 0x150 ] the_thread->is_preemptible = the_thread->Start.is_preemptible; the_thread->budget_algorithm = the_thread->Start.budget_algorithm; the_thread->budget_callout = the_thread->Start.budget_callout; _Context_Initialize( 4000a7f8: 19 10 00 29 sethi %hi(0x4000a400), %o4 the_thread->is_preemptible = the_thread->Start.is_preemptible; 4000a7fc: c8 0e 20 ac ldub [ %i0 + 0xac ], %g4 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000a800: c6 06 20 b0 ld [ %i0 + 0xb0 ], %g3 the_thread->budget_callout = the_thread->Start.budget_callout; 4000a804: c4 06 20 b4 ld [ %i0 + 0xb4 ], %g2 _Context_Initialize( 4000a808: c2 06 20 dc ld [ %i0 + 0xdc ], %g1 the_thread->is_preemptible = the_thread->Start.is_preemptible; 4000a80c: c8 2e 20 89 stb %g4, [ %i0 + 0x89 ] _Context_Initialize( 4000a810: 98 13 20 50 or %o4, 0x50, %o4 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000a814: c6 26 20 90 st %g3, [ %i0 + 0x90 ] _Context_Initialize( 4000a818: 90 06 20 f0 add %i0, 0xf0, %o0 the_thread->budget_callout = the_thread->Start.budget_callout; 4000a81c: c4 26 20 94 st %g2, [ %i0 + 0x94 ] _Context_Initialize( 4000a820: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 4000a824: da 0e 20 8a ldub [ %i0 + 0x8a ], %o5 4000a828: d6 06 20 b8 ld [ %i0 + 0xb8 ], %o3 4000a82c: d4 06 20 cc ld [ %i0 + 0xcc ], %o2 4000a830: 7f ff e3 07 call 4000344c <_CPU_Context_Initialize> 4000a834: d2 06 20 d0 ld [ %i0 + 0xd0 ], %o1 the_thread->Start.isr_level, _Thread_Handler, the_thread->is_fp, the_thread->Start.tls_area ); } 4000a838: 81 c7 e0 08 ret 4000a83c: 81 e8 00 00 restore =============================================================================== 4001053c <_Thread_Priority_remove>: Thread_Control *the_thread, Priority_Node *priority_node, Thread_queue_Context *queue_context ) { _Thread_Priority_apply( 4001053c: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED 40010540: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED 40010544: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 40010548: 7f ff ff e2 call 400104d0 <_Thread_Priority_apply> <== NOT EXECUTED 4001054c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 4000e4c8 <_Thread_Priority_update>: replacement_node ); } void _Thread_Priority_update( Thread_queue_Context *queue_context ) { 4000e4c8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED size_t i; size_t n; n = queue_context->Priority.update_count; 4000e4cc: fa 06 20 14 ld [ %i0 + 0x14 ], %i5 <== NOT EXECUTED /* * Update the priority of all threads of the set. Do not care to clear the * set, since the thread queue context will soon get destroyed anyway. */ for ( i = 0; i < n ; ++i ) { 4000e4d0: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED 4000e4d4: 02 80 00 13 be 4000e520 <_Thread_Priority_update+0x58> <== NOT EXECUTED 4000e4d8: 39 10 00 63 sethi %hi(0x40018c00), %i4 4000e4dc: b8 17 21 c8 or %i4, 0x1c8, %i4 ! 40018dc8 <_Scheduler_Table> <== NOT EXECUTED ( *scheduler->Operations.update_priority )( 4000e4e0: f6 07 20 18 ld [ %i4 + 0x18 ], %i3 <== NOT EXECUTED 4000e4e4: bb 2f 60 02 sll %i5, 2, %i5 <== NOT EXECUTED 4000e4e8: ba 06 00 1d add %i0, %i5, %i5 <== NOT EXECUTED Thread_Control *the_thread; ISR_lock_Context lock_context; the_thread = queue_context->Priority.update[ i ]; 4000e4ec: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000e4f0: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000e4f4: c2 27 bf fc st %g1, [ %fp + -4 ] 4000e4f8: d4 02 60 38 ld [ %o1 + 0x38 ], %o2 4000e4fc: 9f c6 c0 00 call %i3 4000e500: 90 10 00 1c mov %i4, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e504: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e508: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e50c: 01 00 00 00 nop 4000e510: b0 06 20 04 add %i0, 4, %i0 for ( i = 0; i < n ; ++i ) { 4000e514: 80 a6 00 1d cmp %i0, %i5 4000e518: 32 bf ff f6 bne,a 4000e4f0 <_Thread_Priority_update+0x28> 4000e51c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 _Thread_State_acquire( the_thread, &lock_context ); _Scheduler_Update_priority( the_thread ); _Thread_State_release( the_thread, &lock_context ); } } 4000e520: 81 c7 e0 08 ret 4000e524: 81 e8 00 00 restore =============================================================================== 4000b59c <_Thread_Restart_other>: bool _Thread_Restart_other( Thread_Control *the_thread, const Thread_Entry_information *entry, ISR_lock_Context *lock_context ) { 4000b59c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Thread_Life_state previous; Per_CPU_Control *cpu_self; _Thread_State_acquire_critical( the_thread, lock_context ); if ( _States_Is_dormant( the_thread->current_state ) ) { 4000b5a0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED 4000b5a4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000b5a8: 06 80 00 4f bl 4000b6e4 <_Thread_Restart_other+0x148> <== NOT EXECUTED 4000b5ac: 01 00 00 00 nop _Thread_State_release( the_thread, lock_context ); return false; } the_thread->Start.Entry = *entry; 4000b5b0: c2 06 40 00 ld [ %i1 ], %g1 4000b5b4: c2 26 20 a0 st %g1, [ %i0 + 0xa0 ] 4000b5b8: c2 06 60 04 ld [ %i1 + 4 ], %g1 4000b5bc: c2 26 20 a4 st %g1, [ %i0 + 0xa4 ] previous = the_thread->Life.state; 4000b5c0: c2 06 21 70 ld [ %i0 + 0x170 ], %g1 the_thread->Start.Entry = *entry; 4000b5c4: c6 06 60 08 ld [ %i1 + 8 ], %g3 state |= set; 4000b5c8: 84 10 60 02 or %g1, 2, %g2 the_thread->Start.Entry = *entry; 4000b5cc: c6 26 20 a8 st %g3, [ %i0 + 0xa8 ] if ( 4000b5d0: 80 88 60 09 btst 9, %g1 4000b5d4: 02 80 00 15 be 4000b628 <_Thread_Restart_other+0x8c> <== ALWAYS TAKEN 4000b5d8: c4 26 21 70 st %g2, [ %i0 + 0x170 ] disable_level = cpu_self->thread_dispatch_disable_level; 4000b5dc: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000b5e0: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000b5e4: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000b5e8: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED _Thread_Finalize_life_change( the_thread, the_thread->Start.initial_priority ); } else { _Thread_Clear_state_locked( the_thread, STATES_SUSPENDED ); 4000b5ec: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED 4000b5f0: 40 00 0b c5 call 4000e504 <_Thread_Clear_state_locked> <== NOT EXECUTED 4000b5f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000b5f8: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b5fc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b600: 01 00 00 00 nop <== NOT EXECUTED uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000b604: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED if ( disable_level == 1 ) { 4000b608: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000b60c: 02 80 00 2a be 4000b6b4 <_Thread_Restart_other+0x118> <== NOT EXECUTED 4000b610: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED _Thread_State_release( the_thread, lock_context ); } _Thread_Dispatch_enable( cpu_self ); return true; 4000b614: b0 10 20 01 mov 1, %i0 cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000b618: c2 27 60 18 st %g1, [ %i5 + 0x18 ] 4000b61c: b0 0e 20 ff and %i0, 0xff, %i0 } 4000b620: 81 c7 e0 08 ret 4000b624: 81 e8 00 00 restore 4000b628: 7f ff fe 6d call 4000afdc <_Thread_Change_life_locked.part.37> 4000b62c: 90 10 00 18 mov %i0, %o0 disable_level = cpu_self->thread_dispatch_disable_level; 4000b630: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 pending_requests = the_thread->Life.pending_life_change_requests; 4000b634: c4 06 21 74 ld [ %i0 + 0x174 ], %g2 cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000b638: 82 00 60 01 inc %g1 4000b63c: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] the_thread->Life.pending_life_change_requests = pending_requests + 1; 4000b640: 82 00 a0 01 add %g2, 1, %g1 4000b644: c2 26 21 74 st %g1, [ %i0 + 0x174 ] if ( pending_requests == 0 ) { 4000b648: 80 a0 a0 00 cmp %g2, 0 4000b64c: 02 80 00 2d be 4000b700 <_Thread_Restart_other+0x164> <== ALWAYS TAKEN 4000b650: ba 10 00 06 mov %g6, %i5 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000b654: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b658: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b65c: 01 00 00 00 nop _Thread_Finalize_life_change( 4000b660: f4 1e 20 c0 ldd [ %i0 + 0xc0 ], %i2 _Thread_queue_Extract_with_proxy( the_thread ); 4000b664: 40 00 0b d1 call 4000e5a8 <_Thread_queue_Extract_with_proxy> 4000b668: 90 10 00 18 mov %i0, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b66c: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000b670: c2 27 bf fc st %g1, [ %fp + -4 ] 4000b674: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 4000b678: 40 00 02 58 call 4000bfd8 <_Watchdog_Remove> 4000b67c: 92 06 20 68 add %i0, 0x68, %o1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000b680: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b684: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b688: 01 00 00 00 nop _Thread_Raise_real_priority( the_thread, priority ); 4000b68c: 92 10 00 1a mov %i2, %o1 4000b690: 94 10 00 1b mov %i3, %o2 4000b694: 7f ff fe 2e call 4000af4c <_Thread_Raise_real_priority> 4000b698: 90 10 00 18 mov %i0, %o0 _Thread_Remove_life_change_request( the_thread ); 4000b69c: 7f ff fe 17 call 4000aef8 <_Thread_Remove_life_change_request> 4000b6a0: 90 10 00 18 mov %i0, %o0 uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000b6a4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 if ( disable_level == 1 ) { 4000b6a8: 80 a0 60 01 cmp %g1, 1 4000b6ac: 12 bf ff da bne 4000b614 <_Thread_Restart_other+0x78> 4000b6b0: 82 00 7f ff add %g1, -1, %g1 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b6b4: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000b6b8: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2 4000b6bc: 80 a0 a0 00 cmp %g2, 0 4000b6c0: 12 80 00 14 bne 4000b710 <_Thread_Restart_other+0x174> <== ALWAYS TAKEN 4000b6c4: 92 10 00 01 mov %g1, %o1 cpu_self->thread_dispatch_disable_level = 0; 4000b6c8: c0 27 60 18 clr [ %i5 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b6cc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b6d0: 01 00 00 00 nop return true; 4000b6d4: b0 10 20 01 mov 1, %i0 ! 1 <_TLS_Alignment> 4000b6d8: b0 0e 20 ff and %i0, 0xff, %i0 } 4000b6dc: 81 c7 e0 08 ret 4000b6e0: 81 e8 00 00 restore register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000b6e4: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b6e8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b6ec: 01 00 00 00 nop return false; 4000b6f0: b0 10 20 00 clr %i0 ! 0 4000b6f4: b0 0e 20 ff and %i0, 0xff, %i0 } 4000b6f8: 81 c7 e0 08 ret 4000b6fc: 81 e8 00 00 restore _Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING ); 4000b700: 13 00 00 80 sethi %hi(0x20000), %o1 4000b704: 40 00 00 5f call 4000b880 <_Thread_Set_state_locked> 4000b708: 90 10 00 18 mov %i0, %o0 4000b70c: 30 bf ff d2 b,a 4000b654 <_Thread_Restart_other+0xb8> _Thread_Do_dispatch( cpu_self, level ); 4000b710: c2 27 bf fc st %g1, [ %fp + -4 ] 4000b714: 7f ff f9 32 call 40009bdc <_Thread_Do_dispatch> 4000b718: 90 10 00 1d mov %i5, %o0 4000b71c: 10 bf ff ec b 4000b6cc <_Thread_Restart_other+0x130> 4000b720: c2 07 bf fc ld [ %fp + -4 ], %g1 =============================================================================== 4000b724 <_Thread_Restart_self>: void _Thread_Restart_self( Thread_Control *executing, const Thread_Entry_information *entry, ISR_lock_Context *lock_context ) { 4000b724: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_clear_priority_updates( &queue_context ); _Thread_State_acquire_critical( executing, lock_context ); executing->Start.Entry = *entry; 4000b728: c2 06 40 00 ld [ %i1 ], %g1 <== NOT EXECUTED 4000b72c: c2 26 20 a0 st %g1, [ %i0 + 0xa0 ] <== NOT EXECUTED 4000b730: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000b734: c2 06 60 04 ld [ %i1 + 4 ], %g1 <== NOT EXECUTED 4000b738: c2 26 20 a4 st %g1, [ %i0 + 0xa4 ] <== NOT EXECUTED state |= set; 4000b73c: c2 06 21 70 ld [ %i0 + 0x170 ], %g1 <== NOT EXECUTED executing->Start.Entry = *entry; 4000b740: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED state |= set; 4000b744: 82 10 60 02 or %g1, 2, %g1 <== NOT EXECUTED executing->Start.Entry = *entry; 4000b748: c4 26 20 a8 st %g2, [ %i0 + 0xa8 ] <== NOT EXECUTED the_thread->Life.state = state; 4000b74c: c2 26 21 70 st %g1, [ %i0 + 0x170 ] <== NOT EXECUTED 4000b750: 7f ff fe 23 call 4000afdc <_Thread_Change_life_locked.part.37> <== NOT EXECUTED 4000b754: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 4000b758: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000b75c: 82 00 60 01 inc %g1 <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000b760: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000b764: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000b768: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b76c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b770: 01 00 00 00 nop <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b774: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( lock_context ); 4000b778: c2 26 80 00 st %g1, [ %i2 ] 4000b77c: c4 1e 20 c0 ldd [ %i0 + 0xc0 ], %g2 4000b780: c4 3e 20 30 std %g2, [ %i0 + 0x30 ] _Thread_Priority_changed( 4000b784: 94 10 20 00 clr %o2 4000b788: 96 07 bf dc add %fp, -36, %o3 4000b78c: 92 06 20 20 add %i0, 0x20, %o1 4000b790: 7f ff f8 b0 call 40009a50 <_Thread_Priority_changed> 4000b794: 90 10 00 18 mov %i0, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000b798: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b79c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b7a0: 01 00 00 00 nop false, &queue_context ); _Thread_Wait_release_default( executing, lock_context ); _Thread_Priority_update( &queue_context ); 4000b7a4: 7f ff f8 b2 call 40009a6c <_Thread_Priority_update> 4000b7a8: 90 07 bf dc add %fp, -36, %o0 _Thread_Dispatch_direct( cpu_self ); 4000b7ac: 7f ff f9 54 call 40009cfc <_Thread_Dispatch_direct> 4000b7b0: 90 10 00 1d mov %i5, %o0 4000b7b4: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 4000b9cc <_Thread_Set_life_protection>: Thread_Life_state _Thread_Set_life_protection( Thread_Life_state state ) { return _Thread_Change_life( 4000b9cc: 92 0a 20 01 and %o0, 1, %o1 <== NOT EXECUTED 4000b9d0: 94 10 20 00 clr %o2 4000b9d4: 90 10 20 01 mov 1, %o0 4000b9d8: 82 13 c0 00 mov %o7, %g1 4000b9dc: 7f ff ff d0 call 4000b91c <_Thread_Change_life> 4000b9e0: 9e 10 40 00 mov %g1, %o7 =============================================================================== 4000a030 <_Thread_Set_name>: Status_Control _Thread_Set_name( Thread_Control *the_thread, const char *name ) { 4000a030: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED size_t length; length = strlcpy( 4000a034: 03 10 00 3e sethi %hi(0x4000f800), %g1 <== NOT EXECUTED 4000a038: d0 06 20 18 ld [ %i0 + 0x18 ], %o0 <== NOT EXECUTED 4000a03c: fa 00 61 c0 ld [ %g1 + 0x1c0 ], %i5 <== NOT EXECUTED 4000a040: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000a044: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 4000a048: 40 00 12 33 call 4000e914 <== NOT EXECUTED 4000a04c: 33 00 00 08 sethi %hi(0x2000), %i1 <== NOT EXECUTED name, _Thread_Maximum_name_size ); if ( length >= _Thread_Maximum_name_size ) { return STATUS_RESULT_TOO_LARGE; 4000a050: b0 10 20 00 clr %i0 if ( length >= _Thread_Maximum_name_size ) { 4000a054: 80 a7 40 08 cmp %i5, %o0 4000a058: 08 80 00 04 bleu 4000a068 <_Thread_Set_name+0x38> 4000a05c: b2 16 62 0d or %i1, 0x20d, %i1 } return STATUS_SUCCESSFUL; 4000a060: b0 10 20 00 clr %i0 4000a064: b2 10 20 00 clr %i1 } 4000a068: 81 c7 e0 08 ret 4000a06c: 81 e8 00 00 restore =============================================================================== 4000ba1c <_Thread_Set_state>: States_Control _Thread_Set_state( Thread_Control *the_thread, States_Control state ) { 4000ba1c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED 4000ba20: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000ba24: 91 d0 20 09 ta 9 <== NOT EXECUTED previous_state = the_thread->current_state; 4000ba28: f0 06 20 1c ld [ %i0 + 0x1c ], %i0 4000ba2c: b2 16 40 18 or %i1, %i0, %i1 if ( _States_Is_ready( previous_state ) ) { 4000ba30: 80 a6 20 00 cmp %i0, 0 4000ba34: 12 80 00 09 bne 4000ba58 <_Thread_Set_state+0x3c> 4000ba38: f2 22 60 1c st %i1, [ %o1 + 0x1c ] 4000ba3c: d4 02 60 38 ld [ %o1 + 0x38 ], %o2 4000ba40: 11 10 00 63 sethi %hi(0x40018c00), %o0 4000ba44: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 40018dc8 <_Scheduler_Table> 4000ba48: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 4000ba4c: 9f c0 80 00 call %g2 4000ba50: c2 27 bf fc st %g1, [ %fp + -4 ] 4000ba54: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000ba58: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ba5c: 01 00 00 00 nop _Thread_State_acquire( the_thread, &lock_context ); previous_state = _Thread_Set_state_locked( the_thread, state ); _Thread_State_release( the_thread, &lock_context ); return previous_state; } 4000ba60: 81 c7 e0 08 ret 4000ba64: 81 e8 00 00 restore =============================================================================== 4000b9e4 <_Thread_Set_state_locked>: States_Control _Thread_Set_state_locked( Thread_Control *the_thread, States_Control state ) { 4000b9e4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 4000b9e8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED States_Control next_state; _Assert( state != 0 ); _Assert( _Thread_State_is_owner( the_thread ) ); previous_state = the_thread->current_state; 4000b9ec: f0 06 20 1c ld [ %i0 + 0x1c ], %i0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE States_Control _States_Set ( States_Control states_to_set, States_Control current_state ) { return (current_state | states_to_set); 4000b9f0: b2 16 00 19 or %i0, %i1, %i1 <== NOT EXECUTED next_state = _States_Set( state, previous_state); the_thread->current_state = next_state; if ( _States_Is_ready( previous_state ) ) { 4000b9f4: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 4000b9f8: 12 80 00 07 bne 4000ba14 <_Thread_Set_state_locked+0x30> <== NOT EXECUTED 4000b9fc: f2 22 60 1c st %i1, [ %o1 + 0x1c ] <== NOT EXECUTED ( *scheduler->Operations.block )( 4000ba00: 11 10 00 63 sethi %hi(0x40018c00), %o0 <== NOT EXECUTED 4000ba04: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 40018dc8 <_Scheduler_Table> <== NOT EXECUTED 4000ba08: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 <== NOT EXECUTED 4000ba0c: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000ba10: d4 02 60 38 ld [ %o1 + 0x38 ], %o2 <== NOT EXECUTED _Scheduler_Block( the_thread ); } return previous_state; } 4000ba14: 81 c7 e0 08 ret <== NOT EXECUTED 4000ba18: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000ba68 <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 4000ba68: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED return rtems_minimum_stack_size; 4000ba6c: 03 10 00 6c sethi %hi(0x4001b000), %g1 <== NOT EXECUTED 4000ba70: fa 00 63 40 ld [ %g1 + 0x340 ], %i5 ! 4001b340 <_data_load_start> <== NOT EXECUTED 4000ba74: 80 a7 40 19 cmp %i5, %i1 <== NOT EXECUTED 4000ba78: 2a 80 00 02 bcs,a 4000ba80 <_Thread_Stack_Allocate+0x18> <== NOT EXECUTED 4000ba7c: ba 10 00 19 mov %i1, %i5 <== NOT EXECUTED void *stack_addr = 0; size_t the_stack_size; rtems_stack_allocate_hook stack_allocate_hook = 4000ba80: 03 10 00 63 sethi %hi(0x40018c00), %g1 rtems_configuration_get_stack_allocate_hook(); the_stack_size = _Stack_Ensure_minimum( stack_size ); stack_addr = (*stack_allocate_hook)( the_stack_size ); 4000ba84: c2 00 61 10 ld [ %g1 + 0x110 ], %g1 ! 40018d10 4000ba88: 9f c0 40 00 call %g1 4000ba8c: 90 10 00 1d mov %i5, %o0 if ( !stack_addr ) the_stack_size = 0; 4000ba90: 80 a0 00 08 cmp %g0, %o0 the_thread->Start.stack = stack_addr; 4000ba94: d0 26 20 d8 st %o0, [ %i0 + 0xd8 ] the_stack_size = 0; 4000ba98: b0 60 20 00 subx %g0, 0, %i0 return the_stack_size; } 4000ba9c: b0 0f 40 18 and %i5, %i0, %i0 4000baa0: 81 c7 e0 08 ret 4000baa4: 81 e8 00 00 restore =============================================================================== 4000baa8 <_Thread_Stack_Free>: #include void _Thread_Stack_Free( Thread_Control *the_thread ) { 4000baa8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED #if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) /* * If the API provided the stack space, then don't free it. */ if ( !the_thread->Start.core_allocated_stack ) 4000baac: c2 0e 20 c8 ldub [ %i0 + 0xc8 ], %g1 <== NOT EXECUTED 4000bab0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED rtems_stack_free_hook stack_free_hook = 4000bab4: 03 10 00 63 sethi %hi(0x40018c00), %g1 <== NOT EXECUTED if ( !the_thread->Start.core_allocated_stack ) 4000bab8: 02 80 00 04 be 4000bac8 <_Thread_Stack_Free+0x20> <== NOT EXECUTED 4000babc: c2 00 61 14 ld [ %g1 + 0x114 ], %g1 ! 40018d14 * Call ONLY the CPU table stack free hook, or the * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ (*stack_free_hook)( the_thread->Start.Initial_stack.area ); 4000bac0: 9f c0 40 00 call %g1 4000bac4: d0 06 20 d0 ld [ %i0 + 0xd0 ], %o0 } 4000bac8: 81 c7 e0 08 ret 4000bacc: 81 e8 00 00 restore =============================================================================== 4000baec <_Thread_Start>: bool _Thread_Start( Thread_Control *the_thread, const Thread_Entry_information *entry, ISR_lock_Context *lock_context ) { 4000baec: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Per_CPU_Control *cpu_self; _Thread_State_acquire_critical( the_thread, lock_context ); if ( !_States_Is_dormant( the_thread->current_state ) ) { 4000baf0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 4000baf4: 80 a0 60 00 cmp %g1, 0 4000baf8: 26 80 00 09 bl,a 4000bb1c <_Thread_Start+0x30> <== ALWAYS TAKEN 4000bafc: c2 06 40 00 ld [ %i1 ], %g1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000bb00: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000bb04: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000bb08: 01 00 00 00 nop _Thread_State_release( the_thread, lock_context ); return false; 4000bb0c: b0 10 20 00 clr %i0 ! 0 _User_extensions_Thread_start( the_thread ); _Thread_Dispatch_enable( cpu_self ); return true; } 4000bb10: b0 0e 20 01 and %i0, 1, %i0 4000bb14: 81 c7 e0 08 ret 4000bb18: 81 e8 00 00 restore the_thread->Start.Entry = *entry; 4000bb1c: c2 26 20 a0 st %g1, [ %i0 + 0xa0 ] _Thread_Load_environment( the_thread ); 4000bb20: 90 10 00 18 mov %i0, %o0 the_thread->Start.Entry = *entry; 4000bb24: c2 06 60 04 ld [ %i1 + 4 ], %g1 4000bb28: c2 26 20 a4 st %g1, [ %i0 + 0xa4 ] 4000bb2c: c2 06 60 08 ld [ %i1 + 8 ], %g1 _Thread_Load_environment( the_thread ); 4000bb30: 7f ff fb 2d call 4000a7e4 <_Thread_Load_environment> 4000bb34: c2 26 20 a8 st %g1, [ %i0 + 0xa8 ] _Thread_Clear_state_locked( the_thread, STATES_ALL_SET ); 4000bb38: 92 10 3f ff mov -1, %o1 4000bb3c: 40 00 0a 84 call 4000e54c <_Thread_Clear_state_locked> 4000bb40: 90 10 00 18 mov %i0, %o0 disable_level = cpu_self->thread_dispatch_disable_level; 4000bb44: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000bb48: 82 00 60 01 inc %g1 return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000bb4c: ba 10 00 06 mov %g6, %i5 cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000bb50: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000bb54: c2 06 80 00 ld [ %i2 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000bb58: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000bb5c: 01 00 00 00 nop _User_extensions_Iterate( 4000bb60: 94 10 20 00 clr %o2 ! 0 4000bb64: 90 10 00 18 mov %i0, %o0 4000bb68: 13 10 00 2f sethi %hi(0x4000bc00), %o1 4000bb6c: 40 00 00 99 call 4000bdd0 <_User_extensions_Iterate> 4000bb70: 92 12 60 f0 or %o1, 0xf0, %o1 ! 4000bcf0 <_User_extensions_Thread_start_visitor> uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000bb74: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 if ( disable_level == 1 ) { 4000bb78: 80 a0 60 01 cmp %g1, 1 4000bb7c: 02 80 00 07 be 4000bb98 <_Thread_Start+0xac> 4000bb80: 82 00 7f ff add %g1, -1, %g1 return true; 4000bb84: b0 10 20 01 mov 1, %i0 cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000bb88: c2 27 60 18 st %g1, [ %i5 + 0x18 ] } 4000bb8c: b0 0e 20 01 and %i0, 1, %i0 4000bb90: 81 c7 e0 08 ret 4000bb94: 81 e8 00 00 restore __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000bb98: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000bb9c: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2 4000bba0: 80 a0 a0 00 cmp %g2, 0 4000bba4: 12 80 00 07 bne 4000bbc0 <_Thread_Start+0xd4> 4000bba8: 92 10 00 01 mov %g1, %o1 cpu_self->thread_dispatch_disable_level = 0; 4000bbac: c0 27 60 18 clr [ %i5 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000bbb0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000bbb4: 01 00 00 00 nop return true; 4000bbb8: 10 bf ff d6 b 4000bb10 <_Thread_Start+0x24> 4000bbbc: b0 10 20 01 mov 1, %i0 ! 1 <_TLS_Alignment> _Thread_Do_dispatch( cpu_self, level ); 4000bbc0: c2 27 bf fc st %g1, [ %fp + -4 ] 4000bbc4: 40 00 0a 84 call 4000e5d4 <_Thread_Do_dispatch> 4000bbc8: 90 10 00 1d mov %i5, %o0 4000bbcc: 10 bf ff f9 b 4000bbb0 <_Thread_Start+0xc4> 4000bbd0: c2 07 bf fc ld [ %fp + -4 ], %g1 =============================================================================== 4000bad0 <_Thread_Start_multitasking>: #include #include void _Thread_Start_multitasking( void ) { 4000bad0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED heir = cpu_self->heir; 4000bad4: c4 01 a0 24 ld [ %g6 + 0x24 ], %g2 <== NOT EXECUTED cpu_self->dispatch_necessary = false; 4000bad8: c0 29 a0 1c clrb [ %g6 + 0x1c ] <== NOT EXECUTED _CPU_Context_Set_is_executing( &trash, true ); _CPU_Context_switch( &trash, &heir->Registers ); RTEMS_UNREACHABLE(); } #else _CPU_Context_Restart_self( &heir->Registers ); 4000badc: 90 00 a0 f0 add %g2, 0xf0, %o0 4000bae0: 40 00 03 91 call 4000c924 <_CPU_Context_restore> 4000bae4: c4 21 a0 20 st %g2, [ %g6 + 0x20 ] 4000bae8: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 4000ef24 <_Thread_Timeout>: the_thread = RTEMS_CONTAINER_OF( the_watchdog, Thread_Control, Timer.Watchdog ); _Thread_Continue( the_thread, STATUS_TIMEOUT ); 4000ef24: 15 00 00 1d sethi %hi(0x7400), %o2 <== NOT EXECUTED 4000ef28: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000ef2c: 94 12 a0 06 or %o2, 6, %o2 <== NOT EXECUTED 4000ef30: 90 02 3f 98 add %o0, -104, %o0 <== NOT EXECUTED 4000ef34: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4000ef38: 7f ff ff ce call 4000ee70 <_Thread_Continue> 4000ef3c: 9e 10 40 00 mov %g1, %o7 =============================================================================== 4000ce84 <_Thread_Wait_get_id>: if ( _States_Is_waiting_for_rpc_reply( the_thread->current_state ) ) { return the_thread->Wait.remote_id; } #endif queue = the_thread->Wait.queue; 4000ce84: c2 02 20 54 ld [ %o0 + 0x54 ], %g1 <== NOT EXECUTED if ( queue != NULL && queue->name == _Thread_queue_Object_name ) { 4000ce88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000ce8c: 02 80 00 08 be 4000ceac <_Thread_Wait_get_id+0x28> <== NOT EXECUTED 4000ce90: 90 10 20 00 clr %o0 4000ce94: c6 00 60 08 ld [ %g1 + 8 ], %g3 4000ce98: 05 10 00 44 sethi %hi(0x40011000), %g2 4000ce9c: 84 10 a2 80 or %g2, 0x280, %g2 ! 40011280 <_Thread_queue_Object_name> 4000cea0: 80 a0 c0 02 cmp %g3, %g2 4000cea4: 02 80 00 04 be 4000ceb4 <_Thread_Wait_get_id+0x30> <== ALWAYS TAKEN 4000cea8: 01 00 00 00 nop queue_object = THREAD_QUEUE_QUEUE_TO_OBJECT( queue ); return queue_object->Object.id; } return 0; } 4000ceac: 81 c3 e0 08 retl 4000ceb0: 01 00 00 00 nop 4000ceb4: 81 c3 e0 08 retl 4000ceb8: d0 00 7f f8 ld [ %g1 + -8 ], %o0 =============================================================================== 4000bbd4 <_Thread_Yield>: #include #include void _Thread_Yield( Thread_Control *executing ) { 4000bbd4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000bbd8: 91 d0 20 09 ta 9 <== NOT EXECUTED ISR_lock_Context lock_context; _Thread_State_acquire( executing, &lock_context ); if ( _States_Is_ready( executing->current_state ) ) { 4000bbdc: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 4000bbe0: 80 a0 a0 00 cmp %g2, 0 4000bbe4: 12 80 00 09 bne 4000bc08 <_Thread_Yield+0x34> <== NEVER TAKEN 4000bbe8: 11 10 00 63 sethi %hi(0x40018c00), %o0 ( *scheduler->Operations.yield )( 4000bbec: d4 06 20 38 ld [ %i0 + 0x38 ], %o2 4000bbf0: 90 12 21 c8 or %o0, 0x1c8, %o0 4000bbf4: c4 02 20 0c ld [ %o0 + 0xc ], %g2 4000bbf8: c2 27 bf fc st %g1, [ %fp + -4 ] 4000bbfc: 9f c0 80 00 call %g2 4000bc00: 92 10 00 18 mov %i0, %o1 4000bc04: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000bc08: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000bc0c: 01 00 00 00 nop _Scheduler_Yield( executing ); } _Thread_State_release( executing, &lock_context ); } 4000bc10: 81 c7 e0 08 ret 4000bc14: 81 e8 00 00 restore =============================================================================== 40011dec <_Thread_queue_Add_timeout_ticks>: Thread_queue_Queue *queue, Thread_Control *the_thread, Per_CPU_Control *cpu_self, Thread_queue_Context *queue_context ) { 40011dec: 9d e3 bf 98 save %sp, -104, %sp Watchdog_Interval ticks; ticks = queue_context->Timeout.ticks; 40011df0: c4 06 e0 0c ld [ %i3 + 0xc ], %g2 if ( ticks != WATCHDOG_NO_TIMEOUT ) { 40011df4: 80 a0 a0 00 cmp %g2, 0 40011df8: 12 80 00 04 bne 40011e08 <_Thread_queue_Add_timeout_ticks+0x1c> 40011dfc: 01 00 00 00 nop the_thread, cpu_self, queue_context->Timeout.ticks ); } } 40011e00: 81 c7 e0 08 ret 40011e04: 81 e8 00 00 restore __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40011e08: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 40011e0c: c2 27 bf fc st %g1, [ %fp + -4 ] the_thread->Timer.Watchdog.routine = _Thread_Timeout; 40011e10: 07 10 00 4a sethi %hi(0x40012800), %g3 expire = ticks + cpu->Watchdog.ticks; 40011e14: d4 1e a0 30 ldd [ %i2 + 0x30 ], %o2 &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ]; 40011e18: 90 06 a0 38 add %i2, 0x38, %o0 the_thread->Timer.Watchdog.routine = _Thread_Timeout; 40011e1c: 86 10 e0 70 or %g3, 0x70, %g3 the_thread->Timer.header = 40011e20: d0 26 60 60 st %o0, [ %i1 + 0x60 ] _Watchdog_Insert(header, the_watchdog, expire); 40011e24: b6 82 c0 02 addcc %o3, %g2, %i3 the_thread->Timer.Watchdog.routine = _Thread_Timeout; 40011e28: c6 26 60 78 st %g3, [ %i1 + 0x78 ] 40011e2c: b4 42 a0 00 addx %o2, 0, %i2 40011e30: 92 06 60 68 add %i1, 0x68, %o1 40011e34: 94 10 00 1a mov %i2, %o2 40011e38: 40 00 03 93 call 40012c84 <_Watchdog_Insert> 40011e3c: 96 10 00 1b mov %i3, %o3 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40011e40: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40011e44: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40011e48: 01 00 00 00 nop 40011e4c: 81 c7 e0 08 ret 40011e50: 81 e8 00 00 restore =============================================================================== 4000a9a4 <_Thread_queue_Deadlock_fatal>: { 4000a9a4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED _Internal_error( INTERNAL_ERROR_THREAD_QUEUE_DEADLOCK ); 4000a9a8: 7f ff f3 bf call 400078a4 <_Internal_error> <== NOT EXECUTED 4000a9ac: 90 10 20 1c mov 0x1c, %o0 <== NOT EXECUTED 4000a9b0: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40010eb8 <_Thread_queue_Deadlock_status>: the_thread->Wait.return_code = STATUS_DEADLOCK; 40010eb8: 03 00 00 0b sethi %hi(0x2c00), %g1 <== NOT EXECUTED 40010ebc: 82 10 61 0e or %g1, 0x10e, %g1 ! 2d0e <_Configuration_Interrupt_stack_size+0x1d0e> <== NOT EXECUTED } 40010ec0: 81 c3 e0 08 retl <== NOT EXECUTED 40010ec4: c2 22 20 4c st %g1, [ %o0 + 0x4c ] =============================================================================== 4000a9b4 <_Thread_queue_Enqueue>: { 4000a9b4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED the_thread->Wait.queue = queue; 4000a9b8: f0 26 a0 54 st %i0, [ %i2 + 0x54 ] <== NOT EXECUTED 4000a9bc: 10 80 00 08 b 4000a9dc <_Thread_queue_Enqueue+0x28> <== NOT EXECUTED 4000a9c0: 82 10 00 18 mov %i0, %g1 <== NOT EXECUTED if ( owner == the_thread ) { 4000a9c4: 22 80 00 44 be,a 4000aad4 <_Thread_queue_Enqueue+0x120> 4000a9c8: c0 26 a0 54 clr [ %i2 + 0x54 ] queue = owner->Wait.queue; 4000a9cc: c2 00 60 54 ld [ %g1 + 0x54 ], %g1 } while ( queue != NULL ); 4000a9d0: 80 a0 60 00 cmp %g1, 0 4000a9d4: 22 80 00 07 be,a 4000a9f0 <_Thread_queue_Enqueue+0x3c> 4000a9d8: c0 26 e0 14 clr [ %i3 + 0x14 ] owner = queue->owner; 4000a9dc: c2 00 60 04 ld [ %g1 + 4 ], %g1 if ( owner == NULL ) { 4000a9e0: 80 a0 60 00 cmp %g1, 0 4000a9e4: 12 bf ff f8 bne 4000a9c4 <_Thread_queue_Enqueue+0x10> 4000a9e8: 80 a6 80 01 cmp %i2, %g1 RTEMS_INLINE_ROUTINE void _Thread_queue_Context_clear_priority_updates( Thread_queue_Context *queue_context ) { queue_context->Priority.update_count = 0; 4000a9ec: c0 26 e0 14 clr [ %i3 + 0x14 ] ( *operations->enqueue )( queue, the_thread, queue_context ); 4000a9f0: 94 10 00 1b mov %i3, %o2 the_thread->Wait.operations = operations; 4000a9f4: f2 26 a0 58 st %i1, [ %i2 + 0x58 ] 4000a9f8: 92 10 00 1a mov %i2, %o1 4000a9fc: c2 06 60 04 ld [ %i1 + 4 ], %g1 4000aa00: 9f c0 40 00 call %g1 4000aa04: 90 10 00 18 mov %i0, %o0 the_thread->Wait.flags = flags; 4000aa08: 84 10 24 01 mov 0x401, %g2 disable_level = cpu_self->thread_dispatch_disable_level; 4000aa0c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 the_thread->Wait.return_code = STATUS_SUCCESSFUL; 4000aa10: c0 26 a0 4c clr [ %i2 + 0x4c ] cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000aa14: 82 00 60 01 inc %g1 4000aa18: c4 26 a0 50 st %g2, [ %i2 + 0x50 ] return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000aa1c: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000aa20: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000aa24: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000aa28: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000aa2c: 01 00 00 00 nop ( *queue_context->enqueue_callout )( 4000aa30: c2 06 e0 08 ld [ %i3 + 8 ], %g1 4000aa34: 96 10 00 1b mov %i3, %o3 4000aa38: 94 10 00 06 mov %g6, %o2 4000aa3c: 92 10 00 1a mov %i2, %o1 4000aa40: 9f c0 40 00 call %g1 4000aa44: 90 10 00 18 mov %i0, %o0 _Thread_Set_state( the_thread, queue_context->thread_state ); 4000aa48: d2 06 e0 04 ld [ %i3 + 4 ], %o1 4000aa4c: 40 00 03 f4 call 4000ba1c <_Thread_Set_state> 4000aa50: 90 10 00 1a mov %i2, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000aa54: 91 d0 20 09 ta 9 <== NOT EXECUTED bool success = ( the_thread->Wait.flags == expected_flags ); 4000aa58: c4 06 a0 50 ld [ %i2 + 0x50 ], %g2 if ( success ) { 4000aa5c: 80 a0 a4 01 cmp %g2, 0x401 4000aa60: 02 80 00 28 be 4000ab00 <_Thread_queue_Enqueue+0x14c> 4000aa64: 86 10 24 02 mov 0x402, %g3 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000aa68: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000aa6c: 01 00 00 00 nop if ( !success ) { 4000aa70: 80 a0 a4 01 cmp %g2, 0x401 4000aa74: 12 80 00 07 bne 4000aa90 <_Thread_queue_Enqueue+0xdc> <== ALWAYS TAKEN 4000aa78: 01 00 00 00 nop _Thread_Priority_update( queue_context ); 4000aa7c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 4000aa80: 40 00 0e 92 call 4000e4c8 <_Thread_Priority_update> 4000aa84: b0 10 00 1d mov %i5, %i0 _Thread_Dispatch_direct( cpu_self ); 4000aa88: 40 00 0f 1b call 4000e6f4 <_Thread_Dispatch_direct> 4000aa8c: 81 e8 00 00 restore __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000aa90: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000aa94: c2 27 bf fc st %g1, [ %fp + -4 ] 4000aa98: d0 06 a0 60 ld [ %i2 + 0x60 ], %o0 4000aa9c: 40 00 05 4c call 4000bfcc <_Watchdog_Remove> 4000aaa0: 92 06 a0 68 add %i2, 0x68, %o1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000aaa4: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000aaa8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000aaac: 01 00 00 00 nop _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000aab0: 13 0c 00 57 sethi %hi(0x30015c00), %o1 4000aab4: 90 10 00 1a mov %i2, %o0 4000aab8: 40 00 0e b1 call 4000e57c <_Thread_Clear_state> 4000aabc: 92 12 63 ff or %o1, 0x3ff, %o1 _Thread_Priority_update( queue_context ); 4000aac0: 90 10 00 1b mov %i3, %o0 4000aac4: 40 00 0e 81 call 4000e4c8 <_Thread_Priority_update> 4000aac8: b0 10 00 1d mov %i5, %i0 _Thread_Dispatch_direct( cpu_self ); 4000aacc: 40 00 0f 0a call 4000e6f4 <_Thread_Dispatch_direct> 4000aad0: 81 e8 00 00 restore the_thread->Wait.operations = &_Thread_queue_Operations_default; 4000aad4: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 4000aad8: 82 10 61 50 or %g1, 0x150, %g1 ! 40019950 <_Thread_queue_Operations_default> <== NOT EXECUTED 4000aadc: c2 26 a0 58 st %g1, [ %i2 + 0x58 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000aae0: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000aae4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000aae8: 01 00 00 00 nop ( *queue_context->deadlock_callout )( the_thread ); 4000aaec: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1 4000aaf0: 9f c0 40 00 call %g1 4000aaf4: 90 10 00 1a mov %i2, %o0 } 4000aaf8: 81 c7 e0 08 ret 4000aafc: 81 e8 00 00 restore the_thread->Wait.flags = desired_flags; 4000ab00: c6 26 a0 50 st %g3, [ %i2 + 0x50 ] <== NOT EXECUTED 4000ab04: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ab08: 01 00 00 00 nop if ( !success ) { 4000ab0c: 80 a0 a4 01 cmp %g2, 0x401 4000ab10: 22 bf ff dc be,a 4000aa80 <_Thread_queue_Enqueue+0xcc> <== ALWAYS TAKEN 4000ab14: 90 10 00 1b mov %i3, %o0 4000ab18: 30 bf ff de b,a 4000aa90 <_Thread_queue_Enqueue+0xdc> <== NOT EXECUTED =============================================================================== 4000ab8c <_Thread_queue_Extract>: &queue_context->Lock_context.Lock_context ); } void _Thread_queue_Extract( Thread_Control *the_thread ) { 4000ab8c: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED 4000ab90: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000ab94: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 4000ab98: c2 27 bf dc st %g1, [ %fp + -36 ] _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_clear_priority_updates( &queue_context ); _Thread_Wait_acquire( the_thread, &queue_context ); queue = the_thread->Wait.queue; 4000ab9c: d0 06 20 54 ld [ %i0 + 0x54 ], %o0 if ( queue != NULL ) { 4000aba0: 80 a2 20 00 cmp %o0, 0 4000aba4: 02 80 00 1c be 4000ac14 <_Thread_queue_Extract+0x88> 4000aba8: 92 10 00 18 mov %i0, %o1 ( *operations->extract )( queue, the_thread, queue_context ); 4000abac: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 4000abb0: c2 00 60 08 ld [ %g1 + 8 ], %g1 4000abb4: 9f c0 40 00 call %g1 4000abb8: 94 07 bf dc add %fp, -36, %o2 if ( success ) { 4000abbc: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 4000abc0: 80 a0 64 01 cmp %g1, 0x401 the_thread->Wait.queue = NULL; 4000abc4: c0 26 20 54 clr [ %i0 + 0x54 ] the_thread->Wait.flags = desired_flags; 4000abc8: 82 10 24 04 mov 0x404, %g1 if ( success ) { 4000abcc: 02 80 00 0a be 4000abf4 <_Thread_queue_Extract+0x68> <== NEVER TAKEN 4000abd0: c2 26 20 50 st %g1, [ %i0 + 0x50 ] the_thread->Wait.operations = &_Thread_queue_Operations_default; 4000abd4: 03 10 00 66 sethi %hi(0x40019800), %g1 4000abd8: 82 10 61 50 or %g1, 0x150, %g1 ! 40019950 <_Thread_queue_Operations_default> 4000abdc: c2 26 20 58 st %g1, [ %i0 + 0x58 ] 4000abe0: 92 07 bf dc add %fp, -36, %o1 4000abe4: 7f ff ff 44 call 4000a8f4 <_Thread_queue_Unblock_critical.part.33> 4000abe8: 90 10 00 18 mov %i0, %o0 &queue_context.Lock_context.Lock_context ); } else { _Thread_Wait_release( the_thread, &queue_context ); } } 4000abec: 81 c7 e0 08 ret 4000abf0: 81 e8 00 00 restore 4000abf4: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 4000abf8: 82 10 61 50 or %g1, 0x150, %g1 ! 40019950 <_Thread_queue_Operations_default> <== NOT EXECUTED 4000abfc: c2 26 20 58 st %g1, [ %i0 + 0x58 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000ac00: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000ac04: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ac08: 01 00 00 00 nop <== NOT EXECUTED 4000ac0c: 81 c7 e0 08 ret <== NOT EXECUTED 4000ac10: 81 e8 00 00 restore <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000ac14: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000ac18: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ac1c: 01 00 00 00 nop 4000ac20: 81 c7 e0 08 ret 4000ac24: 81 e8 00 00 restore =============================================================================== 400110b0 <_Thread_queue_Extract_critical>: Thread_queue_Queue *queue, const Thread_queue_Operations *operations, Thread_Control *the_thread, Thread_queue_Context *queue_context ) { 400110b0: 9d e3 bf a0 save %sp, -96, %sp ( *operations->extract )( queue, the_thread, queue_context ); 400110b4: c2 06 60 08 ld [ %i1 + 8 ], %g1 400110b8: 92 10 00 1a mov %i2, %o1 400110bc: 94 10 00 1b mov %i3, %o2 400110c0: 9f c0 40 00 call %g1 400110c4: 90 10 00 18 mov %i0, %o0 if ( success ) { 400110c8: c2 06 a0 50 ld [ %i2 + 0x50 ], %g1 400110cc: 80 a0 64 01 cmp %g1, 0x401 the_thread->Wait.queue = NULL; 400110d0: c0 26 a0 54 clr [ %i2 + 0x54 ] the_thread->Wait.flags = desired_flags; 400110d4: 82 10 24 04 mov 0x404, %g1 if ( success ) { 400110d8: 02 80 00 08 be 400110f8 <_Thread_queue_Extract_critical+0x48> 400110dc: c2 26 a0 50 st %g1, [ %i2 + 0x50 ] the_thread->Wait.operations = &_Thread_queue_Operations_default; 400110e0: 03 10 00 77 sethi %hi(0x4001dc00), %g1 400110e4: 82 10 63 08 or %g1, 0x308, %g1 ! 4001df08 <_Thread_queue_Operations_default> 400110e8: c2 26 a0 58 st %g1, [ %i2 + 0x58 ] 400110ec: b2 10 00 1b mov %i3, %i1 400110f0: 7f ff ff 46 call 40010e08 <_Thread_queue_Unblock_critical.part.33> 400110f4: 91 e8 00 1a restore %g0, %i2, %o0 400110f8: 03 10 00 77 sethi %hi(0x4001dc00), %g1 <== NOT EXECUTED 400110fc: 82 10 63 08 or %g1, 0x308, %g1 ! 4001df08 <_Thread_queue_Operations_default> <== NOT EXECUTED 40011100: c2 26 a0 58 st %g1, [ %i2 + 0x58 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40011104: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40011108: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4001110c: 01 00 00 00 nop unblock, queue, the_thread, &queue_context->Lock_context.Lock_context ); } 40011110: 81 c7 e0 08 ret 40011114: 81 e8 00 00 restore =============================================================================== 4000ab1c <_Thread_queue_Extract_locked>: { 4000ab1c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED ( *operations->extract )( queue, the_thread, queue_context ); 4000ab20: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED 4000ab24: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 4000ab28: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4000ab2c: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000ab30: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( success ) { 4000ab34: c2 06 a0 50 ld [ %i2 + 0x50 ], %g1 <== NOT EXECUTED 4000ab38: 80 a0 64 01 cmp %g1, 0x401 <== NOT EXECUTED 4000ab3c: 02 80 00 0b be 4000ab68 <_Thread_queue_Extract_locked+0x4c> <== NOT EXECUTED 4000ab40: 82 10 24 04 mov 0x404, %g1 <== NOT EXECUTED unblock = true; 4000ab44: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED the_thread->Wait.flags = flags; 4000ab48: c2 26 a0 50 st %g1, [ %i2 + 0x50 ] <== NOT EXECUTED return _Thread_queue_Make_ready_again( the_thread ); 4000ab4c: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED the_thread->Wait.queue = NULL; 4000ab50: c0 26 a0 54 clr [ %i2 + 0x54 ] <== NOT EXECUTED the_thread->Wait.operations = &_Thread_queue_Operations_default; 4000ab54: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 4000ab58: 82 10 61 50 or %g1, 0x150, %g1 ! 40019950 <_Thread_queue_Operations_default> <== NOT EXECUTED 4000ab5c: c2 26 a0 58 st %g1, [ %i2 + 0x58 ] <== NOT EXECUTED } 4000ab60: 81 c7 e0 08 ret <== NOT EXECUTED 4000ab64: 81 e8 00 00 restore <== NOT EXECUTED unblock = false; 4000ab68: b0 10 20 00 clr %i0 <== NOT EXECUTED the_thread->Wait.flags = desired_flags; 4000ab6c: c2 26 a0 50 st %g1, [ %i2 + 0x50 ] <== NOT EXECUTED return _Thread_queue_Make_ready_again( the_thread ); 4000ab70: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED the_thread->Wait.queue = NULL; 4000ab74: c0 26 a0 54 clr [ %i2 + 0x54 ] <== NOT EXECUTED the_thread->Wait.operations = &_Thread_queue_Operations_default; 4000ab78: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 4000ab7c: 82 10 61 50 or %g1, 0x150, %g1 ! 40019950 <_Thread_queue_Operations_default> <== NOT EXECUTED 4000ab80: c2 26 a0 58 st %g1, [ %i2 + 0x58 ] <== NOT EXECUTED } 4000ab84: 81 c7 e0 08 ret <== NOT EXECUTED 4000ab88: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000e720 <_Thread_queue_Extract_with_proxy>: if ( proxy_extract_callout != NULL ) (*proxy_extract_callout)( the_thread, id ); } #endif _Thread_queue_Extract( the_thread ); 4000e720: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4000e724: 7f ff f1 1a call 4000ab8c <_Thread_queue_Extract> <== NOT EXECUTED 4000e728: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 40011200 <_Thread_queue_First>: Thread_Control *_Thread_queue_First( Thread_queue_Control *the_thread_queue, const Thread_queue_Operations *operations ) { 40011200: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40011204: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 40011208: d0 06 00 00 ld [ %i0 ], %o0 const Thread_queue_Operations *operations ) { Thread_queue_Heads *heads = the_thread_queue->Queue.heads; if ( heads != NULL ) { 4001120c: 80 a2 20 00 cmp %o0, 0 40011210: 22 80 00 07 be,a 4001122c <_Thread_queue_First+0x2c> 40011214: b0 10 20 00 clr %i0 return ( *operations->first )( heads ); 40011218: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 4001121c: 9f c0 80 00 call %g2 40011220: c2 27 bf fc st %g1, [ %fp + -4 ] 40011224: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED 40011228: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4001122c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40011230: 01 00 00 00 nop _Thread_queue_Acquire( the_thread_queue, &queue_context ); the_thread = _Thread_queue_First_locked( the_thread_queue, operations ); _Thread_queue_Release( the_thread_queue, &queue_context ); return the_thread; } 40011234: 81 c7 e0 08 ret 40011238: 81 e8 00 00 restore =============================================================================== 4000e72c <_Thread_queue_Flush_critical>: Thread_queue_Queue *queue, const Thread_queue_Operations *operations, Thread_queue_Flush_filter filter, Thread_queue_Context *queue_context ) { 4000e72c: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED head->next = tail; 4000e730: a0 07 bf f8 add %fp, -8, %l0 <== NOT EXECUTED tail->previous = head; 4000e734: 82 07 bf f4 add %fp, -12, %g1 <== NOT EXECUTED head->previous = NULL; 4000e738: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED 4000e73c: b8 10 00 18 mov %i0, %i4 <== NOT EXECUTED head->next = tail; 4000e740: e0 27 bf f4 st %l0, [ %fp + -12 ] <== NOT EXECUTED tail->previous = head; 4000e744: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED while ( true ) { Thread_queue_Heads *heads; Thread_Control *first; bool do_unblock; heads = queue->heads; 4000e748: d0 06 00 00 ld [ %i0 ], %o0 <== NOT EXECUTED owner = queue->owner; 4000e74c: e2 06 20 04 ld [ %i0 + 4 ], %l1 <== NOT EXECUTED if ( heads == NULL ) { 4000e750: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000e754: 12 80 00 16 bne 4000e7ac <_Thread_queue_Flush_critical+0x80> <== NOT EXECUTED 4000e758: b0 10 20 00 clr %i0 4000e75c: 30 80 00 59 b,a 4000e8c0 <_Thread_queue_Flush_critical+0x194> * updates, so clear it each time. We unconditionally do the priority * update for the owner later if it exists. */ _Thread_queue_Context_clear_priority_updates( queue_context ); do_unblock = _Thread_queue_Extract_locked( 4000e760: 96 10 00 1b mov %i3, %o3 4000e764: 94 10 00 1d mov %i5, %o2 4000e768: 92 10 00 19 mov %i1, %o1 4000e76c: 7f ff f0 ec call 4000ab1c <_Thread_queue_Extract_locked> 4000e770: 90 10 00 1c mov %i4, %o0 queue, operations, first, queue_context ); if ( do_unblock ) { 4000e774: 80 a2 20 00 cmp %o0, 0 4000e778: 22 80 00 0a be,a 4000e7a0 <_Thread_queue_Flush_critical+0x74> 4000e77c: d0 07 00 00 ld [ %i4 ], %o0 4000e780: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 old_last = tail->previous; 4000e784: c4 07 bf fc ld [ %fp + -4 ], %g2 the_node->next = tail; 4000e788: e0 20 60 08 st %l0, [ %g1 + 8 ] Scheduler_Node *scheduler_node; scheduler_node = _Thread_Scheduler_get_home_node( first ); _Chain_Append_unprotected( 4000e78c: 86 00 60 08 add %g1, 8, %g3 tail->previous = the_node; 4000e790: c6 27 bf fc st %g3, [ %fp + -4 ] old_last->next = the_node; 4000e794: c6 20 80 00 st %g3, [ %g2 ] the_node->previous = old_last; 4000e798: c4 20 60 0c st %g2, [ %g1 + 0xc ] heads = queue->heads; 4000e79c: d0 07 00 00 ld [ %i4 ], %o0 if ( heads == NULL ) { 4000e7a0: 80 a2 20 00 cmp %o0, 0 4000e7a4: 02 80 00 0b be 4000e7d0 <_Thread_queue_Flush_critical+0xa4> 4000e7a8: b0 06 20 01 inc %i0 first = ( *operations->first )( heads ); 4000e7ac: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 4000e7b0: 9f c0 40 00 call %g1 4000e7b4: 01 00 00 00 nop first = ( *filter )( first, queue, queue_context ); 4000e7b8: 94 10 00 1b mov %i3, %o2 4000e7bc: 9f c6 80 00 call %i2 4000e7c0: 92 10 00 1c mov %i4, %o1 if ( first == NULL ) { 4000e7c4: ba 92 20 00 orcc %o0, 0, %i5 4000e7c8: 32 bf ff e6 bne,a 4000e760 <_Thread_queue_Flush_critical+0x34> 4000e7cc: c0 26 e0 14 clr [ %i3 + 0x14 ] return _Chain_Immutable_head( the_chain )->next; 4000e7d0: c4 07 bf f4 ld [ %fp + -12 ], %g2 } node = _Chain_First( &unblock ); tail = _Chain_Tail( &unblock ); if ( node != tail ) { 4000e7d4: 80 a0 80 10 cmp %g2, %l0 4000e7d8: 02 80 00 3a be 4000e8c0 <_Thread_queue_Flush_critical+0x194> 4000e7dc: 01 00 00 00 nop disable_level = cpu_self->thread_dispatch_disable_level; 4000e7e0: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000e7e4: 82 00 60 01 inc %g1 <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000e7e8: b4 10 00 06 mov %g6, %i2 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000e7ec: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e7f0: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e7f4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e7f8: 01 00 00 00 nop <== NOT EXECUTED _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000e7fc: 37 0c 00 57 sethi %hi(0x30015c00), %i3 <== NOT EXECUTED 4000e800: b6 16 e3 ff or %i3, 0x3ff, %i3 ! 30015fff <== NOT EXECUTED 4000e804: f8 00 80 00 ld [ %g2 ], %i4 <== NOT EXECUTED 4000e808: fa 00 bf f8 ld [ %g2 + -8 ], %i5 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000e80c: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000e810: c2 27 bf ec st %g1, [ %fp + -20 ] 4000e814: d0 07 60 60 ld [ %i5 + 0x60 ], %o0 4000e818: 7f ff f5 ed call 4000bfcc <_Watchdog_Remove> 4000e81c: 92 07 60 68 add %i5, 0x68, %o1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e820: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e824: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e828: 01 00 00 00 nop 4000e82c: 92 10 00 1b mov %i3, %o1 4000e830: 7f ff ff 53 call 4000e57c <_Thread_Clear_state> 4000e834: 90 10 00 1d mov %i5, %o0 scheduler_node = SCHEDULER_NODE_OF_WAIT_PRIORITY_NODE( node ); the_thread = _Scheduler_Node_get_owner( scheduler_node ); _Thread_Remove_timer_and_unblock( the_thread, queue ); node = next; } while ( node != tail ); 4000e838: 80 a7 00 10 cmp %i4, %l0 4000e83c: 12 bf ff f2 bne 4000e804 <_Thread_queue_Flush_critical+0xd8> 4000e840: 84 10 00 1c mov %i4, %g2 if ( owner != NULL ) { 4000e844: 80 a4 60 00 cmp %l1, 0 4000e848: 02 80 00 0d be 4000e87c <_Thread_queue_Flush_critical+0x150> 4000e84c: 01 00 00 00 nop __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000e850: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000e854: c2 27 bf ec st %g1, [ %fp + -20 ] ( *scheduler->Operations.update_priority )( 4000e858: 11 10 00 63 sethi %hi(0x40018c00), %o0 4000e85c: d4 04 60 38 ld [ %l1 + 0x38 ], %o2 4000e860: 90 12 21 c8 or %o0, 0x1c8, %o0 4000e864: c4 02 20 18 ld [ %o0 + 0x18 ], %g2 4000e868: 9f c0 80 00 call %g2 4000e86c: 92 10 00 11 mov %l1, %o1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e870: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e874: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e878: 01 00 00 00 nop uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000e87c: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1 if ( disable_level == 1 ) { 4000e880: 80 a0 60 01 cmp %g1, 1 4000e884: 02 80 00 05 be 4000e898 <_Thread_queue_Flush_critical+0x16c> 4000e888: 82 00 7f ff add %g1, -1, %g1 cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000e88c: c2 26 a0 18 st %g1, [ %i2 + 0x18 ] 4000e890: 81 c7 e0 08 ret 4000e894: 81 e8 00 00 restore __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000e898: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000e89c: c4 0e a0 1c ldub [ %i2 + 0x1c ], %g2 4000e8a0: 80 a0 a0 00 cmp %g2, 0 4000e8a4: 12 80 00 0c bne 4000e8d4 <_Thread_queue_Flush_critical+0x1a8> 4000e8a8: 92 10 00 01 mov %g1, %o1 cpu_self->thread_dispatch_disable_level = 0; 4000e8ac: c0 26 a0 18 clr [ %i2 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e8b0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e8b4: 01 00 00 00 nop 4000e8b8: 81 c7 e0 08 ret 4000e8bc: 81 e8 00 00 restore register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e8c0: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e8c4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e8c8: 01 00 00 00 nop } else { _Thread_queue_Queue_release( queue, &queue_context->Lock_context.Lock_context ); } return flushed; } 4000e8cc: 81 c7 e0 08 ret 4000e8d0: 81 e8 00 00 restore _Thread_Do_dispatch( cpu_self, level ); 4000e8d4: c2 27 bf ec st %g1, [ %fp + -20 ] 4000e8d8: 7f ff ff 3f call 4000e5d4 <_Thread_Do_dispatch> 4000e8dc: 90 10 00 1a mov %i2, %o0 4000e8e0: 10 bf ff f4 b 4000e8b0 <_Thread_queue_Flush_critical+0x184> 4000e8e4: c2 07 bf ec ld [ %fp + -20 ], %g1 =============================================================================== 4000b95c <_Thread_queue_Flush_default_filter>: ) { (void) queue; (void) queue_context; return the_thread; } 4000b95c: 81 c3 e0 08 retl <== NOT EXECUTED 4000b960: 01 00 00 00 nop =============================================================================== 4000eeb8 <_Thread_queue_Flush_status_object_was_deleted>: Thread_Control *the_thread, Thread_queue_Queue *queue, Thread_queue_Context *queue_context ) { the_thread->Wait.return_code = STATUS_OBJECT_WAS_DELETED; 4000eeb8: 03 00 00 05 sethi %hi(0x1400), %g1 <== NOT EXECUTED 4000eebc: 82 10 62 07 or %g1, 0x207, %g1 ! 1607 <_Configuration_Interrupt_stack_size+0x607> <== NOT EXECUTED (void) queue; (void) queue_context; return the_thread; } 4000eec0: 81 c3 e0 08 retl <== NOT EXECUTED 4000eec4: c2 22 20 4c st %g1, [ %o0 + 0x4c ] =============================================================================== 4000b834 <_Thread_queue_Flush_status_unavailable>: Thread_Control *the_thread, Thread_queue_Queue *queue, Thread_queue_Context *queue_context ) { the_thread->Wait.return_code = STATUS_UNAVAILABLE; 4000b834: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED 4000b838: 82 10 60 0d or %g1, 0xd, %g1 ! 100d <_Configuration_Interrupt_stack_size+0xd> <== NOT EXECUTED (void) queue; (void) queue_context; return the_thread; } 4000b83c: 81 c3 e0 08 retl <== NOT EXECUTED 4000b840: c2 22 20 4c st %g1, [ %o0 + 0x4c ] =============================================================================== 40011498 <_Thread_queue_Object_initialize>: queue->name = name; 40011498: 03 10 00 77 sethi %hi(0x4001dc00), %g1 <== NOT EXECUTED queue->heads = NULL; 4001149c: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED queue->name = name; 400114a0: 82 10 62 c8 or %g1, 0x2c8, %g1 <== NOT EXECUTED queue->owner = NULL; 400114a4: c0 22 20 04 clr [ %o0 + 4 ] <== NOT EXECUTED } void _Thread_queue_Object_initialize( Thread_queue_Control *the_thread_queue ) { _Thread_queue_Initialize( the_thread_queue, _Thread_queue_Object_name ); } 400114a8: 81 c3 e0 08 retl <== NOT EXECUTED 400114ac: c2 22 20 08 st %g1, [ %o0 + 8 ] =============================================================================== 40014a5c <_Thread_queue_Queue_get_name_and_id>: const Thread_queue_Queue *queue, char *buffer, size_t buffer_size, Objects_Id *id ) { 40014a5c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED const char *name; name = queue->name; 40014a60: c4 06 20 08 ld [ %i0 + 8 ], %g2 <== NOT EXECUTED if ( name == _Thread_queue_Object_name ) { 40014a64: 03 10 00 a5 sethi %hi(0x40029400), %g1 <== NOT EXECUTED 40014a68: 82 10 61 50 or %g1, 0x150, %g1 ! 40029550 <_Thread_queue_Object_name> <== NOT EXECUTED 40014a6c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 40014a70: 02 80 00 0c be 40014aa0 <_Thread_queue_Queue_get_name_and_id+0x44> <== NOT EXECUTED 40014a74: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED false, buffer, buffer_size ); } else { if ( name == NULL ) { 40014a78: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40014a7c: 02 80 00 05 be 40014a90 <_Thread_queue_Queue_get_name_and_id+0x34> <== NOT EXECUTED 40014a80: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED name = _Thread_queue_Object_name; } *id = 0; return strlcpy( buffer, name, buffer_size ); 40014a84: b2 10 00 02 mov %g2, %i1 <== NOT EXECUTED 40014a88: 40 00 14 c6 call 40019da0 <== NOT EXECUTED 40014a8c: 91 e8 00 0a restore %g0, %o2, %o0 <== NOT EXECUTED name = _Thread_queue_Object_name; 40014a90: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED return strlcpy( buffer, name, buffer_size ); 40014a94: b0 10 00 0a mov %o2, %i0 <== NOT EXECUTED 40014a98: 40 00 14 c2 call 40019da0 <== NOT EXECUTED 40014a9c: 93 e8 00 02 restore %g0, %g2, %o1 <== NOT EXECUTED *id = queue_object->Object.id; 40014aa0: c4 06 3f f8 ld [ %i0 + -8 ], %g2 <== NOT EXECUTED 40014aa4: c4 26 c0 00 st %g2, [ %i3 ] <== NOT EXECUTED return _Objects_Name_to_string( 40014aa8: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 40014aac: c2 06 3f fc ld [ %i0 + -4 ], %g1 <== NOT EXECUTED 40014ab0: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED 40014ab4: 92 10 20 00 clr %o1 <== NOT EXECUTED 40014ab8: 7f ff fe 0a call 400142e0 <_Objects_Name_to_string> <== NOT EXECUTED 40014abc: 90 07 bf fc add %fp, -4, %o0 <== NOT EXECUTED } } 40014ac0: 81 c7 e0 08 ret <== NOT EXECUTED 40014ac4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED =============================================================================== 4000ac28 <_Thread_queue_Surrender>: Thread_queue_Heads *heads, Thread_Control *previous_owner, Thread_queue_Context *queue_context, const Thread_queue_Operations *operations ) { 4000ac28: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED 4000ac2c: c0 26 e0 14 clr [ %i3 + 0x14 ] <== NOT EXECUTED Per_CPU_Control *cpu_self; _Assert( heads != NULL ); _Thread_queue_Context_clear_priority_updates( queue_context ); new_owner = ( *operations->surrender )( 4000ac30: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED 4000ac34: c2 07 20 0c ld [ %i4 + 0xc ], %g1 <== NOT EXECUTED 4000ac38: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 4000ac3c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000ac40: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000ac44: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED queue, heads, previous_owner, queue_context ); queue->owner = new_owner; 4000ac48: d0 26 20 04 st %o0, [ %i0 + 4 ] <== NOT EXECUTED if ( success ) { 4000ac4c: c2 02 20 50 ld [ %o0 + 0x50 ], %g1 <== NOT EXECUTED 4000ac50: 80 a0 64 01 cmp %g1, 0x401 <== NOT EXECUTED 4000ac54: 02 80 00 1c be 4000acc4 <_Thread_queue_Surrender+0x9c> <== NOT EXECUTED 4000ac58: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED the_thread->Wait.flags = flags; 4000ac5c: 82 10 24 04 mov 0x404, %g1 <== NOT EXECUTED 4000ac60: c2 22 20 50 st %g1, [ %o0 + 0x50 ] <== NOT EXECUTED unblock = true; 4000ac64: b4 10 20 01 mov 1, %i2 <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 4000ac68: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED the_thread->Wait.queue = NULL; 4000ac6c: c0 27 60 54 clr [ %i5 + 0x54 ] <== NOT EXECUTED the_thread->Wait.operations = &_Thread_queue_Operations_default; 4000ac70: 05 10 00 66 sethi %hi(0x40019800), %g2 <== NOT EXECUTED 4000ac74: 84 10 a1 50 or %g2, 0x150, %g2 ! 40019950 <_Thread_queue_Operations_default> <== NOT EXECUTED 4000ac78: c4 27 60 58 st %g2, [ %i5 + 0x58 ] <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000ac7c: 82 00 60 01 inc %g1 <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000ac80: b8 10 00 06 mov %g6, %i4 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000ac84: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000ac88: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000ac8c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ac90: 01 00 00 00 nop _Thread_queue_Queue_release( queue, &queue_context->Lock_context.Lock_context ); _Thread_Priority_update( queue_context ); 4000ac94: 40 00 0e 0d call 4000e4c8 <_Thread_Priority_update> 4000ac98: 90 10 00 1b mov %i3, %o0 if ( unblock ) { 4000ac9c: 80 8e a0 ff btst 0xff, %i2 4000aca0: 12 80 00 0d bne 4000acd4 <_Thread_queue_Surrender+0xac> <== ALWAYS TAKEN 4000aca4: 01 00 00 00 nop uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000aca8: c2 07 20 18 ld [ %i4 + 0x18 ], %g1 <== NOT EXECUTED if ( disable_level == 1 ) { 4000acac: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000acb0: 02 80 00 19 be 4000ad14 <_Thread_queue_Surrender+0xec> <== NOT EXECUTED 4000acb4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000acb8: c2 27 20 18 st %g1, [ %i4 + 0x18 ] _Thread_Remove_timer_and_unblock( new_owner, queue ); } _Thread_Dispatch_enable( cpu_self ); } 4000acbc: 81 c7 e0 08 ret 4000acc0: 81 e8 00 00 restore the_thread->Wait.flags = desired_flags; 4000acc4: 82 10 24 04 mov 0x404, %g1 <== NOT EXECUTED unblock = false; 4000acc8: b4 10 20 00 clr %i2 <== NOT EXECUTED 4000accc: 10 bf ff e7 b 4000ac68 <_Thread_queue_Surrender+0x40> <== NOT EXECUTED 4000acd0: c2 22 20 50 st %g1, [ %o0 + 0x50 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000acd4: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000acd8: c2 27 bf fc st %g1, [ %fp + -4 ] 4000acdc: d0 07 60 60 ld [ %i5 + 0x60 ], %o0 4000ace0: 40 00 04 bb call 4000bfcc <_Watchdog_Remove> 4000ace4: 92 07 60 68 add %i5, 0x68, %o1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000ace8: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000acec: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000acf0: 01 00 00 00 nop _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000acf4: 13 0c 00 57 sethi %hi(0x30015c00), %o1 4000acf8: 90 10 00 1d mov %i5, %o0 4000acfc: 40 00 0e 20 call 4000e57c <_Thread_Clear_state> 4000ad00: 92 12 63 ff or %o1, 0x3ff, %o1 uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000ad04: c2 07 20 18 ld [ %i4 + 0x18 ], %g1 if ( disable_level == 1 ) { 4000ad08: 80 a0 60 01 cmp %g1, 1 4000ad0c: 12 bf ff eb bne 4000acb8 <_Thread_queue_Surrender+0x90> 4000ad10: 82 00 7f ff add %g1, -1, %g1 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000ad14: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000ad18: c4 0f 20 1c ldub [ %i4 + 0x1c ], %g2 4000ad1c: 80 a0 a0 00 cmp %g2, 0 4000ad20: 32 80 00 07 bne,a 4000ad3c <_Thread_queue_Surrender+0x114> 4000ad24: 92 10 00 01 mov %g1, %o1 cpu_self->thread_dispatch_disable_level = 0; 4000ad28: c0 27 20 18 clr [ %i4 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000ad2c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ad30: 01 00 00 00 nop 4000ad34: 81 c7 e0 08 ret 4000ad38: 81 e8 00 00 restore _Thread_Do_dispatch( cpu_self, level ); 4000ad3c: c2 27 bf fc st %g1, [ %fp + -4 ] 4000ad40: 40 00 0e 25 call 4000e5d4 <_Thread_Do_dispatch> 4000ad44: 90 10 00 1c mov %i4, %o0 4000ad48: 10 bf ff f9 b 4000ad2c <_Thread_queue_Surrender+0x104> 4000ad4c: c2 07 bf fc ld [ %fp + -4 ], %g1 =============================================================================== 40008924 <_Timecounter_Bintime>: { 40008924: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 40008928: 33 10 00 6d sethi %hi(0x4001b400), %i1 <== NOT EXECUTED 4000892c: b2 16 61 00 or %i1, 0x100, %i1 ! 4001b500 <== NOT EXECUTED th = timehands; 40008930: fa 06 40 00 ld [ %i1 ], %i5 40008934: f4 07 60 70 ld [ %i5 + 0x70 ], %i2 *bt = th->th_bintime; 40008938: c4 1f 60 30 ldd [ %i5 + 0x30 ], %g2 4000893c: c4 3e 00 00 std %g2, [ %i0 ] 40008940: c4 1f 60 38 ldd [ %i5 + 0x38 ], %g2 40008944: f6 07 40 00 ld [ %i5 ], %i3 40008948: c4 3e 20 08 std %g2, [ %i0 + 8 ] return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 4000894c: 90 10 00 1b mov %i3, %o0 40008950: c2 06 c0 00 ld [ %i3 ], %g1 bintime_addx(bt, th->th_scale * tc_delta(th)); 40008954: f8 07 60 10 ld [ %i5 + 0x10 ], %i4 return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40008958: 9f c0 40 00 call %g1 4000895c: e0 07 60 14 ld [ %i5 + 0x14 ], %l0 40008960: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 40008964: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 40008968: f6 06 e0 08 ld [ %i3 + 8 ], %i3 4000896c: 90 22 00 01 sub %o0, %g1, %o0 40008970: 90 0a 00 1b and %o0, %i3, %o0 bintime_addx(bt, th->th_scale * tc_delta(th)); 40008974: b8 5f 00 08 smul %i4, %o0, %i4 40008978: 92 52 00 10 umul %o0, %l0, %o1 4000897c: 91 40 00 00 rd %y, %o0 40008980: 90 07 00 08 add %i4, %o0, %o0 40008984: 9a 82 40 03 addcc %o1, %g3, %o5 40008988: 98 c2 00 02 addxcc %o0, %g2, %o4 4000898c: 0a 80 00 12 bcs 400089d4 <_Timecounter_Bintime+0xb0> 40008990: 88 10 20 00 clr %g4 if (_u > _bt->frac) 40008994: 80 a1 20 00 cmp %g4, 0 40008998: 02 80 00 06 be 400089b0 <_Timecounter_Bintime+0x8c> 4000899c: d8 3e 20 08 std %o4, [ %i0 + 8 ] _bt->sec++; 400089a0: c4 1e 00 00 ldd [ %i0 ], %g2 400089a4: 9a 80 e0 01 addcc %g3, 1, %o5 400089a8: 98 40 a0 00 addx %g2, 0, %o4 400089ac: d8 3e 00 00 std %o4, [ %i0 ] } while (gen == 0 || gen != th->th_generation); 400089b0: 80 a6 a0 00 cmp %i2, 0 400089b4: 02 bf ff df be 40008930 <_Timecounter_Bintime+0xc> <== NEVER TAKEN 400089b8: 01 00 00 00 nop 400089bc: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 400089c0: 80 a0 40 1a cmp %g1, %i2 400089c4: 12 bf ff db bne 40008930 <_Timecounter_Bintime+0xc> 400089c8: 01 00 00 00 nop } 400089cc: 81 c7 e0 08 ret 400089d0: 81 e8 00 00 restore 400089d4: 10 bf ff f0 b 40008994 <_Timecounter_Bintime+0x70> 400089d8: 88 10 20 01 mov 1, %g4 =============================================================================== 40009208 <_Timecounter_Binuptime>: { 40009208: 9d e3 bf a0 save %sp, -96, %sp 4000920c: 33 10 00 4b sethi %hi(0x40012c00), %i1 40009210: b2 16 62 c0 or %i1, 0x2c0, %i1 ! 40012ec0 th = timehands; 40009214: fa 06 40 00 ld [ %i1 ], %i5 40009218: f4 07 60 70 ld [ %i5 + 0x70 ], %i2 *bt = th->th_offset; 4000921c: c4 1f 60 20 ldd [ %i5 + 0x20 ], %g2 40009220: c4 3e 00 00 std %g2, [ %i0 ] 40009224: c4 1f 60 28 ldd [ %i5 + 0x28 ], %g2 40009228: f6 07 40 00 ld [ %i5 ], %i3 4000922c: c4 3e 20 08 std %g2, [ %i0 + 8 ] return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40009230: 90 10 00 1b mov %i3, %o0 40009234: c2 06 c0 00 ld [ %i3 ], %g1 bintime_addx(bt, th->th_scale * tc_delta(th)); 40009238: f8 07 60 10 ld [ %i5 + 0x10 ], %i4 return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 4000923c: 9f c0 40 00 call %g1 40009240: e0 07 60 14 ld [ %i5 + 0x14 ], %l0 40009244: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 40009248: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 4000924c: f6 06 e0 08 ld [ %i3 + 8 ], %i3 40009250: 90 22 00 01 sub %o0, %g1, %o0 40009254: 90 0a 00 1b and %o0, %i3, %o0 bintime_addx(bt, th->th_scale * tc_delta(th)); 40009258: b8 5f 00 08 smul %i4, %o0, %i4 4000925c: 92 52 00 10 umul %o0, %l0, %o1 40009260: 91 40 00 00 rd %y, %o0 40009264: 90 07 00 08 add %i4, %o0, %o0 40009268: 9a 82 40 03 addcc %o1, %g3, %o5 4000926c: 98 c2 00 02 addxcc %o0, %g2, %o4 40009270: 0a 80 00 12 bcs 400092b8 <_Timecounter_Binuptime+0xb0> 40009274: 88 10 20 00 clr %g4 if (_u > _bt->frac) 40009278: 80 a1 20 00 cmp %g4, 0 4000927c: 02 80 00 06 be 40009294 <_Timecounter_Binuptime+0x8c> 40009280: d8 3e 20 08 std %o4, [ %i0 + 8 ] _bt->sec++; 40009284: c4 1e 00 00 ldd [ %i0 ], %g2 40009288: 9a 80 e0 01 addcc %g3, 1, %o5 4000928c: 98 40 a0 00 addx %g2, 0, %o4 40009290: d8 3e 00 00 std %o4, [ %i0 ] } while (gen == 0 || gen != th->th_generation); 40009294: 80 a6 a0 00 cmp %i2, 0 40009298: 02 bf ff df be 40009214 <_Timecounter_Binuptime+0xc> <== NEVER TAKEN 4000929c: 01 00 00 00 nop 400092a0: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 400092a4: 80 a0 40 1a cmp %g1, %i2 400092a8: 12 bf ff db bne 40009214 <_Timecounter_Binuptime+0xc> 400092ac: 01 00 00 00 nop } 400092b0: 81 c7 e0 08 ret 400092b4: 81 e8 00 00 restore 400092b8: 10 bf ff f0 b 40009278 <_Timecounter_Binuptime+0x70> 400092bc: 88 10 20 01 mov 1, %g4 =============================================================================== 40008a64 <_Timecounter_Getbintime>: { 40008a64: 07 10 00 6d sethi %hi(0x4001b400), %g3 <== NOT EXECUTED 40008a68: 86 10 e1 00 or %g3, 0x100, %g3 ! 4001b500 <== NOT EXECUTED th = timehands; 40008a6c: c2 00 c0 00 ld [ %g3 ], %g1 40008a70: c4 00 60 70 ld [ %g1 + 0x70 ], %g2 *bt = th->th_bintime; 40008a74: d8 18 60 30 ldd [ %g1 + 0x30 ], %o4 40008a78: d8 3a 00 00 std %o4, [ %o0 ] 40008a7c: d8 18 60 38 ldd [ %g1 + 0x38 ], %o4 40008a80: d8 3a 20 08 std %o4, [ %o0 + 8 ] } while (gen == 0 || gen != th->th_generation); 40008a84: 80 a0 a0 00 cmp %g2, 0 40008a88: 02 bf ff f9 be 40008a6c <_Timecounter_Getbintime+0x8> <== NEVER TAKEN 40008a8c: 01 00 00 00 nop 40008a90: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 40008a94: 80 a0 40 02 cmp %g1, %g2 40008a98: 12 bf ff f5 bne 40008a6c <_Timecounter_Getbintime+0x8> 40008a9c: 01 00 00 00 nop } 40008aa0: 81 c3 e0 08 retl 40008aa4: 01 00 00 00 nop =============================================================================== 40004a14 <_Timecounter_Getbinuptime>: { 40004a14: 07 10 00 32 sethi %hi(0x4000c800), %g3 <== NOT EXECUTED 40004a18: 86 10 e2 08 or %g3, 0x208, %g3 ! 4000ca08 <== NOT EXECUTED th = timehands; 40004a1c: c2 00 c0 00 ld [ %g3 ], %g1 <== NOT EXECUTED 40004a20: c4 00 60 70 ld [ %g1 + 0x70 ], %g2 <== NOT EXECUTED *bt = th->th_offset; 40004a24: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4 <== NOT EXECUTED 40004a28: d8 3a 00 00 std %o4, [ %o0 ] <== NOT EXECUTED 40004a2c: d8 18 60 28 ldd [ %g1 + 0x28 ], %o4 <== NOT EXECUTED 40004a30: d8 3a 20 08 std %o4, [ %o0 + 8 ] <== NOT EXECUTED } while (gen == 0 || gen != th->th_generation); 40004a34: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40004a38: 02 bf ff f9 be 40004a1c <_Timecounter_Getbinuptime+0x8> <== NOT EXECUTED 40004a3c: 01 00 00 00 nop 40004a40: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 40004a44: 80 a0 40 02 cmp %g1, %g2 40004a48: 12 bf ff f5 bne 40004a1c <_Timecounter_Getbinuptime+0x8> <== NEVER TAKEN 40004a4c: 01 00 00 00 nop } 40004a50: 81 c3 e0 08 retl 40004a54: 01 00 00 00 nop =============================================================================== 40004b88 <_Timecounter_Getmicrotime>: { 40004b88: 07 10 00 32 sethi %hi(0x4000c800), %g3 <== NOT EXECUTED 40004b8c: 86 10 e2 08 or %g3, 0x208, %g3 ! 4000ca08 <== NOT EXECUTED th = timehands; 40004b90: c2 00 c0 00 ld [ %g3 ], %g1 <== NOT EXECUTED 40004b94: c4 00 60 70 ld [ %g1 + 0x70 ], %g2 <== NOT EXECUTED *tvp = th->th_microtime; 40004b98: d8 18 60 40 ldd [ %g1 + 0x40 ], %o4 <== NOT EXECUTED 40004b9c: d8 3a 00 00 std %o4, [ %o0 ] <== NOT EXECUTED 40004ba0: d8 18 60 48 ldd [ %g1 + 0x48 ], %o4 <== NOT EXECUTED 40004ba4: d8 3a 20 08 std %o4, [ %o0 + 8 ] <== NOT EXECUTED } while (gen == 0 || gen != th->th_generation); 40004ba8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40004bac: 02 bf ff f9 be 40004b90 <_Timecounter_Getmicrotime+0x8> <== NOT EXECUTED 40004bb0: 01 00 00 00 nop 40004bb4: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 40004bb8: 80 a0 40 02 cmp %g1, %g2 40004bbc: 12 bf ff f5 bne 40004b90 <_Timecounter_Getmicrotime+0x8> <== NEVER TAKEN 40004bc0: 01 00 00 00 nop } 40004bc4: 81 c3 e0 08 retl 40004bc8: 01 00 00 00 nop =============================================================================== 40004aac <_Timecounter_Getmicrouptime>: { 40004aac: 19 10 00 32 sethi %hi(0x4000c800), %o4 <== NOT EXECUTED _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40004ab0: 1b 00 03 d0 sethi %hi(0xf4000), %o5 <== NOT EXECUTED 40004ab4: 98 13 22 08 or %o4, 0x208, %o4 <== NOT EXECUTED 40004ab8: 9a 13 62 40 or %o5, 0x240, %o5 <== NOT EXECUTED th = timehands; 40004abc: c2 03 00 00 ld [ %o4 ], %g1 <== NOT EXECUTED 40004ac0: c8 00 60 70 ld [ %g1 + 0x70 ], %g4 <== NOT EXECUTED _tv->tv_sec = _bt->sec; 40004ac4: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2 <== NOT EXECUTED 40004ac8: c4 3a 00 00 std %g2, [ %o0 ] <== NOT EXECUTED _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40004acc: c4 00 60 28 ld [ %g1 + 0x28 ], %g2 <== NOT EXECUTED 40004ad0: 86 50 80 0d umul %g2, %o5, %g3 <== NOT EXECUTED 40004ad4: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED 40004ad8: c4 22 20 08 st %g2, [ %o0 + 8 ] <== NOT EXECUTED } while (gen == 0 || gen != th->th_generation); 40004adc: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED 40004ae0: 02 bf ff f7 be 40004abc <_Timecounter_Getmicrouptime+0x10> <== NOT EXECUTED 40004ae4: 01 00 00 00 nop 40004ae8: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 40004aec: 80 a0 40 04 cmp %g1, %g4 40004af0: 12 bf ff f3 bne 40004abc <_Timecounter_Getmicrouptime+0x10> <== NEVER TAKEN 40004af4: 01 00 00 00 nop } 40004af8: 81 c3 e0 08 retl 40004afc: 01 00 00 00 nop =============================================================================== 40008aa8 <_Timecounter_Getnanotime>: { 40008aa8: 07 10 00 6d sethi %hi(0x4001b400), %g3 <== NOT EXECUTED 40008aac: 86 10 e1 00 or %g3, 0x100, %g3 ! 4001b500 <== NOT EXECUTED th = timehands; 40008ab0: c2 00 c0 00 ld [ %g3 ], %g1 <== NOT EXECUTED 40008ab4: c4 00 60 70 ld [ %g1 + 0x70 ], %g2 *tsp = th->th_nanotime; 40008ab8: d8 18 60 50 ldd [ %g1 + 0x50 ], %o4 40008abc: d8 3a 00 00 std %o4, [ %o0 ] 40008ac0: d8 18 60 58 ldd [ %g1 + 0x58 ], %o4 40008ac4: d8 3a 20 08 std %o4, [ %o0 + 8 ] } while (gen == 0 || gen != th->th_generation); 40008ac8: 80 a0 a0 00 cmp %g2, 0 40008acc: 02 bf ff f9 be 40008ab0 <_Timecounter_Getnanotime+0x8> <== NEVER TAKEN 40008ad0: 01 00 00 00 nop 40008ad4: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 40008ad8: 80 a0 40 02 cmp %g1, %g2 40008adc: 12 bf ff f5 bne 40008ab0 <_Timecounter_Getnanotime+0x8> <== NEVER TAKEN 40008ae0: 01 00 00 00 nop } 40008ae4: 81 c3 e0 08 retl 40008ae8: 01 00 00 00 nop =============================================================================== 40008a10 <_Timecounter_Getnanouptime>: { 40008a10: 19 10 00 6d sethi %hi(0x4001b400), %o4 <== NOT EXECUTED _ts->tv_nsec = ((uint64_t)1000000000 * 40008a14: 1b 0e e6 b2 sethi %hi(0x3b9ac800), %o5 <== NOT EXECUTED 40008a18: 98 13 21 00 or %o4, 0x100, %o4 <== NOT EXECUTED 40008a1c: 9a 13 62 00 or %o5, 0x200, %o5 <== NOT EXECUTED th = timehands; 40008a20: c2 03 00 00 ld [ %o4 ], %g1 <== NOT EXECUTED 40008a24: c8 00 60 70 ld [ %g1 + 0x70 ], %g4 <== NOT EXECUTED _ts->tv_sec = _bt->sec; 40008a28: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2 40008a2c: c4 3a 00 00 std %g2, [ %o0 ] (uint32_t)(_bt->frac >> 32)) >> 32; 40008a30: c4 00 60 28 ld [ %g1 + 0x28 ], %g2 _ts->tv_nsec = ((uint64_t)1000000000 * 40008a34: 86 50 80 0d umul %g2, %o5, %g3 40008a38: 85 40 00 00 rd %y, %g2 40008a3c: c4 22 20 08 st %g2, [ %o0 + 8 ] } while (gen == 0 || gen != th->th_generation); 40008a40: 80 a1 20 00 cmp %g4, 0 40008a44: 02 bf ff f7 be 40008a20 <_Timecounter_Getnanouptime+0x10> <== NEVER TAKEN 40008a48: 01 00 00 00 nop 40008a4c: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 40008a50: 80 a0 40 04 cmp %g1, %g4 40008a54: 12 bf ff f3 bne 40008a20 <_Timecounter_Getnanouptime+0x10> <== NEVER TAKEN 40008a58: 01 00 00 00 nop } 40008a5c: 81 c3 e0 08 retl 40008a60: 01 00 00 00 nop =============================================================================== 40008aec <_Timecounter_Install>: { 40008aec: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED tc->tc_next = timecounters; 40008af0: 03 10 00 6d sethi %hi(0x4001b400), %g1 <== NOT EXECUTED 40008af4: c4 00 60 f8 ld [ %g1 + 0xf8 ], %g2 ! 4001b4f8 <== NOT EXECUTED 40008af8: c4 26 20 28 st %g2, [ %i0 + 0x28 ] <== NOT EXECUTED (void)tc->tc_get_timecount(tc); 40008afc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40008b00: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED 40008b04: 9f c0 80 00 call %g2 40008b08: f0 20 60 f8 st %i0, [ %g1 + 0xf8 ] (void)tc->tc_get_timecount(tc); 40008b0c: c2 06 00 00 ld [ %i0 ], %g1 40008b10: 9f c0 40 00 call %g1 40008b14: 90 10 00 18 mov %i0, %o0 timecounter = tc; 40008b18: 03 10 00 6d sethi %hi(0x4001b400), %g1 <== NOT EXECUTED 40008b1c: f0 20 60 fc st %i0, [ %g1 + 0xfc ] ! 4001b4fc <_Timecounter> <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40008b20: 91 d0 20 09 ta 9 <== NOT EXECUTED _Timecounter_Acquire(&lock_context); 40008b24: c2 27 bf fc st %g1, [ %fp + -4 ] _Timecounter_Windup(new_boottimebin, &lock_context); 40008b28: 90 10 20 00 clr %o0 40008b2c: 7f ff fe a6 call 400085c4 <_Timecounter_Windup> 40008b30: 92 07 bf fc add %fp, -4, %o1 } 40008b34: 81 c7 e0 08 ret 40008b38: 81 e8 00 00 restore =============================================================================== 400089dc <_Timecounter_Microtime>: { 400089dc: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED bintime(&bt); 400089e0: 7f ff ff d1 call 40008924 <_Timecounter_Bintime> <== NOT EXECUTED 400089e4: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED _tv->tv_sec = _bt->sec; 400089e8: c4 1f bf f0 ldd [ %fp + -16 ], %g2 400089ec: c4 3e 00 00 std %g2, [ %i0 ] _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 400089f0: 03 00 03 d0 sethi %hi(0xf4000), %g1 400089f4: c4 07 bf f8 ld [ %fp + -8 ], %g2 400089f8: 82 10 62 40 or %g1, 0x240, %g1 400089fc: 86 50 80 01 umul %g2, %g1, %g3 40008a00: 85 40 00 00 rd %y, %g2 40008a04: c4 26 20 08 st %g2, [ %i0 + 8 ] } 40008a08: 81 c7 e0 08 ret 40008a0c: 81 e8 00 00 restore =============================================================================== 40007e70 <_Timecounter_Microuptime>: { 40007e70: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED binuptime(&bt); 40007e74: 7f ff ff ac call 40007d24 <_Timecounter_Binuptime> <== NOT EXECUTED 40007e78: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED _tv->tv_sec = _bt->sec; 40007e7c: c4 1f bf f0 ldd [ %fp + -16 ], %g2 40007e80: c4 3e 00 00 std %g2, [ %i0 ] _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40007e84: 03 00 03 d0 sethi %hi(0xf4000), %g1 40007e88: c4 07 bf f8 ld [ %fp + -8 ], %g2 40007e8c: 82 10 62 40 or %g1, 0x240, %g1 40007e90: 86 50 80 01 umul %g2, %g1, %g3 40007e94: 85 40 00 00 rd %y, %g2 40007e98: c4 26 20 08 st %g2, [ %i0 + 8 ] } 40007e9c: 81 c7 e0 08 ret 40007ea0: 81 e8 00 00 restore =============================================================================== 400090bc <_Timecounter_Nanotime>: { 400090bc: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED bintime(&bt); 400090c0: 7f ff ff d1 call 40009004 <_Timecounter_Bintime> <== NOT EXECUTED 400090c4: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED _ts->tv_sec = _bt->sec; 400090c8: c4 1f bf f0 ldd [ %fp + -16 ], %g2 400090cc: c4 3e 00 00 std %g2, [ %i0 ] _ts->tv_nsec = ((uint64_t)1000000000 * 400090d0: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 400090d4: c4 07 bf f8 ld [ %fp + -8 ], %g2 400090d8: 82 10 62 00 or %g1, 0x200, %g1 400090dc: 86 50 80 01 umul %g2, %g1, %g3 400090e0: 85 40 00 00 rd %y, %g2 400090e4: c4 26 20 08 st %g2, [ %i0 + 8 ] } 400090e8: 81 c7 e0 08 ret 400090ec: 81 e8 00 00 restore =============================================================================== 40009354 <_Timecounter_Nanouptime>: { 40009354: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED binuptime(&bt); 40009358: 7f ff ff ac call 40009208 <_Timecounter_Binuptime> <== NOT EXECUTED 4000935c: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED _ts->tv_sec = _bt->sec; 40009360: c4 1f bf f0 ldd [ %fp + -16 ], %g2 40009364: c4 3e 00 00 std %g2, [ %i0 ] _ts->tv_nsec = ((uint64_t)1000000000 * 40009368: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 4000936c: c4 07 bf f8 ld [ %fp + -8 ], %g2 40009370: 82 10 62 00 or %g1, 0x200, %g1 40009374: 86 50 80 01 umul %g2, %g1, %g3 40009378: 85 40 00 00 rd %y, %g2 4000937c: c4 26 20 08 st %g2, [ %i0 + 8 ] } 40009380: 81 c7 e0 08 ret 40009384: 81 e8 00 00 restore =============================================================================== 40008890 <_Timecounter_Sbinuptime>: { 40008890: 9d e3 bf a0 save %sp, -96, %sp 40008894: 33 10 00 6d sethi %hi(0x4001b400), %i1 40008898: b2 16 61 00 or %i1, 0x100, %i1 ! 4001b500 th = timehands; 4000889c: fa 06 40 00 ld [ %i1 ], %i5 400088a0: f6 07 60 70 ld [ %i5 + 0x70 ], %i3 RTEMS_COMPILER_MEMORY_BARRIER(); 400088a4: f8 07 40 00 ld [ %i5 ], %i4 return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 400088a8: c2 07 00 00 ld [ %i4 ], %g1 400088ac: e2 07 60 24 ld [ %i5 + 0x24 ], %l1 400088b0: e0 07 60 28 ld [ %i5 + 0x28 ], %l0 sbt += (th->th_scale * tc_delta(th)) >> 32; 400088b4: f4 07 60 10 ld [ %i5 + 0x10 ], %i2 400088b8: e4 07 60 14 ld [ %i5 + 0x14 ], %l2 return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 400088bc: 9f c0 40 00 call %g1 400088c0: 90 10 00 1c mov %i4, %o0 400088c4: c4 07 60 18 ld [ %i5 + 0x18 ], %g2 tc->tc_counter_mask); 400088c8: c2 07 20 08 ld [ %i4 + 8 ], %g1 } while (gen == 0 || gen != th->th_generation); 400088cc: 80 a6 e0 00 cmp %i3, 0 400088d0: 02 bf ff f3 be 4000889c <_Timecounter_Sbinuptime+0xc> <== NEVER TAKEN 400088d4: 01 00 00 00 nop 400088d8: c6 07 60 70 ld [ %i5 + 0x70 ], %g3 400088dc: 80 a0 c0 1b cmp %g3, %i3 400088e0: 12 bf ff ef bne 4000889c <_Timecounter_Sbinuptime+0xc> 400088e4: 84 22 00 02 sub %o0, %g2, %g2 return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 400088e8: 84 08 80 01 and %g2, %g1, %g2 sbt += (th->th_scale * tc_delta(th)) >> 32; 400088ec: b4 5e 80 02 smul %i2, %g2, %i2 400088f0: 86 50 80 12 umul %g2, %l2, %g3 400088f4: 85 40 00 00 rd %y, %g2 return (((sbintime_t)_bt.sec << 32) + (_bt.frac >> 32)); 400088f8: 9a 10 20 00 clr %o5 400088fc: ba 06 80 02 add %i2, %g2, %i5 40008900: b2 83 40 10 addcc %o5, %l0, %i1 40008904: 84 10 20 00 clr %g2 40008908: b0 44 40 02 addx %l1, %g2, %i0 4000890c: b8 10 20 00 clr %i4 } 40008910: 86 87 40 19 addcc %i5, %i1, %g3 40008914: 84 47 00 18 addx %i4, %i0, %g2 40008918: b2 10 00 03 mov %g3, %i1 4000891c: 81 c7 e0 08 ret 40008920: 91 e8 00 02 restore %g0, %g2, %o0 =============================================================================== 40009d00 <_Timecounter_Set_clock>: { 40009d00: 9d e3 bf 80 save %sp, -128, %sp <== NOT EXECUTED bt = *_bt; 40009d04: f8 1e 00 00 ldd [ %i0 ], %i4 <== NOT EXECUTED 40009d08: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 <== NOT EXECUTED 40009d0c: f8 3f bf e0 std %i4, [ %fp + -32 ] <== NOT EXECUTED binuptime(&bt2); 40009d10: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED 40009d14: 7f ff ff 22 call 4000999c <_Timecounter_Binuptime> <== NOT EXECUTED 40009d18: c4 3f bf e8 std %g2, [ %fp + -24 ] <== NOT EXECUTED 40009d1c: c4 1f bf f8 ldd [ %fp + -8 ], %g2 40009d20: f8 1f bf e8 ldd [ %fp + -24 ], %i4 40009d24: b6 a7 40 03 subcc %i5, %g3, %i3 40009d28: b4 e7 00 02 subxcc %i4, %g2, %i2 40009d2c: 0a 80 00 12 bcs 40009d74 <_Timecounter_Set_clock+0x74> 40009d30: 82 10 20 00 clr %g1 _bt->frac -= _bt2->frac; 40009d34: f4 3f bf e8 std %i2, [ %fp + -24 ] if (_u < _bt->frac) 40009d38: 80 a0 60 00 cmp %g1, 0 40009d3c: 02 80 00 05 be 40009d50 <_Timecounter_Set_clock+0x50> 40009d40: f4 1f bf e0 ldd [ %fp + -32 ], %i2 _bt->sec--; 40009d44: c4 1f bf e0 ldd [ %fp + -32 ], %g2 40009d48: b6 80 ff ff addcc %g3, -1, %i3 40009d4c: b4 40 bf ff addx %g2, -1, %i2 _bt->sec -= _bt2->sec; 40009d50: f8 1f bf f0 ldd [ %fp + -16 ], %i4 40009d54: 86 a6 c0 1d subcc %i3, %i5, %g3 40009d58: 84 66 80 1c subx %i2, %i4, %g2 _Timecounter_Windup(&bt, lock_context); 40009d5c: 92 10 00 19 mov %i1, %o1 40009d60: c4 3f bf e0 std %g2, [ %fp + -32 ] 40009d64: 7f ff fe 5b call 400096d0 <_Timecounter_Windup> 40009d68: 90 07 bf e0 add %fp, -32, %o0 } 40009d6c: 81 c7 e0 08 ret 40009d70: 81 e8 00 00 restore 40009d74: 10 bf ff f0 b 40009d34 <_Timecounter_Set_clock+0x34> 40009d78: 82 10 20 01 mov 1, %g1 =============================================================================== 40008b3c <_Timecounter_Tick>: } } #else /* __rtems__ */ void _Timecounter_Tick(void) { 40008b3c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Per_CPU_Control *cpu_self = _Per_CPU_Get(); 40008b40: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED 40008b44: 91 d0 20 09 ta 9 <== NOT EXECUTED _Timecounter_Acquire(&lock_context); 40008b48: c2 27 bf fc st %g1, [ %fp + -4 ] _Timecounter_Windup(new_boottimebin, &lock_context); 40008b4c: 90 10 20 00 clr %o0 40008b50: 7f ff fe 9d call 400085c4 <_Timecounter_Windup> 40008b54: 92 07 bf fc add %fp, -4, %o1 if (_Per_CPU_Is_boot_processor(cpu_self)) { tc_windup(NULL); } _Watchdog_Tick(cpu_self); 40008b58: 40 00 0d 67 call 4000c0f4 <_Watchdog_Tick> 40008b5c: 90 10 00 1d mov %i5, %o0 } 40008b60: 81 c7 e0 08 ret 40008b64: 81 e8 00 00 restore =============================================================================== 40008b68 <_Timecounter_Tick_simple>: void _Timecounter_Tick_simple(uint32_t delta, uint32_t offset, ISR_lock_Context *lock_context) { 40008b68: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED struct bintime bt; struct timehands *th; uint32_t ogen; th = timehands; 40008b6c: 03 10 00 6d sethi %hi(0x4001b400), %g1 40008b70: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 4001b500 ogen = th->th_generation; th->th_offset_count = offset; 40008b74: f2 20 60 18 st %i1, [ %g1 + 0x18 ] bintime_addx(&th->th_offset, th->th_scale * delta); 40008b78: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 40008b7c: f8 18 60 28 ldd [ %g1 + 0x28 ], %i4 40008b80: c6 00 60 10 ld [ %g1 + 0x10 ], %g3 40008b84: 86 58 c0 18 smul %g3, %i0, %g3 ogen = th->th_generation; 40008b88: c8 00 60 70 ld [ %g1 + 0x70 ], %g4 bintime_addx(&th->th_offset, th->th_scale * delta); 40008b8c: b2 50 80 18 umul %g2, %i0, %i1 40008b90: b1 40 00 00 rd %y, %i0 40008b94: b0 00 c0 18 add %g3, %i0, %i0 40008b98: 96 86 40 1d addcc %i1, %i5, %o3 40008b9c: 94 c6 00 1c addxcc %i0, %i4, %o2 40008ba0: 0a 80 00 30 bcs 40008c60 <_Timecounter_Tick_simple+0xf8> 40008ba4: 84 10 20 00 clr %g2 if (_u > _bt->frac) 40008ba8: 80 a0 a0 00 cmp %g2, 0 40008bac: 12 80 00 28 bne 40008c4c <_Timecounter_Tick_simple+0xe4> 40008bb0: d4 38 60 28 std %o2, [ %g1 + 0x28 ] 40008bb4: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4 40008bb8: c4 18 60 68 ldd [ %g1 + 0x68 ], %g2 40008bbc: b2 80 c0 0b addcc %g3, %o3, %i1 40008bc0: b0 c0 80 0a addxcc %g2, %o2, %i0 _bt->sec++; 40008bc4: 0a 80 00 29 bcs 40008c68 <_Timecounter_Tick_simple+0x100> 40008bc8: 96 83 60 01 addcc %o5, 1, %o3 bt = th->th_offset; 40008bcc: 94 10 00 0c mov %o4, %o2 40008bd0: 96 10 00 0d mov %o5, %o3 _bt->sec += _bt2->sec; 40008bd4: c4 18 60 60 ldd [ %g1 + 0x60 ], %g2 40008bd8: ba 82 c0 03 addcc %o3, %g3, %i5 bintime_add(&bt, &th->th_boottime); /* Update the UTC timestamps used by the get*() functions. */ th->th_bintime = bt; 40008bdc: f0 38 60 38 std %i0, [ %g1 + 0x38 ] 40008be0: b8 42 80 02 addx %o2, %g2, %i4 _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40008be4: 15 00 03 d0 sethi %hi(0xf4000), %o2 _ts->tv_nsec = ((uint64_t)1000000000 * 40008be8: 05 0e e6 b2 sethi %hi(0x3b9ac800), %g2 _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40008bec: 94 12 a2 40 or %o2, 0x240, %o2 _ts->tv_nsec = ((uint64_t)1000000000 * 40008bf0: 84 10 a2 00 or %g2, 0x200, %g2 _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40008bf4: 96 56 00 0a umul %i0, %o2, %o3 40008bf8: 95 40 00 00 rd %y, %o2 _ts->tv_nsec = ((uint64_t)1000000000 * 40008bfc: 86 56 00 02 umul %i0, %g2, %g3 40008c00: 85 40 00 00 rd %y, %g2 40008c04: f8 38 60 30 std %i4, [ %g1 + 0x30 ] /* * Now that the struct timehands is again consistent, set the new * generation number, making sure to not make it zero. */ if (++ogen == 0) 40008c08: 88 81 20 01 inccc %g4 _tv->tv_sec = _bt->sec; 40008c0c: f8 38 60 40 std %i4, [ %g1 + 0x40 ] _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40008c10: d4 20 60 48 st %o2, [ %g1 + 0x48 ] _ts->tv_sec = _bt->sec; 40008c14: f8 38 60 50 std %i4, [ %g1 + 0x50 ] 40008c18: 12 80 00 03 bne 40008c24 <_Timecounter_Tick_simple+0xbc> <== ALWAYS TAKEN 40008c1c: c4 20 60 58 st %g2, [ %g1 + 0x58 ] ogen = 1; 40008c20: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED th->th_generation = ogen; /* Go live with the new struct timehands. */ time_second = th->th_microtime.tv_sec; 40008c24: 05 10 00 6d sethi %hi(0x4001b400), %g2 40008c28: f8 38 a0 f0 std %i4, [ %g2 + 0xf0 ] ! 4001b4f0 <_Timecounter_Time_second> th->th_generation = ogen; 40008c2c: c8 20 60 70 st %g4, [ %g1 + 0x70 ] time_uptime = th->th_offset.sec; 40008c30: 03 10 00 6d sethi %hi(0x4001b400), %g1 40008c34: da 20 60 e8 st %o5, [ %g1 + 0xe8 ] ! 4001b4e8 <_Timecounter_Time_uptime> register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40008c38: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40008c3c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40008c40: 01 00 00 00 nop _Timecounter_Release(lock_context); _Watchdog_Tick(_Per_CPU_Get_snapshot()); 40008c44: 40 00 0d 2c call 4000c0f4 <_Watchdog_Tick> 40008c48: 91 e8 00 06 restore %g0, %g6, %o0 _bt->sec++; 40008c4c: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2 40008c50: 9a 80 e0 01 addcc %g3, 1, %o5 40008c54: 98 40 a0 00 addx %g2, 0, %o4 40008c58: 10 bf ff d8 b 40008bb8 <_Timecounter_Tick_simple+0x50> 40008c5c: d8 38 60 20 std %o4, [ %g1 + 0x20 ] 40008c60: 10 bf ff d2 b 40008ba8 <_Timecounter_Tick_simple+0x40> 40008c64: 84 10 20 01 mov 1, %g2 _bt->sec++; 40008c68: 10 bf ff db b 40008bd4 <_Timecounter_Tick_simple+0x6c> 40008c6c: 94 43 20 00 addx %o4, 0, %o2 =============================================================================== 4000baf4 <_Timespec_Add_to>: uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) { 4000baf4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED uint32_t seconds = add->tv_sec; 4000baf8: f8 1e 40 00 ldd [ %i1 ], %i4 <== NOT EXECUTED /* Add the basics */ time->tv_sec += add->tv_sec; time->tv_nsec += add->tv_nsec; 4000bafc: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED time->tv_sec += add->tv_sec; 4000bb00: d8 1e 00 00 ldd [ %i0 ], %o4 <== NOT EXECUTED time->tv_nsec += add->tv_nsec; 4000bb04: c4 06 20 08 ld [ %i0 + 8 ], %g2 <== NOT EXECUTED time->tv_sec += add->tv_sec; 4000bb08: b6 87 40 0d addcc %i5, %o5, %i3 <== NOT EXECUTED time->tv_nsec += add->tv_nsec; 4000bb0c: 84 00 80 01 add %g2, %g1, %g2 <== NOT EXECUTED time->tv_sec += add->tv_sec; 4000bb10: b4 47 00 0c addx %i4, %o4, %i2 <== NOT EXECUTED time->tv_nsec += add->tv_nsec; 4000bb14: c4 26 20 08 st %g2, [ %i0 + 8 ] <== NOT EXECUTED uint32_t seconds = add->tv_sec; 4000bb18: 88 10 00 1d mov %i5, %g4 <== NOT EXECUTED time->tv_sec += add->tv_sec; 4000bb1c: f4 3e 00 00 std %i2, [ %i0 ] <== NOT EXECUTED /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 4000bb20: 3b 0e e6 b2 sethi %hi(0x3b9ac800), %i5 <== NOT EXECUTED 4000bb24: ba 17 61 ff or %i5, 0x1ff, %i5 ! 3b9ac9ff <== NOT EXECUTED 4000bb28: 80 a0 80 1d cmp %g2, %i5 <== NOT EXECUTED 4000bb2c: 08 80 00 10 bleu 4000bb6c <_Timespec_Add_to+0x78> <== NOT EXECUTED 4000bb30: 82 10 00 02 mov %g2, %g1 4000bb34: 86 86 e0 01 addcc %i3, 1, %g3 time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 4000bb38: 39 31 19 4d sethi %hi(0xc4653400), %i4 4000bb3c: 84 46 a0 00 addx %i2, 0, %g2 4000bb40: b8 17 22 00 or %i4, 0x200, %i4 time->tv_sec++; 4000bb44: b6 10 00 03 mov %g3, %i3 4000bb48: 86 80 e0 01 inccc %g3 4000bb4c: b4 10 00 02 mov %g2, %i2 time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 4000bb50: 82 00 40 1c add %g1, %i4, %g1 4000bb54: 84 40 a0 00 addx %g2, 0, %g2 while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 4000bb58: 80 a0 40 1d cmp %g1, %i5 4000bb5c: 18 bf ff fa bgu 4000bb44 <_Timespec_Add_to+0x50> <== NEVER TAKEN 4000bb60: 88 01 20 01 inc %g4 4000bb64: c2 26 20 08 st %g1, [ %i0 + 8 ] 4000bb68: f4 3e 00 00 std %i2, [ %i0 ] seconds++; } return seconds; } 4000bb6c: 81 c7 e0 08 ret 4000bb70: 91 e8 00 04 restore %g0, %g4, %o0 =============================================================================== 4000d38c <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 4000d38c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec; 4000d390: de 06 60 08 ld [ %i1 + 8 ], %o7 <== NOT EXECUTED right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 4000d394: c8 06 40 00 ld [ %i1 ], %g4 <== NOT EXECUTED 4000d398: c4 06 60 04 ld [ %i1 + 4 ], %g2 <== NOT EXECUTED 4000d39c: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 <== NOT EXECUTED right += rhs->tv_nsec; 4000d3a0: b9 3b e0 1f sra %o7, 0x1f, %i4 <== NOT EXECUTED right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 4000d3a4: 82 10 62 00 or %g1, 0x200, %g1 <== NOT EXECUTED 4000d3a8: 86 50 80 01 umul %g2, %g1, %g3 <== NOT EXECUTED 4000d3ac: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED 4000d3b0: 88 59 00 01 smul %g4, %g1, %g4 <== NOT EXECUTED right += rhs->tv_nsec; 4000d3b4: 96 83 c0 03 addcc %o7, %g3, %o3 <== NOT EXECUTED right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 4000d3b8: 84 01 00 02 add %g4, %g2, %g2 <== NOT EXECUTED right += rhs->tv_nsec; 4000d3bc: 94 47 00 02 addx %i4, %g2, %o2 <== NOT EXECUTED if ( right == 0 ) { 4000d3c0: 80 92 80 0b orcc %o2, %o3, %g0 <== NOT EXECUTED 4000d3c4: 02 80 00 20 be 4000d444 <_Timespec_Divide+0xb8> <== NOT EXECUTED 4000d3c8: 11 00 00 61 sethi %hi(0x18400), %o0 left += lhs->tv_nsec; 4000d3cc: f2 06 20 08 ld [ %i0 + 8 ], %i1 left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 4000d3d0: c8 06 00 00 ld [ %i0 ], %g4 4000d3d4: c4 06 20 04 ld [ %i0 + 4 ], %g2 4000d3d8: 86 50 80 01 umul %g2, %g1, %g3 4000d3dc: 85 40 00 00 rd %y, %g2 4000d3e0: 88 59 00 01 smul %g4, %g1, %g4 left += lhs->tv_nsec; 4000d3e4: b9 3e 60 1f sra %i1, 0x1f, %i4 left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 4000d3e8: 84 01 00 02 add %g4, %g2, %g2 left += lhs->tv_nsec; 4000d3ec: b2 86 40 03 addcc %i1, %g3, %i1 4000d3f0: b0 47 00 02 addx %i4, %g2, %i0 * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 4000d3f4: 90 12 22 a0 or %o0, 0x2a0, %o0 4000d3f8: 82 5e 00 08 smul %i0, %o0, %g1 4000d3fc: 92 56 40 08 umul %i1, %o0, %o1 4000d400: 91 40 00 00 rd %y, %o0 4000d404: 40 00 0e 34 call 40010cd4 <__udivdi3> 4000d408: 90 00 40 08 add %g1, %o0, %o0 *ival_percentage = answer / 1000; 4000d40c: 94 10 20 00 clr %o2 answer = (left * 100000) / right; 4000d410: b8 10 00 08 mov %o0, %i4 4000d414: ba 10 00 09 mov %o1, %i5 *ival_percentage = answer / 1000; 4000d418: 40 00 0e 2f call 40010cd4 <__udivdi3> 4000d41c: 96 10 23 e8 mov 0x3e8, %o3 4000d420: d2 26 80 00 st %o1, [ %i2 ] *fval_percentage = answer % 1000; 4000d424: 94 10 20 00 clr %o2 4000d428: 96 10 23 e8 mov 0x3e8, %o3 4000d42c: 90 10 00 1c mov %i4, %o0 4000d430: 40 00 0e a2 call 40010eb8 <__umoddi3> 4000d434: 92 10 00 1d mov %i5, %o1 4000d438: d2 26 c0 00 st %o1, [ %i3 ] } 4000d43c: 81 c7 e0 08 ret 4000d440: 81 e8 00 00 restore *ival_percentage = 0; 4000d444: c0 26 80 00 clr [ %i2 ] *fval_percentage = 0; 4000d448: c0 26 c0 00 clr [ %i3 ] return; 4000d44c: 81 c7 e0 08 ret 4000d450: 81 e8 00 00 restore =============================================================================== 4000d830 <_Timespec_Divide_by_integer>: void _Timespec_Divide_by_integer( const struct timespec *time, uint32_t iterations, struct timespec *result ) { 4000d830: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ t = time->tv_sec; t *= TOD_NANOSECONDS_PER_SECOND; t += time->tv_nsec; 4000d834: fa 06 20 08 ld [ %i0 + 8 ], %i5 <== NOT EXECUTED t = time->tv_sec; 4000d838: c6 06 00 00 ld [ %i0 ], %g3 <== NOT EXECUTED 4000d83c: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED t += time->tv_nsec; 4000d840: 91 3f 60 1f sra %i5, 0x1f, %o0 <== NOT EXECUTED t *= TOD_NANOSECONDS_PER_SECOND; 4000d844: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 <== NOT EXECUTED 4000d848: 82 10 62 00 or %g1, 0x200, %g1 ! 3b9aca00 <== NOT EXECUTED 4000d84c: 88 58 c0 01 smul %g3, %g1, %g4 <== NOT EXECUTED 4000d850: 86 50 80 01 umul %g2, %g1, %g3 <== NOT EXECUTED 4000d854: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED /* * Divide to get nanoseconds per iteration */ t /= iterations; 4000d858: ba 87 40 03 addcc %i5, %g3, %i5 <== NOT EXECUTED t *= TOD_NANOSECONDS_PER_SECOND; 4000d85c: 84 01 00 02 add %g4, %g2, %g2 <== NOT EXECUTED t /= iterations; 4000d860: 94 10 20 00 clr %o2 <== NOT EXECUTED 4000d864: b8 42 00 02 addx %o0, %g2, %i4 <== NOT EXECUTED 4000d868: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED 4000d86c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED 4000d870: 40 00 0d e0 call 40010ff0 <__udivdi3> <== NOT EXECUTED 4000d874: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED /* * Put it back in the timespec result */ result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 4000d878: 94 10 20 00 clr %o2 t /= iterations; 4000d87c: b8 10 00 08 mov %o0, %i4 4000d880: ba 10 00 09 mov %o1, %i5 result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 4000d884: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 4000d888: 40 00 0d da call 40010ff0 <__udivdi3> 4000d88c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 4000d890: d0 3e 80 00 std %o0, [ %i2 ] result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND; 4000d894: 94 10 20 00 clr %o2 4000d898: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 4000d89c: 90 10 00 1c mov %i4, %o0 4000d8a0: 96 12 e2 00 or %o3, 0x200, %o3 4000d8a4: 40 00 0e 4c call 400111d4 <__umoddi3> 4000d8a8: 92 10 00 1d mov %i5, %o1 4000d8ac: d2 26 a0 08 st %o1, [ %i2 + 8 ] } 4000d8b0: 81 c7 e0 08 ret 4000d8b4: 81 e8 00 00 restore =============================================================================== 4000c4bc <_Timespec_From_ticks>: struct timespec *time ) { uint32_t usecs; usecs = ticks * rtems_configuration_get_microseconds_per_tick(); 4000c4bc: 03 10 00 5c sethi %hi(0x40017000), %g1 <== NOT EXECUTED 4000c4c0: c2 00 62 1c ld [ %g1 + 0x21c ], %g1 ! 4001721c <== NOT EXECUTED 4000c4c4: 90 5a 00 01 smul %o0, %g1, %o0 <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 4000c4c8: 05 00 03 d0 sethi %hi(0xf4000), %g2 <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 4000c4cc: 03 10 c6 f7 sethi %hi(0x431bdc00), %g1 <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 4000c4d0: 84 10 a2 40 or %g2, 0x240, %g2 <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 4000c4d4: 82 10 62 83 or %g1, 0x283, %g1 <== NOT EXECUTED 4000c4d8: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED 4000c4dc: 80 52 00 01 umul %o0, %g1, %g0 <== NOT EXECUTED 4000c4e0: 83 40 00 00 rd %y, %g1 <== NOT EXECUTED 4000c4e4: 83 30 60 12 srl %g1, 0x12, %g1 <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 4000c4e8: 84 58 40 02 smul %g1, %g2, %g2 <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 4000c4ec: c2 22 60 04 st %g1, [ %o1 + 4 ] <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 4000c4f0: 90 22 00 02 sub %o0, %g2, %o0 <== NOT EXECUTED 4000c4f4: 90 5a 23 e8 smul %o0, 0x3e8, %o0 <== NOT EXECUTED TOD_NANOSECONDS_PER_MICROSECOND; } 4000c4f8: 81 c3 e0 08 retl <== NOT EXECUTED 4000c4fc: d0 22 60 08 st %o0, [ %o1 + 8 ] =============================================================================== 400104bc <_Timespec_Get_as_nanoseconds>: #include uint64_t _Timespec_Get_as_nanoseconds( const struct timespec *time ) { 400104bc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED return ( ((uint64_t) time->tv_sec) * 1000000000ULL ) + time->tv_nsec; 400104c0: fa 06 20 08 ld [ %i0 + 8 ], %i5 400104c4: c8 06 00 00 ld [ %i0 ], %g4 400104c8: c4 06 20 04 ld [ %i0 + 4 ], %g2 400104cc: b1 3f 60 1f sra %i5, 0x1f, %i0 400104d0: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 400104d4: 82 10 62 00 or %g1, 0x200, %g1 ! 3b9aca00 400104d8: 86 50 80 01 umul %g2, %g1, %g3 400104dc: 85 40 00 00 rd %y, %g2 400104e0: 88 59 00 01 smul %g4, %g1, %g4 } 400104e4: 9a 80 c0 1d addcc %g3, %i5, %o5 return ( ((uint64_t) time->tv_sec) * 1000000000ULL ) + time->tv_nsec; 400104e8: 84 01 00 02 add %g4, %g2, %g2 } 400104ec: b2 10 00 0d mov %o5, %i1 400104f0: 98 40 80 18 addx %g2, %i0, %o4 400104f4: 81 c7 e0 08 ret 400104f8: 91 e8 00 0c restore %g0, %o4, %o0 =============================================================================== 4000c088 <_Timespec_Is_valid>: bool _Timespec_Is_valid( const struct timespec *time ) { if ( !time ) 4000c088: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000c08c: 02 80 00 0b be 4000c0b8 <_Timespec_Is_valid+0x30> <== NOT EXECUTED 4000c090: 82 10 20 00 clr %g1 return false; if ( time->tv_sec < 0 ) 4000c094: c4 02 00 00 ld [ %o0 ], %g2 4000c098: 80 a0 a0 00 cmp %g2, 0 4000c09c: 06 80 00 07 bl 4000c0b8 <_Timespec_Is_valid+0x30> 4000c0a0: 01 00 00 00 nop return false; if ( time->tv_nsec < 0 ) return false; if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) 4000c0a4: c4 02 20 08 ld [ %o0 + 8 ], %g2 4000c0a8: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 4000c0ac: 82 10 61 ff or %g1, 0x1ff, %g1 ! 3b9ac9ff 4000c0b0: 80 a0 40 02 cmp %g1, %g2 4000c0b4: 82 60 3f ff subx %g0, -1, %g1 return false; return true; } 4000c0b8: 81 c3 e0 08 retl 4000c0bc: 90 08 60 01 and %g1, 1, %o0 =============================================================================== 40010bc0 <_Timespec_Less_than>: bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec < rhs->tv_sec ) 40010bc0: c4 02 00 00 ld [ %o0 ], %g2 40010bc4: c2 02 40 00 ld [ %o1 ], %g1 40010bc8: c8 02 20 04 ld [ %o0 + 4 ], %g4 40010bcc: 80 a0 40 02 cmp %g1, %g2 40010bd0: 14 80 00 13 bg 40010c1c <_Timespec_Less_than+0x5c> <== NEVER TAKEN 40010bd4: c6 02 60 04 ld [ %o1 + 4 ], %g3 40010bd8: 02 80 00 0f be 40010c14 <_Timespec_Less_than+0x54> <== ALWAYS TAKEN 40010bdc: 80 a0 c0 04 cmp %g3, %g4 return true; if ( lhs->tv_sec > rhs->tv_sec ) 40010be0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 40010be4: 34 80 00 0a bg,a 40010c0c <_Timespec_Less_than+0x4c> <== NEVER TAKEN 40010be8: 90 10 20 00 clr %o0 <== NOT EXECUTED 40010bec: 02 80 00 0f be 40010c28 <_Timespec_Less_than+0x68> <== ALWAYS TAKEN 40010bf0: 80 a1 00 03 cmp %g4, %g3 return false; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) 40010bf4: c4 02 20 08 ld [ %o0 + 8 ], %g2 <== NOT EXECUTED 40010bf8: c2 02 60 08 ld [ %o1 + 8 ], %g1 40010bfc: 80 a0 80 01 cmp %g2, %g1 40010c00: 06 80 00 03 bl 40010c0c <_Timespec_Less_than+0x4c> 40010c04: 90 10 20 01 mov 1, %o0 return false; 40010c08: 90 10 20 00 clr %o0 return true; return false; } 40010c0c: 81 c3 e0 08 retl 40010c10: 90 0a 20 01 and %o0, 1, %o0 if ( lhs->tv_sec < rhs->tv_sec ) 40010c14: 08 bf ff f4 bleu 40010be4 <_Timespec_Less_than+0x24> 40010c18: 80 a0 80 01 cmp %g2, %g1 return true; 40010c1c: 90 10 20 01 mov 1, %o0 } 40010c20: 81 c3 e0 08 retl 40010c24: 90 0a 20 01 and %o0, 1, %o0 if ( lhs->tv_sec > rhs->tv_sec ) 40010c28: 28 bf ff f4 bleu,a 40010bf8 <_Timespec_Less_than+0x38> 40010c2c: c4 02 20 08 ld [ %o0 + 8 ], %g2 return false; 40010c30: 10 bf ff f7 b 40010c0c <_Timespec_Less_than+0x4c> 40010c34: 90 10 20 00 clr %o0 =============================================================================== 40010c38 <_Timespec_Subtract>: void _Timespec_Subtract( const struct timespec *start, const struct timespec *end, struct timespec *result ) { 40010c38: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 40010c3c: d8 1e 00 00 ldd [ %i0 ], %o4 <== NOT EXECUTED 40010c40: d4 1e 40 00 ldd [ %i1 ], %o2 40010c44: ba a2 c0 0d subcc %o3, %o5, %i5 if (end->tv_nsec < start->tv_nsec) { 40010c48: c2 06 60 08 ld [ %i1 + 8 ], %g1 40010c4c: c4 06 20 08 ld [ %i0 + 8 ], %g2 40010c50: b8 62 80 0c subx %o2, %o4, %i4 40010c54: 80 a0 40 02 cmp %g1, %g2 40010c58: 26 80 00 07 bl,a 40010c74 <_Timespec_Subtract+0x3c> 40010c5c: b2 87 7f ff addcc %i5, -1, %i1 result->tv_sec = end->tv_sec - start->tv_sec - 1; result->tv_nsec = (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec; } else { result->tv_sec = end->tv_sec - start->tv_sec; result->tv_nsec = end->tv_nsec - start->tv_nsec; 40010c60: 82 20 40 02 sub %g1, %g2, %g1 result->tv_sec = end->tv_sec - start->tv_sec; 40010c64: f8 3e 80 00 std %i4, [ %i2 ] result->tv_nsec = end->tv_nsec - start->tv_nsec; 40010c68: c2 26 a0 08 st %g1, [ %i2 + 8 ] } } 40010c6c: 81 c7 e0 08 ret 40010c70: 81 e8 00 00 restore (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec; 40010c74: 82 20 40 02 sub %g1, %g2, %g1 result->tv_sec = end->tv_sec - start->tv_sec - 1; 40010c78: b0 47 3f ff addx %i4, -1, %i0 (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec; 40010c7c: 05 0e e6 b2 sethi %hi(0x3b9ac800), %g2 result->tv_sec = end->tv_sec - start->tv_sec - 1; 40010c80: f0 3e 80 00 std %i0, [ %i2 ] (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec; 40010c84: 84 10 a2 00 or %g2, 0x200, %g2 40010c88: 82 00 40 02 add %g1, %g2, %g1 result->tv_nsec = 40010c8c: c2 26 a0 08 st %g1, [ %i2 + 8 ] 40010c90: 81 c7 e0 08 ret 40010c94: 81 e8 00 00 restore =============================================================================== 40026fc8 <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 40026fc8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED uint32_t ticks; uint32_t nanoseconds_per_tick; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 40026fcc: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED 40026fd0: fa 06 20 04 ld [ %i0 + 4 ], %i5 <== NOT EXECUTED 40026fd4: 80 90 40 1d orcc %g1, %i5, %g0 <== NOT EXECUTED 40026fd8: 12 80 00 06 bne 40026ff0 <_Timespec_To_ticks+0x28> <== NOT EXECUTED 40026fdc: 01 00 00 00 nop 40026fe0: c2 06 20 08 ld [ %i0 + 8 ], %g1 40026fe4: 80 a0 60 00 cmp %g1, 0 40026fe8: 02 80 00 11 be 4002702c <_Timespec_To_ticks+0x64> 40026fec: 90 10 20 00 clr %o0 /** * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 40026ff0: 40 00 5c 16 call 4003e048 40026ff4: 01 00 00 00 nop nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick(); ticks += time->tv_nsec / nanoseconds_per_tick; 40026ff8: c2 06 20 08 ld [ %i0 + 8 ], %g1 nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick(); 40026ffc: 05 10 01 7a sethi %hi(0x4005e800), %g2 40027000: c4 00 a0 a4 ld [ %g2 + 0xa4 ], %g2 ! 4005e8a4 <_Watchdog_Nanoseconds_per_tick> ticks += time->tv_nsec / nanoseconds_per_tick; 40027004: 81 80 20 00 wr %g0, %y 40027008: 01 00 00 00 nop 4002700c: 01 00 00 00 nop 40027010: 01 00 00 00 nop 40027014: b0 70 40 02 udiv %g1, %g2, %i0 ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 40027018: 90 5a 00 1d smul %o0, %i5, %o0 if ( (time->tv_nsec % nanoseconds_per_tick) != 0 ) 4002701c: 84 5e 00 02 smul %i0, %g2, %g2 40027020: 82 20 40 02 sub %g1, %g2, %g1 ticks += 1; 40027024: 80 a0 00 01 cmp %g0, %g1 40027028: 90 42 00 18 addx %o0, %i0, %o0 return ticks; } 4002702c: 81 c7 e0 08 ret 40027030: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 4000bc18 <_User_extensions_Add_set>: __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000bc18: 91 d0 20 09 ta 9 <== NOT EXECUTED old_last = tail->previous; 4000bc1c: 05 10 00 6d sethi %hi(0x4001b400), %g2 4000bc20: 84 10 a1 d8 or %g2, 0x1d8, %g2 ! 4001b5d8 <_User_extensions_List> 4000bc24: c6 00 a0 08 ld [ %g2 + 8 ], %g3 the_node->next = tail; 4000bc28: 88 00 a0 04 add %g2, 4, %g4 4000bc2c: c8 22 00 00 st %g4, [ %o0 ] tail->previous = the_node; 4000bc30: d0 20 a0 08 st %o0, [ %g2 + 8 ] old_last->next = the_node; 4000bc34: d0 20 c0 00 st %o0, [ %g3 ] the_node->previous = old_last; 4000bc38: c6 22 20 04 st %g3, [ %o0 + 4 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000bc3c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000bc40: 01 00 00 00 nop /* * If a switch handler is present, append it to the switch chain. */ if ( the_extension->Callouts.thread_switch != NULL ) { 4000bc44: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 4000bc48: 80 a0 60 00 cmp %g1, 0 4000bc4c: 02 80 00 0f be 4000bc88 <_User_extensions_Add_set+0x70> 4000bc50: 01 00 00 00 nop ISR_Level level; the_extension->Switch.thread_switch = 4000bc54: c2 22 20 10 st %g1, [ %o0 + 0x10 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000bc58: 91 d0 20 09 ta 9 <== NOT EXECUTED old_last = tail->previous; 4000bc5c: 05 10 00 6d sethi %hi(0x4001b400), %g2 <== NOT EXECUTED 4000bc60: 84 10 a2 3c or %g2, 0x23c, %g2 ! 4001b63c <_User_extensions_Switches_list> <== NOT EXECUTED 4000bc64: c6 00 a0 08 ld [ %g2 + 8 ], %g3 <== NOT EXECUTED the_node->next = tail; 4000bc68: 88 00 a0 04 add %g2, 4, %g4 <== NOT EXECUTED 4000bc6c: c8 22 20 08 st %g4, [ %o0 + 8 ] <== NOT EXECUTED the_extension->Callouts.thread_switch; _Per_CPU_Acquire_all( level ); _Chain_Initialize_node( &the_extension->Switch.Node ); 4000bc70: 88 02 20 08 add %o0, 8, %g4 <== NOT EXECUTED tail->previous = the_node; 4000bc74: c8 20 a0 08 st %g4, [ %g2 + 8 ] <== NOT EXECUTED old_last->next = the_node; 4000bc78: c8 20 c0 00 st %g4, [ %g3 ] <== NOT EXECUTED the_node->previous = old_last; 4000bc7c: c6 22 20 0c st %g3, [ %o0 + 0xc ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000bc80: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000bc84: 01 00 00 00 nop &_User_extensions_Switches_list, &the_extension->Switch.Node ); _Per_CPU_Release_all( level ); } } 4000bc88: 81 c3 e0 08 retl 4000bc8c: 01 00 00 00 nop =============================================================================== 4000bd80 <_User_extensions_Fatal_visitor>: void _User_extensions_Fatal_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 4000bd80: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED User_extensions_fatal_extension callout = callouts->fatal; 4000bd84: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1 <== NOT EXECUTED if ( callout != NULL ) { 4000bd88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000bd8c: 02 80 00 06 be 4000bda4 <_User_extensions_Fatal_visitor+0x24> <== NOT EXECUTED 4000bd90: 01 00 00 00 nop const User_extensions_Fatal_context *ctx = arg; (*callout)( ctx->source, false, ctx->error ); 4000bd94: d4 06 60 04 ld [ %i1 + 4 ], %o2 4000bd98: d0 06 40 00 ld [ %i1 ], %o0 4000bd9c: 9f c0 40 00 call %g1 4000bda0: 92 10 20 00 clr %o1 } } 4000bda4: 81 c7 e0 08 ret 4000bda8: 81 e8 00 00 restore =============================================================================== 4000bf48 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 4000bf48: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED User_extensions_Switch_control *initial_extension_switch_controls; const User_extensions_Table *initial_table; uint32_t n; uint32_t i; n = rtems_configuration_get_number_of_initial_extensions(); 4000bf4c: 39 10 00 63 sethi %hi(0x40018c00), %i4 4000bf50: b8 17 20 e8 or %i4, 0xe8, %i4 ! 40018ce8 4000bf54: f6 07 20 34 ld [ %i4 + 0x34 ], %i3 initial_extension_switch_controls = _Workspace_Allocate_or_fatal_error( n * sizeof( *initial_extension_switch_controls ) 4000bf58: 87 2e e0 01 sll %i3, 1, %g3 4000bf5c: 86 00 c0 1b add %g3, %i3, %g3 4000bf60: bb 28 e0 02 sll %g3, 2, %i5 initial_extension_switch_controls = _Workspace_Allocate_or_fatal_error( 4000bf64: 40 00 01 2b call 4000c410 <_Workspace_Allocate_or_fatal_error> 4000bf68: 90 10 00 1d mov %i5, %o0 ); initial_table = rtems_configuration_get_user_extension_table(); for ( i = 0 ; i < n ; ++i ) { 4000bf6c: 80 a6 e0 00 cmp %i3, 0 4000bf70: 02 80 00 15 be 4000bfc4 <_User_extensions_Handler_initialization+0x7c> <== NEVER TAKEN 4000bf74: c2 07 20 38 ld [ %i4 + 0x38 ], %g1 old_last = tail->previous; 4000bf78: 09 10 00 6d sethi %hi(0x4001b400), %g4 4000bf7c: 86 02 00 1d add %o0, %i5, %g3 4000bf80: 88 11 22 3c or %g4, 0x23c, %g4 4000bf84: 82 00 60 10 add %g1, 0x10, %g1 the_node->next = tail; 4000bf88: ba 01 20 04 add %g4, 4, %i5 User_extensions_thread_switch_extension callout; callout = initial_table[ i ].thread_switch; 4000bf8c: c4 00 40 00 ld [ %g1 ], %g2 if ( callout != NULL ) { 4000bf90: 80 a0 a0 00 cmp %g2, 0 4000bf94: 22 80 00 09 be,a 4000bfb8 <_User_extensions_Handler_initialization+0x70> 4000bf98: 90 02 20 0c add %o0, 0xc, %o0 User_extensions_Switch_control *c; c = &initial_extension_switch_controls[ i ]; c->thread_switch = callout; 4000bf9c: c4 22 20 08 st %g2, [ %o0 + 8 ] old_last = tail->previous; 4000bfa0: c4 01 20 08 ld [ %g4 + 8 ], %g2 the_node->next = tail; 4000bfa4: fa 22 00 00 st %i5, [ %o0 ] tail->previous = the_node; 4000bfa8: d0 21 20 08 st %o0, [ %g4 + 8 ] old_last->next = the_node; 4000bfac: d0 20 80 00 st %o0, [ %g2 ] the_node->previous = old_last; 4000bfb0: c4 22 20 04 st %g2, [ %o0 + 4 ] 4000bfb4: 90 02 20 0c add %o0, 0xc, %o0 for ( i = 0 ; i < n ; ++i ) { 4000bfb8: 80 a2 00 03 cmp %o0, %g3 4000bfbc: 12 bf ff f4 bne 4000bf8c <_User_extensions_Handler_initialization+0x44> 4000bfc0: 82 00 60 24 add %g1, 0x24, %g1 _Chain_Initialize_node( &c->Node ); _Chain_Append_unprotected( &_User_extensions_Switches_list, &c->Node ); } } } 4000bfc4: 81 c7 e0 08 ret 4000bfc8: 81 e8 00 00 restore =============================================================================== 4000bdd0 <_User_extensions_Iterate>: void _User_extensions_Iterate( void *arg, User_extensions_Visitor visitor, Chain_Iterator_direction direction ) { 4000bdd0: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED User_extensions_Iterator iter; ISR_lock_Context lock_context; executing = _Thread_Get_executing(); initial_begin = rtems_configuration_get_user_extension_table(); 4000bdd4: 03 10 00 63 sethi %hi(0x40018c00), %g1 <== NOT EXECUTED 4000bdd8: 82 10 60 e8 or %g1, 0xe8, %g1 ! 40018ce8 initial_end = initial_begin + rtems_configuration_get_number_of_initial_extensions(); 4000bddc: c4 00 60 34 ld [ %g1 + 0x34 ], %g2 initial_begin = rtems_configuration_get_user_extension_table(); 4000bde0: e0 00 60 38 ld [ %g1 + 0x38 ], %l0 initial_begin + rtems_configuration_get_number_of_initial_extensions(); 4000bde4: bb 28 a0 03 sll %g2, 3, %i5 4000bde8: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4 4000bdec: ba 07 40 02 add %i5, %g2, %i5 if ( direction == CHAIN_ITERATOR_FORWARD ) { 4000bdf0: 80 a6 a0 00 cmp %i2, 0 initial_begin + rtems_configuration_get_number_of_initial_extensions(); 4000bdf4: bb 2f 60 02 sll %i5, 2, %i5 if ( direction == CHAIN_ITERATOR_FORWARD ) { 4000bdf8: 12 80 00 50 bne 4000bf38 <_User_extensions_Iterate+0x168> 4000bdfc: ba 04 00 1d add %l0, %i5, %i5 initial_current = initial_begin; while ( initial_current != initial_end ) { 4000be00: 80 a4 00 1d cmp %l0, %i5 4000be04: 02 80 00 0a be 4000be2c <_User_extensions_Iterate+0x5c> <== NEVER TAKEN 4000be08: b6 10 00 10 mov %l0, %i3 (*visitor)( executing, arg, initial_current ); 4000be0c: 94 10 00 1b mov %i3, %o2 4000be10: 92 10 00 18 mov %i0, %o1 4000be14: 9f c6 40 00 call %i1 4000be18: 90 10 00 1c mov %i4, %o0 ++initial_current; 4000be1c: b6 06 e0 24 add %i3, 0x24, %i3 while ( initial_current != initial_end ) { 4000be20: 80 a7 40 1b cmp %i5, %i3 4000be24: 12 bf ff fb bne 4000be10 <_User_extensions_Iterate+0x40> 4000be28: 94 10 00 1b mov %i3, %o2 } end = _Chain_Immutable_tail( &_User_extensions_List.Active ); 4000be2c: 37 10 00 6d sethi %hi(0x4001b400), %i3 <== NOT EXECUTED 4000be30: b6 16 e1 dc or %i3, 0x1dc, %i3 ! 4001b5dc <_User_extensions_List+0x4> <== NOT EXECUTED 4000be34: 84 06 ff fc add %i3, -4, %g2 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000be38: 91 d0 20 09 ta 9 <== NOT EXECUTED old_last = tail->previous; 4000be3c: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4 tail->previous = the_node; 4000be40: 86 07 bf ec add %fp, -20, %g3 the_node->next = tail; 4000be44: 9e 00 a0 10 add %g2, 0x10, %o7 tail->previous = the_node; 4000be48: c6 20 a0 14 st %g3, [ %g2 + 0x14 ] &the_iterator->Registry_node ); the_iterator->direction = direction; if ( direction == CHAIN_ITERATOR_FORWARD ) { 4000be4c: 80 a6 a0 00 cmp %i2, 0 the_node->next = tail; 4000be50: de 27 bf ec st %o7, [ %fp + -20 ] old_last->next = the_node; 4000be54: c6 21 00 00 st %g3, [ %g4 ] the_node->previous = old_last; 4000be58: c8 27 bf f0 st %g4, [ %fp + -16 ] if ( direction == CHAIN_ITERATOR_FORWARD ) { 4000be5c: 02 80 00 03 be 4000be68 <_User_extensions_Iterate+0x98> 4000be60: f4 27 bf f4 st %i2, [ %fp + -12 ] the_iterator->position = _Chain_Head( the_chain ); } else { the_iterator->position = _Chain_Tail( the_chain ); 4000be64: 84 00 a0 04 add %g2, 4, %g2 &_User_extensions_List.Iterators, &iter.Iterator, direction ); if ( executing != NULL ) { 4000be68: 80 a7 20 00 cmp %i4, 0 4000be6c: 02 80 00 05 be 4000be80 <_User_extensions_Iterate+0xb0> 4000be70: c4 27 bf f8 st %g2, [ %fp + -8 ] iter.previous = executing->last_user_extensions_iterator; 4000be74: c4 07 21 88 ld [ %i4 + 0x188 ], %g2 4000be78: c4 27 bf fc st %g2, [ %fp + -4 ] executing->last_user_extensions_iterator = &iter; 4000be7c: c6 27 21 88 st %g3, [ %i4 + 0x188 ] end = _Chain_Immutable_head( &_User_extensions_List.Active ); 4000be80: 10 80 00 0f b 4000bebc <_User_extensions_Iterate+0xec> 4000be84: 84 10 00 1a mov %i2, %g2 4000be88: d4 00 c0 00 ld [ %g3 ], %o2 } while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) { 4000be8c: 80 a6 c0 0a cmp %i3, %o2 4000be90: 02 80 00 13 be 4000bedc <_User_extensions_Iterate+0x10c> 4000be94: 80 a7 20 00 cmp %i4, 0 RTEMS_INLINE_ROUTINE void _Chain_Iterator_set_position( Chain_Iterator *the_iterator, Chain_Node *the_node ) { the_iterator->position = the_node; 4000be98: d4 27 bf f8 st %o2, [ %fp + -8 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000be9c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000bea0: 01 00 00 00 nop _Chain_Iterator_set_position( &iter.Iterator, node ); _User_extensions_Release( &lock_context ); extension = (const User_extensions_Control *) node; ( *visitor )( executing, arg, &extension->Callouts ); 4000bea4: 94 02 a0 14 add %o2, 0x14, %o2 4000bea8: 92 10 00 18 mov %i0, %o1 4000beac: 9f c6 40 00 call %i1 4000beb0: 90 10 00 1c mov %i4, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000beb4: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable_and_acquire( 4000beb8: c4 07 bf f4 ld [ %fp + -12 ], %g2 if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) { 4000bebc: 80 a0 a0 00 cmp %g2, 0 4000bec0: 02 bf ff f2 be 4000be88 <_User_extensions_Iterate+0xb8> 4000bec4: c6 07 bf f8 ld [ %fp + -8 ], %g3 4000bec8: d4 00 e0 04 ld [ %g3 + 4 ], %o2 while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) { 4000becc: 80 a6 c0 0a cmp %i3, %o2 4000bed0: 32 bf ff f3 bne,a 4000be9c <_User_extensions_Iterate+0xcc> 4000bed4: d4 27 bf f8 st %o2, [ %fp + -8 ] _User_extensions_Acquire( &lock_context ); } if ( executing != NULL ) { 4000bed8: 80 a7 20 00 cmp %i4, 0 4000bedc: 02 80 00 03 be 4000bee8 <_User_extensions_Iterate+0x118> 4000bee0: c4 07 bf fc ld [ %fp + -4 ], %g2 executing->last_user_extensions_iterator = iter.previous; 4000bee4: c4 27 21 88 st %g2, [ %i4 + 0x188 ] next = the_node->next; 4000bee8: c6 07 bf ec ld [ %fp + -20 ], %g3 previous = the_node->previous; 4000beec: c4 07 bf f0 ld [ %fp + -16 ], %g2 next->previous = previous; 4000bef0: c4 20 e0 04 st %g2, [ %g3 + 4 ] previous->next = next; 4000bef4: c6 20 80 00 st %g3, [ %g2 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000bef8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000befc: 01 00 00 00 nop _Chain_Iterator_destroy( &iter.Iterator ); _User_extensions_Release( &lock_context ); if ( direction == CHAIN_ITERATOR_BACKWARD ) { 4000bf00: 80 a6 a0 01 cmp %i2, 1 4000bf04: 02 80 00 09 be 4000bf28 <_User_extensions_Iterate+0x158> 4000bf08: 80 a4 00 1d cmp %l0, %i5 while ( initial_current != initial_begin ) { --initial_current; (*visitor)( executing, arg, initial_current ); } } } 4000bf0c: 81 c7 e0 08 ret 4000bf10: 81 e8 00 00 restore (*visitor)( executing, arg, initial_current ); 4000bf14: 92 10 00 18 mov %i0, %o1 4000bf18: 94 10 00 1d mov %i5, %o2 4000bf1c: 9f c6 40 00 call %i1 4000bf20: 90 10 00 1c mov %i4, %o0 while ( initial_current != initial_begin ) { 4000bf24: 80 a4 00 1d cmp %l0, %i5 4000bf28: 12 bf ff fb bne 4000bf14 <_User_extensions_Iterate+0x144> 4000bf2c: ba 07 7f dc add %i5, -36, %i5 } 4000bf30: 81 c7 e0 08 ret 4000bf34: 81 e8 00 00 restore end = _Chain_Immutable_head( &_User_extensions_List.Active ); 4000bf38: 05 10 00 6d sethi %hi(0x4001b400), %g2 4000bf3c: 84 10 a1 d8 or %g2, 0x1d8, %g2 ! 4001b5d8 <_User_extensions_List> 4000bf40: 10 bf ff be b 4000be38 <_User_extensions_Iterate+0x68> 4000bf44: b6 10 00 02 mov %g2, %i3 =============================================================================== 4000c5b8 <_User_extensions_Remove_set>: __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000c5b8: 91 d0 20 09 ta 9 <== NOT EXECUTED iter_node = _Chain_Head( &the_registry->Iterators ); 4000c5bc: 05 10 00 57 sethi %hi(0x40015c00), %g2 4000c5c0: 84 10 a2 68 or %g2, 0x268, %g2 ! 40015e68 <_User_extensions_List+0xc> 4000c5c4: 88 00 a0 04 add %g2, 4, %g4 4000c5c8: c4 00 80 00 ld [ %g2 ], %g2 while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) { 4000c5cc: 80 a0 80 04 cmp %g2, %g4 4000c5d0: 22 80 00 11 be,a 4000c614 <_User_extensions_Remove_set+0x5c> <== ALWAYS TAKEN 4000c5d4: c6 02 00 00 ld [ %o0 ], %g3 if ( iter->position == the_node_to_extract ) { 4000c5d8: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 <== NOT EXECUTED 4000c5dc: 80 a2 00 03 cmp %o0, %g3 <== NOT EXECUTED 4000c5e0: 32 bf ff fb bne,a 4000c5cc <_User_extensions_Remove_set+0x14> <== NOT EXECUTED 4000c5e4: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED if ( iter->direction == CHAIN_ITERATOR_FORWARD ) { 4000c5e8: c6 00 a0 08 ld [ %g2 + 8 ], %g3 <== NOT EXECUTED 4000c5ec: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 4000c5f0: 32 80 00 1b bne,a 4000c65c <_User_extensions_Remove_set+0xa4> <== NOT EXECUTED 4000c5f4: c6 02 00 00 ld [ %o0 ], %g3 <== NOT EXECUTED 4000c5f8: c6 02 20 04 ld [ %o0 + 4 ], %g3 <== NOT EXECUTED iter->position = _Chain_Previous( the_node_to_extract ); 4000c5fc: c6 20 a0 0c st %g3, [ %g2 + 0xc ] <== NOT EXECUTED 4000c600: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) { 4000c604: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED 4000c608: 32 bf ff f5 bne,a 4000c5dc <_User_extensions_Remove_set+0x24> <== NOT EXECUTED 4000c60c: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 <== NOT EXECUTED next = the_node->next; 4000c610: c6 02 00 00 ld [ %o0 ], %g3 <== NOT EXECUTED previous = the_node->previous; 4000c614: c4 02 20 04 ld [ %o0 + 4 ], %g2 <== NOT EXECUTED next->previous = previous; 4000c618: c4 20 e0 04 st %g2, [ %g3 + 4 ] <== NOT EXECUTED previous->next = next; 4000c61c: c6 20 80 00 st %g3, [ %g2 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000c620: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000c624: 01 00 00 00 nop /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) { 4000c628: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 4000c62c: 80 a0 60 00 cmp %g1, 0 4000c630: 02 80 00 09 be 4000c654 <_User_extensions_Remove_set+0x9c> 4000c634: 01 00 00 00 nop __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000c638: 91 d0 20 09 ta 9 <== NOT EXECUTED next = the_node->next; 4000c63c: c6 02 20 08 ld [ %o0 + 8 ], %g3 <== NOT EXECUTED previous = the_node->previous; 4000c640: c4 02 20 0c ld [ %o0 + 0xc ], %g2 <== NOT EXECUTED next->previous = previous; 4000c644: c4 20 e0 04 st %g2, [ %g3 + 4 ] <== NOT EXECUTED previous->next = next; 4000c648: c6 20 80 00 st %g3, [ %g2 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000c64c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000c650: 01 00 00 00 nop _Per_CPU_Acquire_all( level ); _Chain_Extract_unprotected( &the_extension->Switch.Node ); _Per_CPU_Release_all( level ); } } 4000c654: 81 c3 e0 08 retl 4000c658: 01 00 00 00 nop iter->position = _Chain_Next( the_node_to_extract ); 4000c65c: 10 bf ff db b 4000c5c8 <_User_extensions_Remove_set+0x10> <== NOT EXECUTED 4000c660: c6 20 a0 0c st %g3, [ %g2 + 0xc ] <== NOT EXECUTED =============================================================================== 4000bd38 <_User_extensions_Thread_begin_visitor>: void _User_extensions_Thread_begin_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 4000bd38: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED User_extensions_thread_begin_extension callout = callouts->thread_begin; 4000bd3c: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1 <== NOT EXECUTED if ( callout != NULL ) { 4000bd40: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000bd44: 02 80 00 04 be 4000bd54 <_User_extensions_Thread_begin_visitor+0x1c> <== NOT EXECUTED 4000bd48: 01 00 00 00 nop (*callout)( executing ); 4000bd4c: 9f c0 40 00 call %g1 4000bd50: 90 10 00 18 mov %i0, %o0 } } 4000bd54: 81 c7 e0 08 ret 4000bd58: 81 e8 00 00 restore =============================================================================== 4000bc90 <_User_extensions_Thread_create_visitor>: void _User_extensions_Thread_create_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 4000bc90: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED User_extensions_thread_create_extension callout = callouts->thread_create; 4000bc94: c4 06 80 00 ld [ %i2 ], %g2 if ( callout != NULL ) { 4000bc98: 80 a0 a0 00 cmp %g2, 0 4000bc9c: 02 80 00 0a be 4000bcc4 <_User_extensions_Thread_create_visitor+0x34> 4000bca0: 01 00 00 00 nop User_extensions_Thread_create_context *ctx = arg; ctx->ok = ctx->ok && (*callout)( executing, ctx->created ); 4000bca4: d0 0e 60 04 ldub [ %i1 + 4 ], %o0 4000bca8: 80 8a 20 ff btst 0xff, %o0 4000bcac: 22 80 00 06 be,a 4000bcc4 <_User_extensions_Thread_create_visitor+0x34> <== NEVER TAKEN 4000bcb0: d0 2e 60 04 stb %o0, [ %i1 + 4 ] <== NOT EXECUTED 4000bcb4: d2 06 40 00 ld [ %i1 ], %o1 4000bcb8: 9f c0 80 00 call %g2 4000bcbc: 90 10 00 18 mov %i0, %o0 4000bcc0: d0 2e 60 04 stb %o0, [ %i1 + 4 ] } } 4000bcc4: 81 c7 e0 08 ret 4000bcc8: 81 e8 00 00 restore =============================================================================== 4000bccc <_User_extensions_Thread_delete_visitor>: void _User_extensions_Thread_delete_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 4000bccc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED User_extensions_thread_delete_extension callout = callouts->thread_delete; 4000bcd0: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 <== NOT EXECUTED if ( callout != NULL ) { 4000bcd4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000bcd8: 02 80 00 04 be 4000bce8 <_User_extensions_Thread_delete_visitor+0x1c> 4000bcdc: 92 10 00 19 mov %i1, %o1 (*callout)( executing, arg ); 4000bce0: 9f c0 40 00 call %g1 4000bce4: 90 10 00 18 mov %i0, %o0 } } 4000bce8: 81 c7 e0 08 ret 4000bcec: 81 e8 00 00 restore =============================================================================== 4000bd5c <_User_extensions_Thread_exitted_visitor>: void _User_extensions_Thread_exitted_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 4000bd5c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED User_extensions_thread_exitted_extension callout = callouts->thread_exitted; 4000bd60: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1 <== NOT EXECUTED if ( callout != NULL ) { 4000bd64: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000bd68: 02 80 00 04 be 4000bd78 <_User_extensions_Thread_exitted_visitor+0x1c> <== NOT EXECUTED 4000bd6c: 01 00 00 00 nop (*callout)( executing ); 4000bd70: 9f c0 40 00 call %g1 4000bd74: 90 10 00 18 mov %i0, %o0 } } 4000bd78: 81 c7 e0 08 ret 4000bd7c: 81 e8 00 00 restore =============================================================================== 4000bd14 <_User_extensions_Thread_restart_visitor>: void _User_extensions_Thread_restart_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 4000bd14: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED User_extensions_thread_restart_extension callout = callouts->thread_restart; 4000bd18: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED if ( callout != NULL ) { 4000bd1c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000bd20: 02 80 00 04 be 4000bd30 <_User_extensions_Thread_restart_visitor+0x1c> <== NOT EXECUTED 4000bd24: 92 10 00 19 mov %i1, %o1 (*callout)( executing, arg ); 4000bd28: 9f c0 40 00 call %g1 4000bd2c: 90 10 00 18 mov %i0, %o0 } } 4000bd30: 81 c7 e0 08 ret 4000bd34: 81 e8 00 00 restore =============================================================================== 4000bcf0 <_User_extensions_Thread_start_visitor>: void _User_extensions_Thread_start_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 4000bcf0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED User_extensions_thread_start_extension callout = callouts->thread_start; 4000bcf4: c2 06 a0 04 ld [ %i2 + 4 ], %g1 <== NOT EXECUTED if ( callout != NULL ) { 4000bcf8: 80 a0 60 00 cmp %g1, 0 4000bcfc: 02 80 00 04 be 4000bd0c <_User_extensions_Thread_start_visitor+0x1c> 4000bd00: 92 10 00 19 mov %i1, %o1 (*callout)( executing, arg ); 4000bd04: 9f c0 40 00 call %g1 4000bd08: 90 10 00 18 mov %i0, %o0 } } 4000bd0c: 81 c7 e0 08 ret 4000bd10: 81 e8 00 00 restore =============================================================================== 4000bdac <_User_extensions_Thread_terminate_visitor>: void _User_extensions_Thread_terminate_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 4000bdac: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED User_extensions_thread_terminate_extension callout = 4000bdb0: c2 06 a0 20 ld [ %i2 + 0x20 ], %g1 <== NOT EXECUTED callouts->thread_terminate; if ( callout != NULL ) { 4000bdb4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000bdb8: 02 80 00 04 be 4000bdc8 <_User_extensions_Thread_terminate_visitor+0x1c> 4000bdbc: 01 00 00 00 nop (*callout)( executing ); 4000bdc0: 9f c0 40 00 call %g1 4000bdc4: 90 10 00 18 mov %i0, %o0 } } 4000bdc8: 81 c7 e0 08 ret 4000bdcc: 81 e8 00 00 restore =============================================================================== 4000c044 <_Watchdog_Do_tickle>: #ifdef RTEMS_SMP ISR_lock_Control *lock, #endif ISR_lock_Context *lock_context ) { 4000c044: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 4000c048: ba 10 20 02 mov 2, %i5 do { if ( first->expire <= now ) { 4000c04c: c2 06 60 18 ld [ %i1 + 0x18 ], %g1 4000c050: 80 a0 40 1a cmp %g1, %i2 4000c054: 18 80 00 26 bgu 4000c0ec <_Watchdog_Do_tickle+0xa8> 4000c058: 01 00 00 00 nop 4000c05c: 22 80 00 21 be,a 4000c0e0 <_Watchdog_Do_tickle+0x9c> 4000c060: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 4000c064: c4 06 60 04 ld [ %i1 + 4 ], %g2 if ( node != NULL ) { 4000c068: 80 a0 a0 00 cmp %g2, 0 4000c06c: 32 80 00 05 bne,a 4000c080 <_Watchdog_Do_tickle+0x3c> 4000c070: c2 00 80 00 ld [ %g2 ], %g1 4000c074: 10 80 00 19 b 4000c0d8 <_Watchdog_Do_tickle+0x94> 4000c078: c2 06 60 08 ld [ %i1 + 8 ], %g1 4000c07c: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED while ( ( left = _RBTree_Left( node ) ) != NULL ) { 4000c080: 80 a0 60 00 cmp %g1, 0 4000c084: 32 bf ff fe bne,a 4000c07c <_Watchdog_Do_tickle+0x38> <== NEVER TAKEN 4000c088: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED header->first = node; 4000c08c: c4 26 20 04 st %g2, [ %i0 + 4 ] Watchdog_Service_routine_entry routine; _Watchdog_Next_first( header, first ); _RBTree_Extract( &header->Watchdogs, &first->Node.RBTree ); 4000c090: 92 10 00 19 mov %i1, %o1 4000c094: 7f ff f4 9e call 4000930c <_RBTree_Extract> 4000c098: 90 10 00 18 mov %i0, %o0 _Watchdog_Set_state( first, WATCHDOG_INACTIVE ); routine = first->routine; 4000c09c: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 <== NOT EXECUTED RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 4000c0a0: fa 26 60 0c st %i5, [ %i1 + 0xc ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000c0a4: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000c0a8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000c0ac: 01 00 00 00 nop _ISR_lock_Release_and_ISR_enable( lock, lock_context ); ( *routine )( first ); 4000c0b0: 9f c0 80 00 call %g2 4000c0b4: 90 10 00 19 mov %i1, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000c0b8: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable_and_acquire( lock, lock_context ); 4000c0bc: c2 27 00 00 st %g1, [ %i4 ] 4000c0c0: f2 06 20 04 ld [ %i0 + 4 ], %i1 } else { break; } first = _Watchdog_Header_first( header ); } while ( first != NULL ); 4000c0c4: 80 a6 60 00 cmp %i1, 0 4000c0c8: 32 bf ff e2 bne,a 4000c050 <_Watchdog_Do_tickle+0xc> 4000c0cc: c2 06 60 18 ld [ %i1 + 0x18 ], %g1 } 4000c0d0: 81 c7 e0 08 ret 4000c0d4: 81 e8 00 00 restore header->first = _RBTree_Parent( &the_watchdog->Node.RBTree ); 4000c0d8: 10 bf ff ee b 4000c090 <_Watchdog_Do_tickle+0x4c> 4000c0dc: c2 26 20 04 st %g1, [ %i0 + 4 ] if ( first->expire <= now ) { 4000c0e0: 80 a0 40 1b cmp %g1, %i3 4000c0e4: 28 bf ff e1 bleu,a 4000c068 <_Watchdog_Do_tickle+0x24> 4000c0e8: c4 06 60 04 ld [ %i1 + 4 ], %g2 } 4000c0ec: 81 c7 e0 08 ret 4000c0f0: 81 e8 00 00 restore =============================================================================== 4000f338 <_Watchdog_Insert>: _Assert( _Watchdog_Get_state( the_watchdog ) == WATCHDOG_INACTIVE ); link = _RBTree_Root_reference( &header->Watchdogs ); parent = NULL; old_first = header->first; 4000f338: d8 02 20 04 ld [ %o0 + 4 ], %o4 <== NOT EXECUTED new_first = &the_watchdog->Node.RBTree; the_watchdog->expire = expire; 4000f33c: d4 22 60 18 st %o2, [ %o1 + 0x18 ] <== NOT EXECUTED link = _RBTree_Root_reference( &header->Watchdogs ); 4000f340: 84 10 00 08 mov %o0, %g2 the_watchdog->expire = expire; 4000f344: d6 22 60 1c st %o3, [ %o1 + 0x1c ] { 4000f348: 86 10 00 09 mov %o1, %g3 while ( *link != NULL ) { 4000f34c: c2 00 80 00 ld [ %g2 ], %g1 new_first = &the_watchdog->Node.RBTree; 4000f350: 9a 10 00 09 mov %o1, %o5 while ( *link != NULL ) { 4000f354: 80 a0 60 00 cmp %g1, 0 4000f358: 02 80 00 12 be 4000f3a0 <_Watchdog_Insert+0x68> 4000f35c: 88 10 20 00 clr %g4 Watchdog_Control *parent_watchdog; parent = *link; parent_watchdog = (Watchdog_Control *) parent; if ( expire < parent_watchdog->expire ) { 4000f360: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 4000f364: 80 a0 80 0a cmp %g2, %o2 4000f368: 18 80 00 09 bgu 4000f38c <_Watchdog_Insert+0x54> 4000f36c: 84 10 00 01 mov %g1, %g2 4000f370: 12 80 00 17 bne 4000f3cc <_Watchdog_Insert+0x94> 4000f374: 84 00 60 04 add %g1, 4, %g2 4000f378: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 4000f37c: 80 a0 80 0b cmp %g2, %o3 4000f380: 08 80 00 13 bleu 4000f3cc <_Watchdog_Insert+0x94> 4000f384: 84 00 60 04 add %g1, 4, %g2 return &RB_LEFT( the_node, Node ); 4000f388: 84 10 00 01 mov %g1, %g2 link = _RBTree_Left_reference( parent ); } else { link = _RBTree_Right_reference( parent ); new_first = old_first; 4000f38c: 88 10 00 01 mov %g1, %g4 while ( *link != NULL ) { 4000f390: c2 00 80 00 ld [ %g2 ], %g1 4000f394: 80 a0 60 00 cmp %g1, 0 4000f398: 32 bf ff f3 bne,a 4000f364 <_Watchdog_Insert+0x2c> 4000f39c: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 } } header->first = new_first; 4000f3a0: da 22 20 04 st %o5, [ %o0 + 4 ] RB_SET( child, parent, Node ); 4000f3a4: 82 10 20 01 mov 1, %g1 4000f3a8: c8 20 e0 08 st %g4, [ %g3 + 8 ] _RBTree_Initialize_node( &the_watchdog->Node.RBTree ); _RBTree_Add_child( &the_watchdog->Node.RBTree, parent, link ); _RBTree_Insert_color( &header->Watchdogs, &the_watchdog->Node.RBTree ); 4000f3ac: 92 10 00 03 mov %g3, %o1 4000f3b0: c0 20 e0 04 clr [ %g3 + 4 ] 4000f3b4: c0 20 c0 00 clr [ %g3 ] 4000f3b8: c2 20 e0 0c st %g1, [ %g3 + 0xc ] *link = child; 4000f3bc: c6 20 80 00 st %g3, [ %g2 ] 4000f3c0: 82 13 c0 00 mov %o7, %g1 4000f3c4: 7f ff f4 d3 call 4000c710 <_RBTree_Insert_color> 4000f3c8: 9e 10 40 00 mov %g1, %o7 new_first = old_first; 4000f3cc: 9a 10 00 0c mov %o4, %o5 4000f3d0: 10 bf ff f0 b 4000f390 <_Watchdog_Insert+0x58> 4000f3d4: 88 10 00 01 mov %g1, %g4 =============================================================================== 4000bfcc <_Watchdog_Remove>: void _Watchdog_Remove( Watchdog_Header *header, Watchdog_Control *the_watchdog ) { 4000bfcc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED if ( _Watchdog_Is_scheduled( the_watchdog ) ) { 4000bfd0: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED 4000bfd4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000bfd8: 28 80 00 04 bleu,a 4000bfe8 <_Watchdog_Remove+0x1c> <== NOT EXECUTED 4000bfdc: c2 06 20 04 ld [ %i0 + 4 ], %g1 } _RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree ); _Watchdog_Set_state( the_watchdog, WATCHDOG_INACTIVE ); } } 4000bfe0: 81 c7 e0 08 ret 4000bfe4: 81 e8 00 00 restore if ( header->first == &the_watchdog->Node.RBTree ) { 4000bfe8: 80 a0 40 19 cmp %g1, %i1 4000bfec: 22 80 00 09 be,a 4000c010 <_Watchdog_Remove+0x44> 4000bff0: c4 06 60 04 ld [ %i1 + 4 ], %g2 _RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree ); 4000bff4: 92 10 00 19 mov %i1, %o1 4000bff8: 7f ff f4 c5 call 4000930c <_RBTree_Extract> 4000bffc: 90 10 00 18 mov %i0, %o0 RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 4000c000: 82 10 20 02 mov 2, %g1 4000c004: c2 26 60 0c st %g1, [ %i1 + 0xc ] } 4000c008: 81 c7 e0 08 ret 4000c00c: 81 e8 00 00 restore if ( node != NULL ) { 4000c010: 80 a0 a0 00 cmp %g2, 0 4000c014: 32 80 00 05 bne,a 4000c028 <_Watchdog_Remove+0x5c> 4000c018: c2 00 80 00 ld [ %g2 ], %g1 4000c01c: 10 80 00 08 b 4000c03c <_Watchdog_Remove+0x70> 4000c020: c2 06 60 08 ld [ %i1 + 8 ], %g1 4000c024: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED while ( ( left = _RBTree_Left( node ) ) != NULL ) { 4000c028: 80 a0 60 00 cmp %g1, 0 4000c02c: 32 bf ff fe bne,a 4000c024 <_Watchdog_Remove+0x58> <== NEVER TAKEN 4000c030: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED header->first = node; 4000c034: 10 bf ff f0 b 4000bff4 <_Watchdog_Remove+0x28> 4000c038: c4 26 20 04 st %g2, [ %i0 + 4 ] header->first = _RBTree_Parent( &the_watchdog->Node.RBTree ); 4000c03c: 10 bf ff ee b 4000bff4 <_Watchdog_Remove+0x28> 4000c040: c2 26 20 04 st %g1, [ %i0 + 4 ] =============================================================================== 4000c0f4 <_Watchdog_Tick>: void _Watchdog_Tick( Per_CPU_Control *cpu ) { 4000c0f4: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED Watchdog_Control *first; uint64_t ticks; struct timespec now; if ( _Per_CPU_Is_boot_processor( cpu ) ) { ++_Watchdog_Ticks_since_boot; 4000c0f8: 05 10 00 7e sethi %hi(0x4001f800), %g2 <== NOT EXECUTED 4000c0fc: c2 00 a1 dc ld [ %g2 + 0x1dc ], %g1 ! 4001f9dc <_Watchdog_Ticks_since_boot> <== NOT EXECUTED 4000c100: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000c104: c2 20 a1 dc st %g1, [ %g2 + 0x1dc ] <== NOT EXECUTED 4000c108: 91 d0 20 09 ta 9 <== NOT EXECUTED } _ISR_lock_ISR_disable_and_acquire( &cpu->Watchdog.Lock, &lock_context ); 4000c10c: c2 27 bf ec st %g1, [ %fp + -20 ] ticks = cpu->Watchdog.ticks; 4000c110: c4 1e 20 30 ldd [ %i0 + 0x30 ], %g2 _Assert( ticks < UINT64_MAX ); ++ticks; 4000c114: 96 80 e0 01 addcc %g3, 1, %o3 4000c118: 94 40 a0 00 addx %g2, 0, %o2 cpu->Watchdog.ticks = ticks; 4000c11c: d4 3e 20 30 std %o2, [ %i0 + 0x30 ] 4000c120: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ]; first = _Watchdog_Header_first( header ); if ( first != NULL ) { 4000c124: 80 a2 60 00 cmp %o1, 0 4000c128: 02 80 00 04 be 4000c138 <_Watchdog_Tick+0x44> 4000c12c: 98 07 bf ec add %fp, -20, %o4 _Watchdog_Tickle( 4000c130: 7f ff ff c5 call 4000c044 <_Watchdog_Do_tickle> 4000c134: 90 06 20 38 add %i0, 0x38, %o0 4000c138: fa 06 20 4c ld [ %i0 + 0x4c ], %i5 } header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_MONOTONIC ]; first = _Watchdog_Header_first( header ); if ( first != NULL ) { 4000c13c: 80 a7 60 00 cmp %i5, 0 4000c140: 22 80 00 11 be,a 4000c184 <_Watchdog_Tick+0x90> 4000c144: fa 06 20 44 ld [ %i0 + 0x44 ], %i5 _Timecounter_Getnanouptime( &now ); 4000c148: 7f ff f2 32 call 40008a10 <_Timecounter_Getnanouptime> 4000c14c: 90 07 bf f0 add %fp, -16, %o0 ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS; 4000c150: c2 07 bf f0 ld [ %fp + -16 ], %g1 ticks = (uint64_t) ts->tv_sec; 4000c154: d6 07 bf f4 ld [ %fp + -12 ], %o3 ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS; 4000c158: 83 28 60 1e sll %g1, 0x1e, %g1 4000c15c: 95 32 e0 02 srl %o3, 2, %o2 _Watchdog_Tickle( 4000c160: 94 12 80 01 or %o2, %g1, %o2 4000c164: c2 07 bf f8 ld [ %fp + -8 ], %g1 4000c168: 97 2a e0 1e sll %o3, 0x1e, %o3 4000c16c: 98 07 bf ec add %fp, -20, %o4 4000c170: 96 10 40 0b or %g1, %o3, %o3 4000c174: 92 10 00 1d mov %i5, %o1 4000c178: 7f ff ff b3 call 4000c044 <_Watchdog_Do_tickle> 4000c17c: 90 06 20 48 add %i0, 0x48, %o0 4000c180: fa 06 20 44 ld [ %i0 + 0x44 ], %i5 } header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_REALTIME ]; first = _Watchdog_Header_first( header ); if ( first != NULL ) { 4000c184: 80 a7 60 00 cmp %i5, 0 4000c188: 02 80 00 10 be 4000c1c8 <_Watchdog_Tick+0xd4> 4000c18c: 01 00 00 00 nop _Timecounter_Getnanotime( &now ); 4000c190: 7f ff f2 46 call 40008aa8 <_Timecounter_Getnanotime> 4000c194: 90 07 bf f0 add %fp, -16, %o0 4000c198: c2 07 bf f0 ld [ %fp + -16 ], %g1 ticks = (uint64_t) ts->tv_sec; 4000c19c: d6 07 bf f4 ld [ %fp + -12 ], %o3 ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS; 4000c1a0: 83 28 60 1e sll %g1, 0x1e, %g1 4000c1a4: 95 32 e0 02 srl %o3, 2, %o2 _Watchdog_Tickle( 4000c1a8: 94 12 80 01 or %o2, %g1, %o2 4000c1ac: c2 07 bf f8 ld [ %fp + -8 ], %g1 4000c1b0: 97 2a e0 1e sll %o3, 0x1e, %o3 4000c1b4: 98 07 bf ec add %fp, -20, %o4 4000c1b8: 96 10 40 0b or %g1, %o3, %o3 4000c1bc: 92 10 00 1d mov %i5, %o1 4000c1c0: 7f ff ff a1 call 4000c044 <_Watchdog_Do_tickle> 4000c1c4: 90 06 20 40 add %i0, 0x40, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000c1c8: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000c1cc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000c1d0: 01 00 00 00 nop Thread_Control *executing = cpu->executing; 4000c1d4: d2 06 20 20 ld [ %i0 + 0x20 ], %o1 if ( scheduler != NULL && executing != NULL ) { 4000c1d8: 80 a2 60 00 cmp %o1, 0 4000c1dc: 02 80 00 06 be 4000c1f4 <_Watchdog_Tick+0x100> 4000c1e0: 11 10 00 63 sethi %hi(0x40018c00), %o0 ( *scheduler->Operations.tick )( scheduler, executing ); 4000c1e4: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 40018dc8 <_Scheduler_Table> 4000c1e8: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 4000c1ec: 9f c0 40 00 call %g1 4000c1f0: 01 00 00 00 nop } _ISR_lock_Release_and_ISR_enable( &cpu->Watchdog.Lock, &lock_context ); _Scheduler_Tick( cpu ); } 4000c1f4: 81 c7 e0 08 ret 4000c1f8: 81 e8 00 00 restore =============================================================================== 4000c3b8 <_Workspace_Allocate>: return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 4000c3b8: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED 4000c3bc: 96 10 20 00 clr %o3 4000c3c0: 11 10 00 7e sethi %hi(0x4001f800), %o0 4000c3c4: 94 10 20 00 clr %o2 4000c3c8: 90 12 21 e0 or %o0, 0x1e0, %o0 4000c3cc: 82 13 c0 00 mov %o7, %g1 4000c3d0: 7f ff eb 8e call 40007208 <_Heap_Allocate_aligned_with_boundary> 4000c3d4: 9e 10 40 00 mov %g1, %o7 =============================================================================== 4000c3d8 <_Workspace_Allocate_aligned>: return _Heap_Allocate_aligned_with_boundary( heap, size, alignment, 0 ); 4000c3d8: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED 4000c3dc: 96 10 20 00 clr %o3 <== NOT EXECUTED 4000c3e0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED 4000c3e4: 11 10 00 7e sethi %hi(0x4001f800), %o0 <== NOT EXECUTED 4000c3e8: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 4001f9e0 <_Workspace_Area> <== NOT EXECUTED 4000c3ec: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4000c3f0: 7f ff eb 86 call 40007208 <_Heap_Allocate_aligned_with_boundary> <== NOT EXECUTED 4000c3f4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 4000c410 <_Workspace_Allocate_or_fatal_error>: } void *_Workspace_Allocate_or_fatal_error( size_t size ) { 4000c410: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 4000c414: 96 10 20 00 clr %o3 <== NOT EXECUTED 4000c418: 94 10 20 00 clr %o2 <== NOT EXECUTED 4000c41c: 92 10 00 18 mov %i0, %o1 4000c420: 11 10 00 7e sethi %hi(0x4001f800), %o0 4000c424: 7f ff eb 79 call 40007208 <_Heap_Allocate_aligned_with_boundary> 4000c428: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 4001f9e0 <_Workspace_Area> __builtin_return_address( 1 ), memory ); #endif if ( memory == NULL ) 4000c42c: 80 a2 20 00 cmp %o0, 0 4000c430: 02 80 00 04 be 4000c440 <_Workspace_Allocate_or_fatal_error+0x30> 4000c434: b0 10 00 08 mov %o0, %i0 _Internal_error( INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 4000c438: 81 c7 e0 08 ret 4000c43c: 81 e8 00 00 restore _Internal_error( INTERNAL_ERROR_WORKSPACE_ALLOCATION ); 4000c440: 7f ff ed 19 call 400078a4 <_Internal_error> 4000c444: 90 10 20 03 mov 3, %o0 4000c448: 01 00 00 00 nop <== NOT EXECUTED ... =============================================================================== 4000c3f8 <_Workspace_Free>: block, __builtin_return_address( 0 ), __builtin_return_address( 1 ) ); #endif _Heap_Free( &_Workspace_Area, block ); 4000c3f8: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED 4000c3fc: 11 10 00 7e sethi %hi(0x4001f800), %o0 4000c400: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 4001f9e0 <_Workspace_Area> 4000c404: 82 13 c0 00 mov %o7, %g1 4000c408: 40 00 06 35 call 4000dcdc <_Heap_Free> 4000c40c: 9e 10 40 00 mov %g1, %o7 =============================================================================== 4000c1fc <_Workspace_Handler_initialization>: void _Workspace_Handler_initialization( Heap_Area *areas, size_t area_count, Heap_Initialization_or_extend_handler extend ) { 4000c1fc: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize; uintptr_t remaining = rtems_configuration_get_work_space_size(); 4000c200: 03 10 00 63 sethi %hi(0x40018c00), %g1 <== NOT EXECUTED 4000c204: 86 10 60 e8 or %g1, 0xe8, %g3 ! 40018ce8 4000c208: c4 08 e0 32 ldub [ %g3 + 0x32 ], %g2 4000c20c: 80 a0 a0 00 cmp %g2, 0 4000c210: 12 80 00 04 bne 4000c220 <_Workspace_Handler_initialization+0x24> 4000c214: f8 00 60 e8 ld [ %g1 + 0xe8 ], %i4 4000c218: c2 00 e0 04 ld [ %g3 + 4 ], %g1 4000c21c: b8 07 00 01 add %i4, %g1, %i4 bool do_zero = rtems_configuration_get_do_zero_of_workspace(); 4000c220: c8 08 e0 30 ldub [ %g3 + 0x30 ], %g4 bool unified = rtems_configuration_get_unified_work_area(); 4000c224: c6 08 e0 31 ldub [ %g3 + 0x31 ], %g3 bool do_zero = rtems_configuration_get_do_zero_of_workspace(); 4000c228: c8 2f bf ff stb %g4, [ %fp + -1 ] return (uintptr_t) _TLS_BSS_end - (uintptr_t) _TLS_Data_begin; 4000c22c: 03 10 00 68 sethi %hi(0x4001a000), %g1 4000c230: 82 10 62 d0 or %g1, 0x2d0, %g1 ! 4001a2d0 <_Linker_set__Sysinit_bsp_work_area_initialize> 4000c234: 05 10 00 68 sethi %hi(0x4001a000), %g2 4000c238: 84 10 a2 d0 or %g2, 0x2d0, %g2 ! 4001a2d0 <_Linker_set__Sysinit_bsp_work_area_initialize> * workspace is large enough to fulfill all requests known at configuration * time (so excluding the unlimited option). It is not possible to estimate * the TLS size in the configuration at compile-time. The TLS size is * determined at application link-time. */ if ( tls_size > 0 ) { 4000c23c: 82 a0 40 02 subcc %g1, %g2, %g1 4000c240: 02 80 00 1b be 4000c2ac <_Workspace_Handler_initialization+0xb0> 4000c244: c6 2f bf fe stb %g3, [ %fp + -2 ] return (val + msk) & ~msk; 4000c248: 05 00 00 00 sethi %hi(0), %g2 4000c24c: 84 10 a0 01 or %g2, 1, %g2 ! 1 <_TLS_Alignment> 4000c250: 84 00 a0 07 add %g2, 7, %g2 4000c254: 84 08 bf f8 and %g2, -8, %g2 sizeof(TLS_Thread_control_block) : alignment; 4000c258: 80 a0 a0 08 cmp %g2, 8 4000c25c: 2a 80 00 02 bcs,a 4000c264 <_Workspace_Handler_initialization+0x68> <== NEVER TAKEN 4000c260: 84 10 20 08 mov 8, %g2 <== NOT EXECUTED thread_count += rtems_resource_maximum_per_allocation( 4000c264: 09 10 00 6e sethi %hi(0x4001b800), %g4 if ( page_size < alignment ) { page_size = alignment; } return HEAP_BLOCK_HEADER_SIZE + page_size - 1 + size; 4000c268: 85 28 a0 01 sll %g2, 1, %g2 4000c26c: fa 01 21 60 ld [ %g4 + 0x160 ], %i5 4000c270: 07 10 00 6c sethi %hi(0x4001b000), %g3 4000c274: c6 00 e3 44 ld [ %g3 + 0x344 ], %g3 ! 4001b344 return (val + msk) & ~msk; 4000c278: 82 00 60 07 add %g1, 7, %g1 4000c27c: 09 00 00 3f sethi %hi(0xfc00), %g4 4000c280: 82 08 7f f8 and %g1, -8, %g1 4000c284: 88 11 23 ff or %g4, 0x3ff, %g4 4000c288: 82 00 60 0f add %g1, 0xf, %g1 4000c28c: 86 08 c0 04 and %g3, %g4, %g3 4000c290: 82 00 80 01 add %g2, %g1, %g1 4000c294: 84 0f 40 04 and %i5, %g4, %g2 4000c298: 84 00 c0 02 add %g3, %g2, %g2 4000c29c: 84 00 a0 01 inc %g2 * size. */ remaining += _Heap_Min_block_size( page_size ); remaining += _Get_maximum_thread_count() * _Heap_Size_with_overhead( page_size, tls_alloc, tls_align ); 4000c2a0: 82 58 40 02 smul %g1, %g2, %g1 remaining += _Get_maximum_thread_count() 4000c2a4: 82 00 60 10 add %g1, 0x10, %g1 4000c2a8: b8 07 00 01 add %i4, %g1, %i4 } for (i = 0; i < area_count; ++i) { 4000c2ac: 80 a6 60 00 cmp %i1, 0 4000c2b0: 02 80 00 2d be 4000c364 <_Workspace_Handler_initialization+0x168> <== NEVER TAKEN 4000c2b4: 80 a7 20 00 cmp %i4, 0 4000c2b8: f6 0f bf ff ldub [ %fp + -1 ], %i3 if ( area->size > overhead ) { uintptr_t space_available; uintptr_t size; if ( unified ) { 4000c2bc: e2 0f bf fe ldub [ %fp + -2 ], %l1 4000c2c0: b3 2e 60 03 sll %i1, 3, %i1 for (i = 0; i < area_count; ++i) { 4000c2c4: 21 10 00 1d sethi %hi(0x40007400), %l0 } else { size = 0; } } space_available = (*init_or_extend)( 4000c2c8: 25 10 00 7e sethi %hi(0x4001f800), %l2 4000c2cc: b2 06 00 19 add %i0, %i1, %i1 for (i = 0; i < area_count; ++i) { 4000c2d0: a0 14 21 80 or %l0, 0x180, %l0 space_available = (*init_or_extend)( 4000c2d4: a4 14 a1 e0 or %l2, 0x1e0, %l2 if ( do_zero ) { 4000c2d8: 80 a6 e0 00 cmp %i3, 0 4000c2dc: 12 80 00 26 bne 4000c374 <_Workspace_Handler_initialization+0x178> 4000c2e0: fa 06 20 04 ld [ %i0 + 4 ], %i5 if ( area->size > overhead ) { 4000c2e4: 80 a7 60 16 cmp %i5, 0x16 4000c2e8: 28 80 00 1b bleu,a 4000c354 <_Workspace_Handler_initialization+0x158> 4000c2ec: b0 06 20 08 add %i0, 8, %i0 if ( unified ) { 4000c2f0: 80 a4 60 00 cmp %l1, 0 4000c2f4: 12 80 00 09 bne 4000c318 <_Workspace_Handler_initialization+0x11c> 4000c2f8: d2 06 00 00 ld [ %i0 ], %o1 if ( remaining > 0 ) { 4000c2fc: 80 a7 20 00 cmp %i4, 0 4000c300: 02 80 00 23 be 4000c38c <_Workspace_Handler_initialization+0x190> <== NEVER TAKEN 4000c304: 96 10 20 08 mov 8, %o3 size = remaining < area->size - overhead ? 4000c308: 82 07 7f ea add %i5, -22, %g1 remaining + overhead : area->size; 4000c30c: 80 a0 40 1c cmp %g1, %i4 4000c310: 38 80 00 02 bgu,a 4000c318 <_Workspace_Handler_initialization+0x11c> <== ALWAYS TAKEN 4000c314: ba 07 20 16 add %i4, 0x16, %i5 space_available = (*init_or_extend)( 4000c318: 94 10 00 1d mov %i5, %o2 4000c31c: 96 10 20 08 mov 8, %o3 4000c320: 9f c4 00 00 call %l0 4000c324: 90 10 00 12 mov %l2, %o0 area->begin, size, page_size ); area->begin = (char *) area->begin + size; 4000c328: c4 06 00 00 ld [ %i0 ], %g2 area->size -= size; 4000c32c: c2 06 20 04 ld [ %i0 + 4 ], %g1 area->begin = (char *) area->begin + size; 4000c330: 84 00 80 1d add %g2, %i5, %g2 area->size -= size; 4000c334: ba 20 40 1d sub %g1, %i5, %i5 area->begin = (char *) area->begin + size; 4000c338: c4 26 00 00 st %g2, [ %i0 ] if ( space_available < remaining ) { 4000c33c: 80 a2 00 1c cmp %o0, %i4 4000c340: 1a 80 00 18 bcc 4000c3a0 <_Workspace_Handler_initialization+0x1a4> <== ALWAYS TAKEN 4000c344: fa 26 20 04 st %i5, [ %i0 + 4 ] remaining -= space_available; 4000c348: b8 27 00 08 sub %i4, %o0, %i4 <== NOT EXECUTED } else { remaining = 0; } init_or_extend = extend; 4000c34c: a0 10 00 1a mov %i2, %l0 <== NOT EXECUTED 4000c350: b0 06 20 08 add %i0, 8, %i0 for (i = 0; i < area_count; ++i) { 4000c354: 80 a6 40 18 cmp %i1, %i0 4000c358: 12 bf ff e1 bne 4000c2dc <_Workspace_Handler_initialization+0xe0> <== NEVER TAKEN 4000c35c: 80 a6 e0 00 cmp %i3, 0 } } if ( remaining > 0 ) { 4000c360: 80 a7 20 00 cmp %i4, 0 4000c364: 12 80 00 12 bne 4000c3ac <_Workspace_Handler_initialization+0x1b0> 4000c368: 01 00 00 00 nop _Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } _Heap_Protection_set_delayed_free_fraction( &_Workspace_Area, 1 ); } 4000c36c: 81 c7 e0 08 ret 4000c370: 81 e8 00 00 restore memset( area->begin, 0, area->size ); 4000c374: d0 06 00 00 ld [ %i0 ], %o0 4000c378: 94 10 00 1d mov %i5, %o2 4000c37c: 40 00 0b a1 call 4000f200 4000c380: 92 10 20 00 clr %o1 4000c384: 10 bf ff d8 b 4000c2e4 <_Workspace_Handler_initialization+0xe8> 4000c388: fa 06 20 04 ld [ %i0 + 4 ], %i5 space_available = (*init_or_extend)( 4000c38c: 94 10 20 00 clr %o2 <== NOT EXECUTED 4000c390: 9f c4 00 00 call %l0 <== NOT EXECUTED 4000c394: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED init_or_extend = extend; 4000c398: 10 bf ff ee b 4000c350 <_Workspace_Handler_initialization+0x154> <== NOT EXECUTED 4000c39c: a0 10 00 1a mov %i2, %l0 <== NOT EXECUTED 4000c3a0: a0 10 00 1a mov %i2, %l0 remaining = 0; 4000c3a4: 10 bf ff eb b 4000c350 <_Workspace_Handler_initialization+0x154> 4000c3a8: b8 10 20 00 clr %i4 _Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); 4000c3ac: 7f ff ed 3e call 400078a4 <_Internal_error> 4000c3b0: 90 10 20 02 mov 2, %o0 4000c3b4: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 400104a4 <_Workspace_String_duplicate>: char *_Workspace_String_duplicate( const char *string, size_t len ) { 400104a4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED char *dup = _Workspace_Allocate(len + 1); 400104a8: 7f ff ff da call 40010410 <_Workspace_Allocate> <== NOT EXECUTED 400104ac: 90 06 60 01 add %i1, 1, %o0 <== NOT EXECUTED if (dup != NULL) { 400104b0: ba 92 20 00 orcc %o0, 0, %i5 400104b4: 02 80 00 05 be 400104c8 <_Workspace_String_duplicate+0x24> 400104b8: 94 10 00 19 mov %i1, %o2 dup [len] = '\0'; 400104bc: c0 2f 40 19 clrb [ %i5 + %i1 ] memcpy(dup, string, len); 400104c0: 40 00 07 de call 40012438 400104c4: 92 10 00 18 mov %i0, %o1 } return dup; } 400104c8: 81 c7 e0 08 ret 400104cc: 91 e8 00 1d restore %g0, %i5, %o0 ...