=============================================================================== 4001b884 : uint32_t TOD_TICKS_PER_SECOND_method(void) { return (TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick()); } 4001b884: 11 00 03 d0 sethi %hi(0xf4000), %o0 <== NOT EXECUTED 4001b888: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <== NOT EXECUTED 4001b88c: 03 10 00 b4 sethi %hi(0x4002d000), %g1 <== NOT EXECUTED 4001b890: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 4001b894: c4 00 63 dc ld [ %g1 + 0x3dc ], %g2 <== NOT EXECUTED 4001b898: 01 00 00 00 nop <== NOT EXECUTED 4001b89c: 01 00 00 00 nop <== NOT EXECUTED 4001b8a0: 84 72 00 02 udiv %o0, %g2, %g2 <== NOT EXECUTED 4001b8a4: 81 c3 e0 08 retl <== NOT EXECUTED 4001b8a8: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED =============================================================================== 40006730 <_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(); 40006730: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED 40006734: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2 <== NOT EXECUTED 40006738: 82 18 40 02 xor %g1, %g2, %g1 <== NOT EXECUTED } 4000673c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 40006740: 81 c3 e0 08 retl <== NOT EXECUTED 40006744: 90 60 3f ff subx %g0, -1, %o0 =============================================================================== 4001a014 <_CORE_message_queue_Close>: void _CORE_message_queue_Close( CORE_message_queue_Control *the_message_queue, Thread_queue_Context *queue_context ) { 4001a014: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED /* * This will flush blocked threads whether they were blocked on * a send or receive. */ _Thread_queue_Flush_critical( 4001a018: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED 4001a01c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001a020: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED 4001a024: 15 10 00 68 sethi %hi(0x4001a000), %o2 <== NOT EXECUTED 4001a028: 7f ff e7 4e call 40013d60 <_Thread_queue_Flush_critical> <== NOT EXECUTED 4001a02c: 94 12 a0 08 or %o2, 8, %o2 ! 4001a008 <_CORE_message_queue_Was_deleted> <== NOT EXECUTED the_message_queue->operations, _CORE_message_queue_Was_deleted, queue_context ); (void) _Workspace_Free( the_message_queue->message_buffers ); 4001a030: f0 06 20 28 ld [ %i0 + 0x28 ], %i0 <== NOT EXECUTED 4001a034: 7f ff ef 6e call 40015dec <_Workspace_Free> <== NOT EXECUTED 4001a038: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000f2e8 <_CORE_mutex_Seize_slow>: const Thread_queue_Operations *operations, Thread_Control *executing, bool wait, Thread_queue_Context *queue_context ) { 4000f2e8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED if ( wait ) { 4000f2ec: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 4000f2f0: 02 80 00 0f be 4000f32c <_CORE_mutex_Seize_slow+0x44> <== NOT EXECUTED 4000f2f4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED queue_context->thread_state = thread_state; 4000f2f8: c2 27 20 04 st %g1, [ %i4 + 4 ] <== NOT EXECUTED queue_context->deadlock_callout = deadlock_callout; 4000f2fc: 03 10 00 4e sethi %hi(0x40013800), %g1 <== NOT EXECUTED 4000f300: 82 10 61 2c or %g1, 0x12c, %g1 ! 4001392c <_Thread_queue_Deadlock_status> <== NOT EXECUTED 4000f304: c2 27 20 20 st %g1, [ %i4 + 0x20 ] <== NOT EXECUTED ); _Thread_queue_Context_set_deadlock_callout( queue_context, _Thread_queue_Deadlock_status ); _Thread_queue_Enqueue( 4000f308: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000f30c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000f310: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED 4000f314: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 4000f318: 40 00 11 8d call 4001394c <_Thread_queue_Enqueue> <== NOT EXECUTED 4000f31c: b0 10 20 00 clr %i0 <== NOT EXECUTED return (Status_Control) the_thread->Wait.return_code; 4000f320: f2 06 a0 4c ld [ %i2 + 0x4c ], %i1 <== NOT EXECUTED return _Thread_Wait_get_status( executing ); } else { _CORE_mutex_Release( the_mutex, queue_context ); return STATUS_UNAVAILABLE; } } 4000f324: 81 c7 e0 08 ret <== NOT EXECUTED 4000f328: 81 e8 00 00 restore <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000f32c: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000f330: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000f334: 01 00 00 00 nop <== NOT EXECUTED return STATUS_UNAVAILABLE; 4000f338: 33 00 00 04 sethi %hi(0x1000), %i1 <== NOT EXECUTED 4000f33c: b2 16 60 0d or %i1, 0xd, %i1 ! 100d <== NOT EXECUTED } 4000f340: 81 c7 e0 08 ret <== NOT EXECUTED 4000f344: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED =============================================================================== 4000f348 <_CORE_semaphore_Initialize>: void _CORE_semaphore_Initialize( CORE_semaphore_Control *the_semaphore, uint32_t initial_value ) { the_semaphore->count = initial_value; 4000f348: d2 22 20 0c st %o1, [ %o0 + 0xc ] <== NOT EXECUTED _Thread_queue_Object_initialize( &the_semaphore->Wait_queue ); 4000f34c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4000f350: 40 00 11 2a call 400137f8 <_Thread_queue_Object_initialize> <== NOT EXECUTED 4000f354: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 40057500 <_Condition_Broadcast>: _Condition_Wake( _condition, 1 ); } void _Condition_Broadcast( struct _Condition_Control *_condition ) { _Condition_Wake( _condition, INT_MAX ); 40057500: 13 1f ff ff sethi %hi(0x7ffffc00), %o1 <== NOT EXECUTED 40057504: 92 12 63 ff or %o1, 0x3ff, %o1 ! 7fffffff <== NOT EXECUTED 40057508: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4005750c: 7f ff ff d2 call 40057454 <_Condition_Wake> <== NOT EXECUTED 40057510: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 40019e0c <_Condition_Wait>: { 40019e0c: 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; 40019e10: 03 10 00 67 sethi %hi(0x40019c00), %g1 <== NOT EXECUTED context->mutex = _mutex; 40019e14: f2 27 bf fc st %i1, [ %fp + -4 ] <== NOT EXECUTED 40019e18: 82 10 61 a8 or %g1, 0x1a8, %g1 <== NOT EXECUTED 40019e1c: c2 27 bf e0 st %g1, [ %fp + -32 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40019e20: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( &context->Base.Lock_context.Lock_context ); 40019e24: c2 27 bf d8 st %g1, [ %fp + -40 ] <== NOT EXECUTED queue_context->thread_state = thread_state; 40019e28: 82 10 20 20 mov 0x20, %g1 <== NOT EXECUTED _Thread_queue_Enqueue( 40019e2c: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2 <== NOT EXECUTED 40019e30: 90 06 20 08 add %i0, 8, %o0 <== NOT EXECUTED 40019e34: 96 07 bf d8 add %fp, -40, %o3 <== NOT EXECUTED 40019e38: c2 27 bf dc st %g1, [ %fp + -36 ] <== NOT EXECUTED 40019e3c: 13 10 01 f5 sethi %hi(0x4007d400), %o1 <== NOT EXECUTED 40019e40: 40 00 10 72 call 4001e008 <_Thread_queue_Enqueue> <== NOT EXECUTED 40019e44: 92 12 63 c0 or %o1, 0x3c0, %o1 ! 4007d7c0 <_Thread_queue_Operations_FIFO> <== NOT EXECUTED _Mutex_Acquire( _mutex ); 40019e48: 40 00 07 7e call 4001bc40 <_Mutex_Acquire> <== NOT EXECUTED 40019e4c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED } 40019e50: 81 c7 e0 08 ret <== NOT EXECUTED 40019e54: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 400574a8 <_Condition_Wait_recursive>: { 400574a8: 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; 400574ac: 03 10 01 5d sethi %hi(0x40057400), %g1 <== NOT EXECUTED nest_level = _mutex->_nest_level; 400574b0: fa 06 60 14 ld [ %i1 + 0x14 ], %i5 <== NOT EXECUTED 400574b4: 82 10 60 44 or %g1, 0x44, %g1 <== NOT EXECUTED _mutex->_nest_level = 0; 400574b8: c0 26 60 14 clr [ %i1 + 0x14 ] <== NOT EXECUTED 400574bc: c2 27 bf e0 st %g1, [ %fp + -32 ] <== NOT EXECUTED context->mutex = _mutex; 400574c0: f2 27 bf fc st %i1, [ %fp + -4 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400574c4: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( &context->Base.Lock_context.Lock_context ); 400574c8: c2 27 bf d8 st %g1, [ %fp + -40 ] <== NOT EXECUTED queue_context->thread_state = thread_state; 400574cc: 82 10 20 20 mov 0x20, %g1 <== NOT EXECUTED _Thread_queue_Enqueue( 400574d0: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2 <== NOT EXECUTED 400574d4: 96 07 bf d8 add %fp, -40, %o3 <== NOT EXECUTED 400574d8: 90 06 20 08 add %i0, 8, %o0 <== NOT EXECUTED 400574dc: c2 27 bf dc st %g1, [ %fp + -36 ] <== NOT EXECUTED 400574e0: 13 10 02 46 sethi %hi(0x40091800), %o1 <== NOT EXECUTED 400574e4: 40 00 0d b1 call 4005aba8 <_Thread_queue_Enqueue> <== NOT EXECUTED 400574e8: 92 12 63 a8 or %o1, 0x3a8, %o1 ! 40091ba8 <_Thread_queue_Operations_FIFO> <== NOT EXECUTED _Mutex_recursive_Acquire( _mutex ); 400574ec: 40 00 06 16 call 40058d44 <_Mutex_recursive_Acquire> <== NOT EXECUTED 400574f0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED _mutex->_nest_level = nest_level; 400574f4: fa 26 60 14 st %i5, [ %i1 + 0x14 ] <== NOT EXECUTED } 400574f8: 81 c7 e0 08 ret <== NOT EXECUTED 400574fc: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000d8d8 <_Event_Seize>: Event_Control *event, Thread_Wait_flags wait_class, States_Control block_state, ISR_lock_Context *lock_context ) { 4000d8d8: 9d e3 bf 98 save %sp, -104, %sp rtems_event_set pending_events; bool success; Thread_Wait_flags intend_to_block; Per_CPU_Control *cpu_self; pending_events = event->pending_events; 4000d8dc: c2 07 40 00 ld [ %i5 ], %g1 seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 4000d8e0: 84 88 40 18 andcc %g1, %i0, %g2 4000d8e4: 02 80 00 07 be 4000d900 <_Event_Seize+0x28> 4000d8e8: 80 8e 60 01 btst 1, %i1 4000d8ec: 80 a6 00 02 cmp %i0, %g2 4000d8f0: 02 80 00 3e be 4000d9e8 <_Event_Seize+0x110> <== NEVER TAKEN 4000d8f4: 80 8e 60 02 btst 2, %i1 (seized_events == event_in || _Options_Is_any( option_set )) ) { 4000d8f8: 12 80 00 3c bne 4000d9e8 <_Event_Seize+0x110> <== ALWAYS TAKEN 4000d8fc: 80 8e 60 01 btst 1, %i1 _Thread_Wait_release_default( executing, lock_context ); *event_out = seized_events; return RTEMS_SUCCESSFUL; } if ( _Options_Is_no_wait( option_set ) ) { 4000d900: 12 80 00 33 bne 4000d9cc <_Event_Seize+0xf4> 4000d904: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 _Thread_Wait_release_default( executing, lock_context ); *event_out = seized_events; return RTEMS_UNSATISFIED; } intend_to_block = wait_class | THREAD_WAIT_STATE_INTEND_TO_BLOCK; 4000d908: a0 10 60 01 or %g1, 1, %l0 <== NOT EXECUTED const ISR_lock_Context *lock_context ) { uint32_t disable_level; disable_level = cpu_self->thread_dispatch_disable_level; 4000d90c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED * set properly when we are marked as in the event critical section. * * NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.return_code = STATUS_SUCCESSFUL; 4000d910: c0 27 20 4c clr [ %i4 + 0x4c ] <== NOT EXECUTED _Profiling_Thread_dispatch_disable_critical( cpu_self, disable_level, lock_context ); cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000d914: 82 00 60 01 inc %g1 <== NOT EXECUTED executing->Wait.option = option_set; 4000d918: f2 27 20 48 st %i1, [ %i4 + 0x48 ] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Per_CPU_Control *_Thread_Dispatch_disable_critical( const ISR_lock_Context *lock_context ) { return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000d91c: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED executing->Wait.count = event_in; 4000d920: f0 27 20 3c st %i0, [ %i4 + 0x3c ] <== NOT EXECUTED executing->Wait.return_argument = event_out; 4000d924: f6 27 20 40 st %i3, [ %i4 + 0x40 ] <== NOT EXECUTED ) { #if defined(RTEMS_SMP) _Atomic_Store_uint( &the_thread->Wait.flags, flags, ATOMIC_ORDER_RELAXED ); #else the_thread->Wait.flags = flags; 4000d928: e0 27 20 50 st %l0, [ %i4 + 0x50 ] <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000d92c: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000d930: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 <== NOT EXECUTED 4000d934: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000d938: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000d93c: 01 00 00 00 nop _Thread_Wait_flags_set( executing, intend_to_block ); cpu_self = _Thread_Dispatch_disable_critical( lock_context ); _Thread_Wait_release_default( executing, lock_context ); if ( ticks ) { 4000d940: 80 a6 a0 00 cmp %i2, 0 4000d944: 12 80 00 32 bne 4000da0c <_Event_Seize+0x134> 4000d948: 01 00 00 00 nop _Thread_Add_timeout_ticks( executing, cpu_self, ticks ); } _Thread_Set_state( executing, block_state ); 4000d94c: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 4000d950: 40 00 1e 19 call 400151b4 <_Thread_Set_state> 4000d954: 90 10 00 1c mov %i4, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000d958: 91 d0 20 09 ta 9 <== NOT EXECUTED desired_flags, ATOMIC_ORDER_RELEASE, ATOMIC_ORDER_RELAXED ); #else bool success = ( the_thread->Wait.flags == expected_flags ); 4000d95c: c6 07 20 50 ld [ %i4 + 0x50 ], %g3 if ( success ) { 4000d960: 80 a4 00 03 cmp %l0, %g3 4000d964: 12 80 00 04 bne 4000d974 <_Event_Seize+0x9c> <== NEVER TAKEN 4000d968: c4 07 a0 5c ld [ %fp + 0x5c ], %g2 <== NOT EXECUTED success = _Thread_Wait_flags_try_change_acquire( 4000d96c: 84 10 a0 02 or %g2, 2, %g2 <== NOT EXECUTED the_thread->Wait.flags = desired_flags; 4000d970: c4 27 20 50 st %g2, [ %i4 + 0x50 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000d974: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000d978: 01 00 00 00 nop executing, intend_to_block, wait_class | THREAD_WAIT_STATE_BLOCKED ); if ( !success ) { 4000d97c: 80 a4 00 03 cmp %l0, %g3 4000d980: 02 80 00 0e be 4000d9b8 <_Event_Seize+0xe0> <== ALWAYS TAKEN 4000d984: 01 00 00 00 nop __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000d988: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000d98c: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED ) { ISR_lock_Context lock_context; _Watchdog_Per_CPU_acquire_critical( cpu, &lock_context ); _Watchdog_Remove( 4000d990: d0 07 20 60 ld [ %i4 + 0x60 ], %o0 <== NOT EXECUTED 4000d994: 40 00 20 0b call 400159c0 <_Watchdog_Remove> <== NOT EXECUTED 4000d998: 92 07 20 68 add %i4, 0x68, %o1 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000d99c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000d9a0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000d9a4: 01 00 00 00 nop <== NOT EXECUTED _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000d9a8: 13 0c 00 57 sethi %hi(0x30015c00), %o1 <== NOT EXECUTED 4000d9ac: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED 4000d9b0: 40 00 15 9c call 40013020 <_Thread_Clear_state> <== NOT EXECUTED 4000d9b4: 92 12 63 ff or %o1, 0x3ff, %o1 <== NOT EXECUTED _Thread_Timer_remove( executing ); _Thread_Unblock( executing ); } _Thread_Dispatch_direct( cpu_self ); 4000d9b8: 40 00 16 3c call 400132a8 <_Thread_Dispatch_direct> 4000d9bc: 90 10 00 1d mov %i5, %o0 RTEMS_INLINE_ROUTINE rtems_status_code _Status_Get( Status_Control status ) { return (rtems_status_code) STATUS_GET_CLASSIC( status ); 4000d9c0: f0 0f 20 4f ldub [ %i4 + 0x4f ], %i0 return _Status_Get_after_wait( executing ); } 4000d9c4: 81 c7 e0 08 ret 4000d9c8: 81 e8 00 00 restore register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000d9cc: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 <== NOT EXECUTED 4000d9d0: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000d9d4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000d9d8: 01 00 00 00 nop *event_out = seized_events; 4000d9dc: c4 26 c0 00 st %g2, [ %i3 ] return RTEMS_UNSATISFIED; 4000d9e0: 81 c7 e0 08 ret 4000d9e4: 91 e8 20 0d restore %g0, 0xd, %o0 RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear( rtems_event_set the_event_set, rtems_event_set the_mask ) { return ( the_event_set & ~(the_mask) ); 4000d9e8: 82 28 40 02 andn %g1, %g2, %g1 <== NOT EXECUTED event->pending_events = 4000d9ec: c2 27 40 00 st %g1, [ %i5 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000d9f0: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 <== NOT EXECUTED 4000d9f4: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000d9f8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000d9fc: 01 00 00 00 nop *event_out = seized_events; 4000da00: c4 26 c0 00 st %g2, [ %i3 ] return RTEMS_SUCCESSFUL; 4000da04: 81 c7 e0 08 ret 4000da08: 91 e8 20 00 restore %g0, 0, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000da0c: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000da10: c2 27 bf fc st %g1, [ %fp + -4 ] _ISR_lock_ISR_disable_and_acquire( &the_thread->Timer.Lock, &lock_context ); the_thread->Timer.header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ]; the_thread->Timer.Watchdog.routine = _Thread_Timeout; 4000da14: 05 10 00 55 sethi %hi(0x40015400), %g2 expire = ticks + cpu->Watchdog.ticks; 4000da18: d4 19 a0 30 ldd [ %g6 + 0x30 ], %o2 &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ]; 4000da1c: 90 01 a0 38 add %g6, 0x38, %o0 the_thread->Timer.Watchdog.routine = _Thread_Timeout; 4000da20: 84 10 a0 20 or %g2, 0x20, %g2 the_thread->Timer.header = 4000da24: d0 27 20 60 st %o0, [ %i4 + 0x60 ] _Watchdog_Insert(header, the_watchdog, expire); 4000da28: 86 82 c0 1a addcc %o3, %i2, %g3 the_thread->Timer.Watchdog.routine = _Thread_Timeout; 4000da2c: c4 27 20 78 st %g2, [ %i4 + 0x78 ] 4000da30: 84 42 a0 00 addx %o2, 0, %g2 4000da34: 92 07 20 68 add %i4, 0x68, %o1 4000da38: 94 10 00 02 mov %g2, %o2 4000da3c: 40 00 1f b9 call 40015920 <_Watchdog_Insert> 4000da40: 96 10 00 03 mov %g3, %o3 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000da44: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000da48: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000da4c: 01 00 00 00 nop _Thread_Set_state( executing, block_state ); 4000da50: 10 bf ff c0 b 4000d950 <_Event_Seize+0x78> 4000da54: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 =============================================================================== 4000d254 <_Event_Surrender>: rtems_event_set event_in, Event_Control *event, Thread_Wait_flags wait_class, ISR_lock_Context *lock_context ) { 4000d254: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE void _Event_sets_Post( rtems_event_set the_new_events, rtems_event_set *the_event_set ) { *the_event_set |= the_new_events; 4000d258: c2 06 80 00 ld [ %i2 ], %g1 4000d25c: b2 16 40 01 or %i1, %g1, %i1 4000d260: f2 26 80 00 st %i1, [ %i2 ] return ( wait_flags & wait_mask ) == wait_class; 4000d264: 03 00 00 3f sethi %hi(0xfc00), %g1 4000d268: c4 06 20 50 ld [ %i0 + 0x50 ], %g2 4000d26c: 82 10 63 04 or %g1, 0x304, %g1 4000d270: 82 08 80 01 and %g2, %g1, %g1 _Thread_Wait_acquire_default_critical( the_thread, lock_context ); _Event_sets_Post( event_in, &event->pending_events ); pending_events = event->pending_events; if ( 4000d274: 80 a0 40 1b cmp %g1, %i3 4000d278: 22 80 00 07 be,a 4000d294 <_Event_Surrender+0x40> 4000d27c: c6 06 20 3c ld [ %i0 + 0x3c ], %g3 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000d280: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000d284: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000d288: 01 00 00 00 nop } else { _Thread_Wait_release_default( the_thread, lock_context ); } return RTEMS_SUCCESSFUL; } 4000d28c: 81 c7 e0 08 ret 4000d290: 91 e8 20 00 restore %g0, 0, %o0 && ( *seized_events == event_condition || _Options_Is_any( option_set ) ); 4000d294: 88 88 c0 19 andcc %g3, %i1, %g4 4000d298: 02 bf ff fa be 4000d280 <_Event_Surrender+0x2c> <== NEVER TAKEN 4000d29c: 80 a0 c0 04 cmp %g3, %g4 4000d2a0: 02 80 00 05 be 4000d2b4 <_Event_Surrender+0x60> 4000d2a4: fa 06 20 48 ld [ %i0 + 0x48 ], %i5 4000d2a8: 80 8f 60 02 btst 2, %i5 4000d2ac: 02 bf ff f5 be 4000d280 <_Event_Surrender+0x2c> <== NEVER TAKEN 4000d2b0: 01 00 00 00 nop 4000d2b4: fa 06 20 40 ld [ %i0 + 0x40 ], %i5 RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear( rtems_event_set the_event_set, rtems_event_set the_mask ) { return ( the_event_set & ~(the_mask) ); 4000d2b8: b2 2e 40 04 andn %i1, %g4, %i1 event->pending_events = _Event_sets_Clear( pending_events, seized_events ); 4000d2bc: f2 26 80 00 st %i1, [ %i2 ] success = _Thread_Wait_flags_try_change_release( 4000d2c0: 86 10 60 01 or %g1, 1, %g3 *(rtems_event_set *) the_thread->Wait.return_argument = seized_events; 4000d2c4: c8 27 40 00 st %g4, [ %i5 ] ready_again = wait_class | THREAD_WAIT_STATE_READY_AGAIN; 4000d2c8: 82 10 60 04 or %g1, 4, %g1 if ( success ) { 4000d2cc: 80 a0 c0 02 cmp %g3, %g2 4000d2d0: 02 bf ff ec be 4000d280 <_Event_Surrender+0x2c> <== NEVER TAKEN 4000d2d4: c2 26 20 50 st %g1, [ %i0 + 0x50 ] <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 4000d2d8: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000d2dc: 82 00 60 01 inc %g1 <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000d2e0: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000d2e4: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000d2e8: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000d2ec: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000d2f0: 01 00 00 00 nop <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000d2f4: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000d2f8: c2 27 bf fc st %g1, [ %fp + -4 ] _Watchdog_Remove( 4000d2fc: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 4000d300: 7f ff fa 4b call 4000bc2c <_Watchdog_Remove> 4000d304: 92 06 20 68 add %i0, 0x68, %o1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000d308: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000d30c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000d310: 01 00 00 00 nop _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000d314: 13 0c 00 57 sethi %hi(0x30015c00), %o1 4000d318: 90 10 00 18 mov %i0, %o0 4000d31c: 40 00 02 af call 4000ddd8 <_Thread_Clear_state> 4000d320: 92 12 63 ff or %o1, 0x3ff, %o1 uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000d324: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 if ( disable_level == 1 ) { 4000d328: 80 a0 60 01 cmp %g1, 1 4000d32c: 02 80 00 04 be 4000d33c <_Event_Surrender+0xe8> <== ALWAYS TAKEN 4000d330: 82 00 7f ff add %g1, -1, %g1 cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000d334: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED 4000d338: 30 bf ff d5 b,a 4000d28c <_Event_Surrender+0x38> <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000d33c: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000d340: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2 4000d344: 80 a0 a0 00 cmp %g2, 0 4000d348: 12 80 00 06 bne 4000d360 <_Event_Surrender+0x10c> 4000d34c: 92 10 00 01 mov %g1, %o1 cpu_self->thread_dispatch_disable_level = 0; 4000d350: c0 27 60 18 clr [ %i5 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000d354: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000d358: 01 00 00 00 nop 4000d35c: 30 bf ff cc b,a 4000d28c <_Event_Surrender+0x38> _Thread_Do_dispatch( cpu_self, level ); 4000d360: c2 27 bf fc st %g1, [ %fp + -4 ] 4000d364: 7f ff f2 43 call 40009c70 <_Thread_Do_dispatch> 4000d368: 90 10 00 1d mov %i5, %o0 4000d36c: 10 bf ff fa b 4000d354 <_Event_Surrender+0x100> 4000d370: c2 07 bf fc ld [ %fp + -4 ], %g1 =============================================================================== 4000682c <_Freechain_Get>: Freechain_Control *freechain, Freechain_Allocator allocator, size_t number_nodes_to_extend, size_t node_size ) { 4000682c: 9d e3 bf a0 save %sp, -96, %sp 40006830: ba 10 00 18 mov %i0, %i5 return _Chain_Immutable_head( the_chain )->next; 40006834: f0 06 00 00 ld [ %i0 ], %i0 return &the_chain->Tail.Node; 40006838: 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 ) { 4000683c: 80 a6 00 1c cmp %i0, %i4 40006840: 12 80 00 04 bne 40006850 <_Freechain_Get+0x24> 40006844: 80 a6 a0 00 cmp %i2, 0 40006848: 12 80 00 0a bne 40006870 <_Freechain_Get+0x44> <== ALWAYS TAKEN 4000684c: 01 00 00 00 nop if ( !_Chain_Is_empty(the_chain)) 40006850: 80 a7 00 18 cmp %i4, %i0 40006854: 02 80 00 12 be 4000689c <_Freechain_Get+0x70> <== NEVER TAKEN 40006858: 01 00 00 00 nop new_first = old_first->next; 4000685c: c2 06 00 00 ld [ %i0 ], %g1 head->next = new_first; 40006860: c2 27 40 00 st %g1, [ %i5 ] new_first->previous = head; 40006864: fa 20 60 04 st %i5, [ %g1 + 4 ] 40006868: 81 c7 e0 08 ret 4000686c: 81 e8 00 00 restore void *starting_address; starting_address = ( *allocator )( number_nodes_to_extend * node_size ); 40006870: 9f c6 40 00 call %i1 40006874: 90 5e 80 1b smul %i2, %i3, %o0 number_nodes_to_extend *= ( starting_address != NULL ); 40006878: 80 a0 00 08 cmp %g0, %o0 starting_address = ( *allocator )( number_nodes_to_extend * node_size ); 4000687c: 92 10 00 08 mov %o0, %o1 number_nodes_to_extend *= ( starting_address != NULL ); 40006880: 94 40 20 00 addx %g0, 0, %o2 _Chain_Initialize( 40006884: 96 10 00 1b mov %i3, %o3 40006888: 94 5a 80 1a smul %o2, %i2, %o2 4000688c: 7f ff ff c7 call 400067a8 <_Chain_Initialize> 40006890: 90 10 00 1d mov %i5, %o0 40006894: 10 bf ff ef b 40006850 <_Freechain_Get+0x24> 40006898: f0 07 40 00 ld [ %i5 ], %i0 node_size ); } return _Chain_Get_unprotected( &freechain->Free ); } 4000689c: 81 c7 e0 08 ret <== NOT EXECUTED 400068a0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED =============================================================================== 400068a4 <_Freechain_Put>: void _Freechain_Put( Freechain_Control *freechain, void *node ) { if ( node != NULL ) { 400068a4: 80 a2 60 00 cmp %o1, 0 400068a8: 02 80 00 07 be 400068c4 <_Freechain_Put+0x20> <== NEVER TAKEN 400068ac: 01 00 00 00 nop the_node->previous = after_node; 400068b0: d0 22 60 04 st %o0, [ %o1 + 4 ] before_node = after_node->next; 400068b4: c2 02 00 00 ld [ %o0 ], %g1 after_node->next = the_node; 400068b8: d2 22 00 00 st %o1, [ %o0 ] the_node->next = before_node; 400068bc: c2 22 40 00 st %g1, [ %o1 ] before_node->previous = the_node; 400068c0: d2 20 60 04 st %o1, [ %g1 + 4 ] _Chain_Initialize_node( node ); _Chain_Prepend_unprotected( &freechain->Free, node ); } } 400068c4: 81 c3 e0 08 retl 400068c8: 01 00 00 00 nop =============================================================================== 40006cdc <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 40006cdc: 9d e3 bf a0 save %sp, -96, %sp 40006ce0: 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 ) { 40006ce4: 80 a6 7f fc cmp %i1, -4 40006ce8: 1a 80 00 8a bcc 40006f10 <_Heap_Allocate_aligned_with_boundary+0x234> <== NEVER TAKEN 40006cec: da 06 20 10 ld [ %i0 + 0x10 ], %o5 /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { 40006cf0: 80 a6 e0 00 cmp %i3, 0 40006cf4: 12 80 00 81 bne 40006ef8 <_Heap_Allocate_aligned_with_boundary+0x21c> <== NEVER TAKEN 40006cf8: 80 a6 40 1b cmp %i1, %i3 return _Heap_Free_list_head(heap)->next; 40006cfc: 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 ) { 40006d00: 80 a6 00 09 cmp %i0, %o1 40006d04: 02 80 00 78 be 40006ee4 <_Heap_Allocate_aligned_with_boundary+0x208> <== NEVER TAKEN 40006d08: ba 10 20 00 clr %i5 uintptr_t alloc_begin = alloc_end - alloc_size; 40006d0c: 9e 10 20 04 mov 4, %o7 uintptr_t const alloc_begin_ceiling = block_end - min_block_size 40006d10: 96 03 60 07 add %o5, 7, %o3 uintptr_t alloc_begin = alloc_end - alloc_size; 40006d14: 9e 23 c0 19 sub %o7, %i1, %o7 uintptr_t const free_size = alloc_block_begin - block_begin; 40006d18: 10 80 00 09 b 40006d3c <_Heap_Allocate_aligned_with_boundary+0x60> 40006d1c: 94 10 3f f8 mov -8, %o2 } /* Statistics */ ++search_count; if ( alloc_begin != 0 ) { 40006d20: 80 a7 20 00 cmp %i4, 0 40006d24: 32 80 00 5b bne,a 40006e90 <_Heap_Allocate_aligned_with_boundary+0x1b4> <== ALWAYS TAKEN 40006d28: 96 10 00 19 mov %i1, %o3 break; } block = block->next; 40006d2c: d2 02 60 08 ld [ %o1 + 8 ], %o1 while ( block != free_list_tail ) { 40006d30: 80 a6 00 09 cmp %i0, %o1 40006d34: 22 80 00 6d be,a 40006ee8 <_Heap_Allocate_aligned_with_boundary+0x20c> <== NEVER TAKEN 40006d38: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED if ( block->size_and_flag > block_size_floor ) { 40006d3c: c2 02 60 04 ld [ %o1 + 4 ], %g1 40006d40: 80 a0 40 04 cmp %g1, %g4 40006d44: 08 bf ff fa bleu 40006d2c <_Heap_Allocate_aligned_with_boundary+0x50> 40006d48: ba 07 60 01 inc %i5 if ( alignment == 0 ) { 40006d4c: 80 a6 a0 00 cmp %i2, 0 40006d50: 02 bf ff f4 be 40006d20 <_Heap_Allocate_aligned_with_boundary+0x44> <== ALWAYS TAKEN 40006d54: b8 02 60 08 add %o1, 8, %i4 40006d58: d8 06 20 14 ld [ %i0 + 0x14 ], %o4 <== NOT EXECUTED return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40006d5c: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED uintptr_t const alloc_begin_ceiling = block_end - min_block_size 40006d60: 86 22 c0 0c sub %o3, %o4, %g3 <== NOT EXECUTED uintptr_t const block_end = block_begin + block_size; 40006d64: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED uintptr_t const alloc_begin_ceiling = block_end - min_block_size 40006d68: 86 00 c0 01 add %g3, %g1, %g3 <== NOT EXECUTED uintptr_t alloc_begin = alloc_end - alloc_size; 40006d6c: 82 03 c0 01 add %o7, %g1, %g1 <== NOT EXECUTED return value - (value % alignment); 40006d70: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 40006d74: 01 00 00 00 nop <== NOT EXECUTED 40006d78: 01 00 00 00 nop <== NOT EXECUTED 40006d7c: 01 00 00 00 nop <== NOT EXECUTED 40006d80: 84 70 40 1a udiv %g1, %i2, %g2 <== NOT EXECUTED 40006d84: 84 58 80 1a smul %g2, %i2, %g2 <== NOT EXECUTED if ( alloc_begin > alloc_begin_ceiling ) { 40006d88: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED 40006d8c: 1a 80 00 08 bcc 40006dac <_Heap_Allocate_aligned_with_boundary+0xd0> <== NOT EXECUTED 40006d90: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 40006d94: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 40006d98: 01 00 00 00 nop <== NOT EXECUTED 40006d9c: 01 00 00 00 nop <== NOT EXECUTED 40006da0: 01 00 00 00 nop <== NOT EXECUTED 40006da4: 84 70 c0 1a udiv %g3, %i2, %g2 <== NOT EXECUTED 40006da8: 84 58 80 1a smul %g2, %i2, %g2 <== NOT EXECUTED if ( boundary != 0 ) { 40006dac: 02 80 00 26 be 40006e44 <_Heap_Allocate_aligned_with_boundary+0x168> <== NOT EXECUTED 40006db0: 80 a7 00 02 cmp %i4, %g2 <== NOT EXECUTED alloc_end = alloc_begin + alloc_size; 40006db4: 86 06 40 02 add %i1, %g2, %g3 <== NOT EXECUTED 40006db8: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 40006dbc: 01 00 00 00 nop <== NOT EXECUTED 40006dc0: 01 00 00 00 nop <== NOT EXECUTED 40006dc4: 01 00 00 00 nop <== NOT EXECUTED 40006dc8: 82 70 c0 1b udiv %g3, %i3, %g1 <== NOT EXECUTED 40006dcc: 82 58 40 1b smul %g1, %i3, %g1 <== NOT EXECUTED while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 40006dd0: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40006dd4: 1a 80 00 1b bcc 40006e40 <_Heap_Allocate_aligned_with_boundary+0x164> <== NOT EXECUTED 40006dd8: 90 06 40 1c add %i1, %i4, %o0 <== NOT EXECUTED 40006ddc: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 40006de0: 2a 80 00 06 bcs,a 40006df8 <_Heap_Allocate_aligned_with_boundary+0x11c> <== NOT EXECUTED 40006de4: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED if ( alloc_begin >= alloc_begin_floor ) { 40006de8: 10 80 00 17 b 40006e44 <_Heap_Allocate_aligned_with_boundary+0x168> <== NOT EXECUTED 40006dec: 80 a7 00 02 cmp %i4, %g2 <== NOT EXECUTED while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 40006df0: 1a 80 00 14 bcc 40006e40 <_Heap_Allocate_aligned_with_boundary+0x164> <== NOT EXECUTED 40006df4: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED if ( boundary_line < boundary_floor ) { 40006df8: 18 bf ff cd bgu 40006d2c <_Heap_Allocate_aligned_with_boundary+0x50> <== NOT EXECUTED 40006dfc: 82 20 40 19 sub %g1, %i1, %g1 <== NOT EXECUTED 40006e00: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 40006e04: 01 00 00 00 nop <== NOT EXECUTED 40006e08: 01 00 00 00 nop <== NOT EXECUTED 40006e0c: 01 00 00 00 nop <== NOT EXECUTED 40006e10: 84 70 40 1a udiv %g1, %i2, %g2 <== NOT EXECUTED 40006e14: 84 58 80 1a smul %g2, %i2, %g2 <== NOT EXECUTED alloc_end = alloc_begin + alloc_size; 40006e18: 86 06 40 02 add %i1, %g2, %g3 <== NOT EXECUTED 40006e1c: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 40006e20: 01 00 00 00 nop <== NOT EXECUTED 40006e24: 01 00 00 00 nop <== NOT EXECUTED 40006e28: 01 00 00 00 nop <== NOT EXECUTED 40006e2c: 82 70 c0 1b udiv %g3, %i3, %g1 <== NOT EXECUTED 40006e30: 82 58 40 1b smul %g1, %i3, %g1 <== NOT EXECUTED while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 40006e34: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 40006e38: 0a bf ff ee bcs 40006df0 <_Heap_Allocate_aligned_with_boundary+0x114> <== NOT EXECUTED 40006e3c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED if ( alloc_begin >= alloc_begin_floor ) { 40006e40: 80 a7 00 02 cmp %i4, %g2 <== NOT EXECUTED 40006e44: 18 bf ff ba bgu 40006d2c <_Heap_Allocate_aligned_with_boundary+0x50> <== NOT EXECUTED 40006e48: 82 22 80 09 sub %o2, %o1, %g1 <== NOT EXECUTED 40006e4c: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 40006e50: 01 00 00 00 nop <== NOT EXECUTED 40006e54: 01 00 00 00 nop <== NOT EXECUTED 40006e58: 01 00 00 00 nop <== NOT EXECUTED 40006e5c: 86 70 80 0d udiv %g2, %o5, %g3 <== NOT EXECUTED 40006e60: 86 58 c0 0d smul %g3, %o5, %g3 <== NOT EXECUTED uintptr_t const free_size = alloc_block_begin - block_begin; 40006e64: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED if ( free_size >= min_block_size || free_size == 0 ) { 40006e68: 80 a0 40 0c cmp %g1, %o4 <== NOT EXECUTED 40006e6c: 1a 80 00 04 bcc 40006e7c <_Heap_Allocate_aligned_with_boundary+0x1a0> <== NOT EXECUTED 40006e70: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40006e74: 32 bf ff af bne,a 40006d30 <_Heap_Allocate_aligned_with_boundary+0x54> <== NOT EXECUTED 40006e78: d2 02 60 08 ld [ %o1 + 8 ], %o1 <== NOT EXECUTED 40006e7c: b8 10 00 02 mov %g2, %i4 <== NOT EXECUTED if ( alloc_begin != 0 ) { 40006e80: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED 40006e84: 22 bf ff ab be,a 40006d30 <_Heap_Allocate_aligned_with_boundary+0x54> <== NOT EXECUTED 40006e88: 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 ); 40006e8c: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED 40006e90: 94 10 00 1c mov %i4, %o2 40006e94: 7f ff ff 3f call 40006b90 <_Heap_Block_allocate> 40006e98: 90 10 00 18 mov %i0, %o0 alignment, boundary ); /* Statistics */ ++stats->allocs; 40006e9c: f6 06 20 58 ld [ %i0 + 0x58 ], %i3 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40006ea0: c8 02 20 04 ld [ %o0 + 4 ], %g4 stats->searches += search_count; stats->lifetime_allocated += _Heap_Block_size( block ); 40006ea4: c4 1e 20 28 ldd [ %i0 + 0x28 ], %g2 stats->searches += search_count; 40006ea8: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 ++stats->allocs; 40006eac: b6 06 e0 01 inc %i3 stats->searches += search_count; 40006eb0: 82 00 40 1d add %g1, %i5, %g1 40006eb4: 88 09 3f fe and %g4, -2, %g4 ++stats->allocs; 40006eb8: f6 26 20 58 st %i3, [ %i0 + 0x58 ] stats->lifetime_allocated += _Heap_Block_size( block ); 40006ebc: b6 80 c0 04 addcc %g3, %g4, %i3 stats->searches += search_count; 40006ec0: c2 26 20 54 st %g1, [ %i0 + 0x54 ] stats->lifetime_allocated += _Heap_Block_size( block ); 40006ec4: b4 40 a0 00 addx %g2, 0, %i2 40006ec8: f4 3e 20 28 std %i2, [ %i0 + 0x28 ] /* Statistics */ ++stats->failed_allocs; } /* Statistics */ if ( stats->max_search < search_count ) { 40006ecc: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 40006ed0: 80 a0 40 1d cmp %g1, %i5 40006ed4: 2a 80 00 02 bcs,a 40006edc <_Heap_Allocate_aligned_with_boundary+0x200> 40006ed8: fa 26 20 50 st %i5, [ %i0 + 0x50 ] stats->max_search = search_count; } return (void *) alloc_begin; } 40006edc: 81 c7 e0 08 ret 40006ee0: 91 e8 00 1c restore %g0, %i4, %o0 ++stats->failed_allocs; 40006ee4: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED 40006ee8: 82 00 60 01 inc %g1 <== NOT EXECUTED 40006eec: b8 10 20 00 clr %i4 <== NOT EXECUTED 40006ef0: 10 bf ff f7 b 40006ecc <_Heap_Allocate_aligned_with_boundary+0x1f0> <== NOT EXECUTED 40006ef4: c2 26 20 5c st %g1, [ %i0 + 0x5c ] <== NOT EXECUTED if ( boundary < alloc_size ) { 40006ef8: 18 80 00 06 bgu 40006f10 <_Heap_Allocate_aligned_with_boundary+0x234> <== NOT EXECUTED 40006efc: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED if ( alignment == 0 ) { 40006f00: 22 bf ff 7f be,a 40006cfc <_Heap_Allocate_aligned_with_boundary+0x20> <== NOT EXECUTED 40006f04: b4 10 00 0d mov %o5, %i2 <== NOT EXECUTED return _Heap_Free_list_head(heap)->next; 40006f08: 10 bf ff 7e b 40006d00 <_Heap_Allocate_aligned_with_boundary+0x24> <== NOT EXECUTED 40006f0c: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED return NULL; 40006f10: b8 10 20 00 clr %i4 <== NOT EXECUTED } 40006f14: 81 c7 e0 08 ret <== NOT EXECUTED 40006f18: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED =============================================================================== 40006b90 <_Heap_Block_allocate>: Heap_Control *heap, Heap_Block *block, uintptr_t alloc_begin, uintptr_t alloc_size ) { 40006b90: 9d e3 bf a0 save %sp, -96, %sp return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40006b94: c2 06 60 04 ld [ %i1 + 4 ], %g1 40006b98: 82 08 7f fe and %g1, -2, %g1 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40006b9c: 84 06 40 01 add %i1, %g1, %g2 40006ba0: c4 00 a0 04 ld [ %g2 + 4 ], %g2 40006ba4: ba 10 00 18 mov %i0, %i5 Heap_Block *free_list_anchor = NULL; _HAssert( alloc_area_begin <= alloc_begin ); if ( _Heap_Is_free( block ) ) { 40006ba8: 80 88 a0 01 btst 1, %g2 40006bac: b0 06 bf f8 add %i2, -8, %i0 return &heap->free_list; 40006bb0: 94 10 00 1d mov %i5, %o2 40006bb4: 12 80 00 0f bne 40006bf0 <_Heap_Block_allocate+0x60> <== NEVER TAKEN 40006bb8: 96 26 00 19 sub %i0, %i1, %o3 40006bbc: c4 06 60 08 ld [ %i1 + 8 ], %g2 free_list_anchor = block->prev; 40006bc0: d4 06 60 0c ld [ %i1 + 0xc ], %o2 prev->next = next; 40006bc4: c4 22 a0 08 st %g2, [ %o2 + 8 ] next->prev = prev; 40006bc8: d4 20 a0 0c st %o2, [ %g2 + 0xc ] _Heap_Free_list_remove( block ); /* Statistics */ --stats->free_blocks; 40006bcc: f8 07 60 44 ld [ %i5 + 0x44 ], %i4 ++stats->used_blocks; 40006bd0: c8 07 60 4c ld [ %i5 + 0x4c ], %g4 stats->free_size -= _Heap_Block_size( block ); 40006bd4: c4 07 60 3c ld [ %i5 + 0x3c ], %g2 --stats->free_blocks; 40006bd8: b8 07 3f ff add %i4, -1, %i4 ++stats->used_blocks; 40006bdc: 88 01 20 01 inc %g4 stats->free_size -= _Heap_Block_size( block ); 40006be0: 82 20 80 01 sub %g2, %g1, %g1 --stats->free_blocks; 40006be4: f8 27 60 44 st %i4, [ %i5 + 0x44 ] ++stats->used_blocks; 40006be8: c8 27 60 4c st %g4, [ %i5 + 0x4c ] stats->free_size -= _Heap_Block_size( block ); 40006bec: c2 27 60 3c st %g1, [ %i5 + 0x3c ] } else { free_list_anchor = _Heap_Free_list_head( heap ); } if ( alloc_area_offset < heap->page_size ) { 40006bf0: c4 07 60 10 ld [ %i5 + 0x10 ], %g2 40006bf4: 80 a0 80 0b cmp %g2, %o3 40006bf8: 28 80 00 0e bleu,a 40006c30 <_Heap_Block_allocate+0xa0> <== NEVER TAKEN 40006bfc: c6 07 60 3c ld [ %i5 + 0x3c ], %g3 <== NOT EXECUTED _Heap_Block_split( heap, block, free_list_anchor, alloc_size ); 40006c00: 96 02 c0 1b add %o3, %i3, %o3 40006c04: 92 10 00 19 mov %i1, %o1 40006c08: 90 10 00 1d mov %i5, %o0 40006c0c: 7f ff ff 30 call 400068cc <_Heap_Block_split> 40006c10: b0 10 00 19 mov %i1, %i0 alloc_size ); } /* Statistics */ if ( stats->min_free_size > stats->free_size ) { 40006c14: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 40006c18: c4 07 60 40 ld [ %i5 + 0x40 ], %g2 40006c1c: 80 a0 80 01 cmp %g2, %g1 40006c20: 38 80 00 02 bgu,a 40006c28 <_Heap_Block_allocate+0x98> 40006c24: c2 27 60 40 st %g1, [ %i5 + 0x40 ] } _Heap_Protection_block_initialize( heap, block ); return block; } 40006c28: 81 c7 e0 08 ret 40006c2c: 81 e8 00 00 restore return value - (value % alignment); 40006c30: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 40006c34: 01 00 00 00 nop <== NOT EXECUTED 40006c38: 01 00 00 00 nop <== NOT EXECUTED 40006c3c: 01 00 00 00 nop <== NOT EXECUTED 40006c40: 88 76 80 02 udiv %i2, %g2, %g4 <== NOT EXECUTED 40006c44: 84 59 00 02 smul %g4, %g2, %g2 <== NOT EXECUTED return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40006c48: c2 06 60 04 ld [ %i1 + 4 ], %g1 <== NOT EXECUTED return value - (value % alignment); 40006c4c: b4 26 80 02 sub %i2, %g2, %i2 <== NOT EXECUTED - HEAP_BLOCK_HEADER_SIZE); 40006c50: b0 26 00 1a sub %i0, %i2, %i0 <== NOT EXECUTED block_size = block_end - block_begin; 40006c54: 84 26 00 19 sub %i0, %i1, %g2 <== NOT EXECUTED stats->free_size += block_size; 40006c58: 86 00 c0 02 add %g3, %g2, %g3 <== NOT EXECUTED 40006c5c: c6 27 60 3c st %g3, [ %i5 + 0x3c ] <== NOT EXECUTED return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40006c60: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40006c64: c6 06 60 04 ld [ %i1 + 4 ], %g3 <== NOT EXECUTED uintptr_t block_end = block_begin + block_size; 40006c68: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED if ( _Heap_Is_prev_used( block ) ) { 40006c6c: 80 88 e0 01 btst 1, %g3 <== NOT EXECUTED 40006c70: 12 80 00 11 bne 40006cb4 <_Heap_Block_allocate+0x124> <== NOT EXECUTED 40006c74: 82 20 40 18 sub %g1, %i0, %g1 <== NOT EXECUTED return (Heap_Block *) ((uintptr_t) block - block->prev_size); 40006c78: c6 06 40 00 ld [ %i1 ], %g3 <== NOT EXECUTED 40006c7c: b2 26 40 03 sub %i1, %g3, %i1 <== NOT EXECUTED return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40006c80: c6 06 60 04 ld [ %i1 + 4 ], %g3 <== NOT EXECUTED 40006c84: 86 08 ff fe and %g3, -2, %g3 <== NOT EXECUTED block_size += prev_block_size; 40006c88: 84 00 80 03 add %g2, %g3, %g2 <== NOT EXECUTED block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; 40006c8c: 86 10 a0 01 or %g2, 1, %g3 <== NOT EXECUTED 40006c90: c6 26 60 04 st %g3, [ %i1 + 4 ] <== NOT EXECUTED _Heap_Block_split( heap, new_block, free_list_anchor, alloc_size ); 40006c94: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED new_block->prev_size = block_size; 40006c98: c4 26 00 00 st %g2, [ %i0 ] <== NOT EXECUTED _Heap_Block_split( heap, new_block, free_list_anchor, alloc_size ); 40006c9c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED new_block->size_and_flag = new_block_size; 40006ca0: c2 26 20 04 st %g1, [ %i0 + 4 ] <== NOT EXECUTED _Heap_Block_split( heap, new_block, free_list_anchor, alloc_size ); 40006ca4: 7f ff ff 0a call 400068cc <_Heap_Block_split> <== NOT EXECUTED 40006ca8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED if ( stats->min_free_size > stats->free_size ) { 40006cac: 10 bf ff db b 40006c18 <_Heap_Block_allocate+0x88> <== NOT EXECUTED 40006cb0: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED Heap_Block *next = block_before->next; 40006cb4: c8 02 a0 08 ld [ %o2 + 8 ], %g4 <== NOT EXECUTED new_block->next = next; 40006cb8: c8 26 60 08 st %g4, [ %i1 + 8 ] <== NOT EXECUTED new_block->prev = block_before; 40006cbc: d4 26 60 0c st %o2, [ %i1 + 0xc ] <== NOT EXECUTED block_before->next = new_block; 40006cc0: f2 22 a0 08 st %i1, [ %o2 + 8 ] <== NOT EXECUTED ++stats->free_blocks; 40006cc4: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 40006cc8: c6 07 60 44 ld [ %i5 + 0x44 ], %g3 <== NOT EXECUTED next->prev = new_block; 40006ccc: f2 21 20 0c st %i1, [ %g4 + 0xc ] <== NOT EXECUTED 40006cd0: 86 00 e0 01 inc %g3 <== NOT EXECUTED 40006cd4: 10 bf ff ee b 40006c8c <_Heap_Block_allocate+0xfc> <== NOT EXECUTED 40006cd8: c6 27 60 44 st %g3, [ %i5 + 0x44 ] <== NOT EXECUTED =============================================================================== 4000d5b8 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 4000d5b8: 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 ) { 4000d5bc: 80 a6 60 00 cmp %i1, 0 4000d5c0: 02 80 00 41 be 4000d6c4 <_Heap_Free+0x10c> 4000d5c4: 84 10 20 01 mov 1, %g2 return value - (value % alignment); 4000d5c8: c8 06 20 10 ld [ %i0 + 0x10 ], %g4 return (uintptr_t) block >= (uintptr_t) heap->first_block 4000d5cc: c6 06 20 20 ld [ %i0 + 0x20 ], %g3 return value - (value % alignment); 4000d5d0: 81 80 20 00 wr %g0, %y 4000d5d4: 01 00 00 00 nop 4000d5d8: 01 00 00 00 nop 4000d5dc: 01 00 00 00 nop 4000d5e0: 82 76 40 04 udiv %i1, %g4, %g1 4000d5e4: 82 58 40 04 smul %g1, %g4, %g1 - HEAP_BLOCK_HEADER_SIZE); 4000d5e8: 82 00 7f f8 add %g1, -8, %g1 && (uintptr_t) block <= (uintptr_t) heap->last_block; 4000d5ec: 80 a0 40 03 cmp %g1, %g3 4000d5f0: 0a 80 00 35 bcs 4000d6c4 <_Heap_Free+0x10c> <== NEVER TAKEN 4000d5f4: 84 10 20 00 clr %g2 4000d5f8: f6 06 20 24 ld [ %i0 + 0x24 ], %i3 4000d5fc: 80 a0 40 1b cmp %g1, %i3 4000d600: 38 80 00 32 bgu,a 4000d6c8 <_Heap_Free+0x110> <== NEVER TAKEN 4000d604: b0 08 a0 ff and %g2, 0xff, %i0 <== NOT EXECUTED 4000d608: fa 00 60 04 ld [ %g1 + 4 ], %i5 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000d60c: b8 0f 7f fe and %i5, -2, %i4 return (Heap_Block *) ((uintptr_t) block + offset); 4000d610: 88 00 40 1c add %g1, %i4, %g4 && (uintptr_t) block <= (uintptr_t) heap->last_block; 4000d614: 80 a0 c0 04 cmp %g3, %g4 4000d618: 38 80 00 2c bgu,a 4000d6c8 <_Heap_Free+0x110> <== NEVER TAKEN 4000d61c: b0 08 a0 ff and %g2, 0xff, %i0 <== NOT EXECUTED 4000d620: 80 a6 c0 04 cmp %i3, %g4 4000d624: 2a 80 00 29 bcs,a 4000d6c8 <_Heap_Free+0x110> <== NEVER TAKEN 4000d628: b0 08 a0 ff and %g2, 0xff, %i0 <== NOT EXECUTED 4000d62c: f4 01 20 04 ld [ %g4 + 4 ], %i2 return false; } _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_prev_used( next_block ) ) { 4000d630: 80 8e a0 01 btst 1, %i2 4000d634: 02 80 00 24 be 4000d6c4 <_Heap_Free+0x10c> <== NEVER TAKEN 4000d638: 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 )); 4000d63c: 80 a6 c0 04 cmp %i3, %g4 4000d640: 02 80 00 24 be 4000d6d0 <_Heap_Free+0x118> <== NEVER TAKEN 4000d644: ba 0f 60 01 and %i5, 1, %i5 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000d648: 84 01 00 1a add %g4, %i2, %g2 4000d64c: c4 00 a0 04 ld [ %g2 + 4 ], %g2 4000d650: 80 88 a0 01 btst 1, %g2 4000d654: 12 80 00 20 bne 4000d6d4 <_Heap_Free+0x11c> 4000d658: 80 a7 60 00 cmp %i5, 0 if ( !_Heap_Is_prev_used( block ) ) { 4000d65c: 02 80 00 20 be 4000d6dc <_Heap_Free+0x124> 4000d660: 9e 10 20 01 mov 1, %o7 4000d664: c6 01 20 08 ld [ %g4 + 8 ], %g3 4000d668: c4 01 20 0c ld [ %g4 + 0xc ], %g2 new_block->prev = prev; 4000d66c: 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; 4000d670: b4 07 00 1a add %i4, %i2, %i2 new_block->next = next; 4000d674: c6 20 60 08 st %g3, [ %g1 + 8 ] _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 4000d678: 88 16 a0 01 or %i2, 1, %g4 next->prev = new_block; 4000d67c: c2 20 e0 0c st %g1, [ %g3 + 0xc ] prev->next = new_block; 4000d680: c2 20 a0 08 st %g1, [ %g2 + 8 ] 4000d684: c8 20 60 04 st %g4, [ %g1 + 4 ] next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 4000d688: 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 ); 4000d68c: 84 10 20 01 mov 1, %g2 stats->lifetime_freed += block_size; 4000d690: f4 1e 20 30 ldd [ %i0 + 0x30 ], %i2 --stats->used_blocks; 4000d694: c8 06 20 4c ld [ %i0 + 0x4c ], %g4 ++stats->frees; 4000d698: c6 06 20 60 ld [ %i0 + 0x60 ], %g3 stats->free_size += block_size; 4000d69c: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 stats->lifetime_freed += block_size; 4000d6a0: 9a 86 c0 1c addcc %i3, %i4, %o5 --stats->used_blocks; 4000d6a4: 88 01 3f ff add %g4, -1, %g4 ++stats->frees; 4000d6a8: 86 00 e0 01 inc %g3 stats->free_size += block_size; 4000d6ac: 82 00 40 1c add %g1, %i4, %g1 stats->lifetime_freed += block_size; 4000d6b0: 98 46 a0 00 addx %i2, 0, %o4 --stats->used_blocks; 4000d6b4: c8 26 20 4c st %g4, [ %i0 + 0x4c ] ++stats->frees; 4000d6b8: c6 26 20 60 st %g3, [ %i0 + 0x60 ] stats->free_size += block_size; 4000d6bc: c2 26 20 3c st %g1, [ %i0 + 0x3c ] stats->lifetime_freed += block_size; 4000d6c0: d8 3e 20 30 std %o4, [ %i0 + 0x30 ] 4000d6c4: b0 08 a0 ff and %g2, 0xff, %i0 } 4000d6c8: 81 c7 e0 08 ret 4000d6cc: 81 e8 00 00 restore if ( !_Heap_Is_prev_used( block ) ) { 4000d6d0: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED 4000d6d4: 12 80 00 1c bne 4000d744 <_Heap_Free+0x18c> 4000d6d8: 9e 10 20 00 clr %o7 uintptr_t const prev_size = block->prev_size; 4000d6dc: f2 00 40 00 ld [ %g1 ], %i1 4000d6e0: ba 20 40 19 sub %g1, %i1, %i5 && (uintptr_t) block <= (uintptr_t) heap->last_block; 4000d6e4: 80 a7 40 03 cmp %i5, %g3 4000d6e8: 0a bf ff f7 bcs 4000d6c4 <_Heap_Free+0x10c> <== NEVER TAKEN 4000d6ec: 84 10 20 00 clr %g2 4000d6f0: 80 a7 40 1b cmp %i5, %i3 4000d6f4: 38 bf ff f5 bgu,a 4000d6c8 <_Heap_Free+0x110> <== NEVER TAKEN 4000d6f8: b0 08 a0 ff and %g2, 0xff, %i0 <== NOT EXECUTED return block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000d6fc: c6 07 60 04 ld [ %i5 + 4 ], %g3 if ( !_Heap_Is_prev_used ( prev_block) ) { 4000d700: 80 88 e0 01 btst 1, %g3 4000d704: 02 bf ff f0 be 4000d6c4 <_Heap_Free+0x10c> <== NEVER TAKEN 4000d708: 80 a3 e0 00 cmp %o7, 0 if ( next_is_free ) { /* coalesce both */ 4000d70c: 02 80 00 22 be 4000d794 <_Heap_Free+0x1dc> 4000d710: b2 06 40 1c add %i1, %i4, %i1 4000d714: c4 01 20 08 ld [ %g4 + 8 ], %g2 4000d718: c6 01 20 0c ld [ %g4 + 0xc ], %g3 prev->next = next; 4000d71c: c4 20 e0 08 st %g2, [ %g3 + 8 ] uintptr_t const size = block_size + prev_size + next_block_size; 4000d720: b4 06 80 19 add %i2, %i1, %i2 stats->free_blocks -= 1; 4000d724: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 next->prev = prev; 4000d728: c6 20 a0 0c st %g3, [ %g2 + 0xc ] 4000d72c: 82 00 7f ff add %g1, -1, %g1 4000d730: c2 26 20 44 st %g1, [ %i0 + 0x44 ] prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 4000d734: 82 16 a0 01 or %i2, 1, %g1 4000d738: c2 27 60 04 st %g1, [ %i5 + 4 ] 4000d73c: 10 bf ff d4 b 4000d68c <_Heap_Free+0xd4> 4000d740: f4 27 40 1a st %i2, [ %i5 + %i2 ] Heap_Block *next = block_before->next; 4000d744: c6 06 20 08 ld [ %i0 + 8 ], %g3 new_block->next = next; 4000d748: c6 20 60 08 st %g3, [ %g1 + 8 ] block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; 4000d74c: 84 17 20 01 or %i4, 1, %g2 new_block->prev = block_before; 4000d750: f0 20 60 0c st %i0, [ %g1 + 0xc ] block_before->next = new_block; 4000d754: c2 26 20 08 st %g1, [ %i0 + 8 ] next->prev = new_block; 4000d758: c2 20 e0 0c st %g1, [ %g3 + 0xc ] 4000d75c: c4 20 60 04 st %g2, [ %g1 + 4 ] next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 4000d760: c4 01 20 04 ld [ %g4 + 4 ], %g2 4000d764: 84 08 bf fe and %g2, -2, %g2 4000d768: c4 21 20 04 st %g2, [ %g4 + 4 ] ++stats->free_blocks; 4000d76c: c4 06 20 44 ld [ %i0 + 0x44 ], %g2 next_block->prev_size = block_size; 4000d770: f8 20 40 1c st %i4, [ %g1 + %i4 ] ++stats->free_blocks; 4000d774: 82 00 a0 01 add %g2, 1, %g1 4000d778: c2 26 20 44 st %g1, [ %i0 + 0x44 ] if ( stats->max_free_blocks < stats->free_blocks ) { 4000d77c: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 4000d780: 80 a0 40 02 cmp %g1, %g2 4000d784: 38 bf ff c2 bgu,a 4000d68c <_Heap_Free+0xd4> 4000d788: c2 26 20 48 st %g1, [ %i0 + 0x48 ] return( true ); 4000d78c: 10 bf ff c1 b 4000d690 <_Heap_Free+0xd8> 4000d790: 84 10 20 01 mov 1, %g2 prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 4000d794: 84 16 60 01 or %i1, 1, %g2 4000d798: c4 27 60 04 st %g2, [ %i5 + 4 ] next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 4000d79c: c4 01 20 04 ld [ %g4 + 4 ], %g2 4000d7a0: 84 08 bf fe and %g2, -2, %g2 4000d7a4: c4 21 20 04 st %g2, [ %g4 + 4 ] next_block->prev_size = size; 4000d7a8: 10 bf ff b9 b 4000d68c <_Heap_Free+0xd4> 4000d7ac: f2 20 40 1c st %i1, [ %g1 + %i4 ] =============================================================================== 400447a8 <_Heap_Get_free_information>: ) { Heap_Block *the_block; Heap_Block *const tail = _Heap_Free_list_tail(the_heap); info->number = 0; 400447a8: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED info->largest = 0; 400447ac: c0 22 60 04 clr [ %o1 + 4 ] <== NOT EXECUTED info->total = 0; 400447b0: c0 22 60 08 clr [ %o1 + 8 ] <== NOT EXECUTED return _Heap_Free_list_head(heap)->next; 400447b4: c4 02 20 08 ld [ %o0 + 8 ], %g2 <== NOT EXECUTED for(the_block = _Heap_Free_list_first(the_heap); 400447b8: 80 a2 00 02 cmp %o0, %g2 <== NOT EXECUTED 400447bc: 02 80 00 12 be 40044804 <_Heap_Get_free_information+0x5c> <== NOT EXECUTED 400447c0: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED 400447c4: 9a 10 20 00 clr %o5 <== NOT EXECUTED 400447c8: 10 80 00 03 b 400447d4 <_Heap_Get_free_information+0x2c> <== NOT EXECUTED 400447cc: 86 10 20 00 clr %g3 <== NOT EXECUTED 400447d0: da 02 60 04 ld [ %o1 + 4 ], %o5 <== NOT EXECUTED return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 400447d4: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED 400447d8: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED 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++; 400447dc: c8 22 40 00 st %g4, [ %o1 ] <== NOT EXECUTED info->total += the_size; 400447e0: 86 00 c0 01 add %g3, %g1, %g3 <== NOT EXECUTED if ( info->largest < the_size ) 400447e4: 80 a0 40 0d cmp %g1, %o5 <== NOT EXECUTED 400447e8: 08 80 00 03 bleu 400447f4 <_Heap_Get_free_information+0x4c> <== NOT EXECUTED 400447ec: c6 22 60 08 st %g3, [ %o1 + 8 ] <== NOT EXECUTED info->largest = the_size; 400447f0: c2 22 60 04 st %g1, [ %o1 + 4 ] <== NOT EXECUTED the_block = the_block->next) 400447f4: c4 00 a0 08 ld [ %g2 + 8 ], %g2 <== NOT EXECUTED for(the_block = _Heap_Free_list_first(the_heap); 400447f8: 80 a2 00 02 cmp %o0, %g2 <== NOT EXECUTED 400447fc: 12 bf ff f5 bne 400447d0 <_Heap_Get_free_information+0x28> <== NOT EXECUTED 40044800: 88 01 20 01 inc %g4 <== NOT EXECUTED } } 40044804: 81 c3 e0 08 retl <== NOT EXECUTED 40044808: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40058390 <_Heap_Get_information>: void _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 40058390: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED memset( the_info, 0, sizeof(*the_info) ); 40058394: 92 10 20 00 clr %o1 <== NOT EXECUTED 40058398: 94 10 20 58 mov 0x58, %o2 <== NOT EXECUTED 4005839c: 40 00 22 bd call 40060e90 <== NOT EXECUTED 400583a0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED _Heap_Protection_free_all_delayed_blocks( the_heap ); _Heap_Iterate( the_heap, _Heap_Get_information_visitor, the_info ); 400583a4: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 400583a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400583ac: 13 10 01 60 sethi %hi(0x40058000), %o1 <== NOT EXECUTED 400583b0: 40 00 00 08 call 400583d0 <_Heap_Iterate> <== NOT EXECUTED 400583b4: 92 12 63 54 or %o1, 0x354, %o1 ! 40058354 <_Heap_Get_information_visitor> <== NOT EXECUTED the_info->Stats = the_heap->stats; 400583b8: 94 10 20 40 mov 0x40, %o2 <== NOT EXECUTED 400583bc: 92 06 20 28 add %i0, 0x28, %o1 <== NOT EXECUTED 400583c0: 40 00 22 2a call 40060c68 <== NOT EXECUTED 400583c4: 90 06 60 18 add %i1, 0x18, %o0 <== NOT EXECUTED } 400583c8: 81 c7 e0 08 ret <== NOT EXECUTED 400583cc: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40006a04 <_Heap_Initialize>: { 40006a04: 9d e3 bf a0 save %sp, -96, %sp 40006a08: a2 86 40 1a addcc %i1, %i2, %l1 40006a0c: 84 40 20 00 addx %g0, 0, %g2 if ( page_size == 0 ) { 40006a10: 80 a6 e0 00 cmp %i3, 0 40006a14: 22 80 00 33 be,a 40006ae0 <_Heap_Initialize+0xdc> <== NEVER TAKEN 40006a18: b6 10 20 08 mov 8, %i3 <== NOT EXECUTED if ( remainder != 0 ) { 40006a1c: 82 8e e0 07 andcc %i3, 7, %g1 40006a20: 02 80 00 05 be 40006a34 <_Heap_Initialize+0x30> <== ALWAYS TAKEN 40006a24: 80 a6 e0 07 cmp %i3, 7 return value - remainder + alignment; 40006a28: b6 06 e0 08 add %i3, 8, %i3 <== NOT EXECUTED 40006a2c: b6 26 c0 01 sub %i3, %g1, %i3 <== NOT EXECUTED if ( page_size < CPU_ALIGNMENT ) { 40006a30: 80 a6 e0 07 cmp %i3, 7 <== NOT EXECUTED 40006a34: 08 80 00 29 bleu 40006ad8 <_Heap_Initialize+0xd4> <== NEVER TAKEN 40006a38: ba 10 20 00 clr %i5 uintptr_t remainder = value % alignment; 40006a3c: 82 10 20 10 mov 0x10, %g1 40006a40: 81 80 20 00 wr %g0, %y 40006a44: 01 00 00 00 nop 40006a48: 01 00 00 00 nop 40006a4c: 01 00 00 00 nop 40006a50: 86 70 40 1b udiv %g1, %i3, %g3 40006a54: 86 58 c0 1b smul %g3, %i3, %g3 if ( remainder != 0 ) { 40006a58: 82 a0 40 03 subcc %g1, %g3, %g1 40006a5c: 02 80 00 22 be 40006ae4 <_Heap_Initialize+0xe0> <== ALWAYS TAKEN 40006a60: a0 10 20 10 mov 0x10, %l0 _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 40006a64: b8 06 60 08 add %i1, 8, %i4 <== NOT EXECUTED return value - remainder + alignment; 40006a68: a0 06 e0 10 add %i3, 0x10, %l0 <== NOT EXECUTED 40006a6c: a0 24 00 01 sub %l0, %g1, %l0 <== NOT EXECUTED uintptr_t remainder = value % alignment; 40006a70: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 40006a74: 01 00 00 00 nop <== NOT EXECUTED 40006a78: 01 00 00 00 nop <== NOT EXECUTED 40006a7c: 01 00 00 00 nop <== NOT EXECUTED 40006a80: 82 77 00 1b udiv %i4, %i3, %g1 <== NOT EXECUTED 40006a84: 82 58 40 1b smul %g1, %i3, %g1 <== NOT EXECUTED if ( remainder != 0 ) { 40006a88: 82 a7 00 01 subcc %i4, %g1, %g1 <== NOT EXECUTED 40006a8c: 12 80 00 21 bne 40006b10 <_Heap_Initialize+0x10c> <== NOT EXECUTED 40006a90: b8 06 40 1b add %i1, %i3, %i4 <== NOT EXECUTED uintptr_t const heap_area_begin = (uintptr_t) heap_area_begin_ptr; 40006a94: b8 10 00 19 mov %i1, %i4 <== NOT EXECUTED 40006a98: 82 10 20 08 mov 8, %g1 || heap_area_size <= overhead 40006a9c: 80 a0 40 1a cmp %g1, %i2 _Heap_Align_down( heap_area_size - overhead, page_size ); 40006aa0: b4 26 80 01 sub %i2, %g1, %i2 || heap_area_size <= overhead 40006aa4: 82 60 3f ff subx %g0, -1, %g1 return value - (value % alignment); 40006aa8: 81 80 20 00 wr %g0, %y 40006aac: 01 00 00 00 nop 40006ab0: 01 00 00 00 nop 40006ab4: 01 00 00 00 nop 40006ab8: ba 76 80 1b udiv %i2, %i3, %i5 || first_block_size < min_block_size 40006abc: 80 90 80 01 orcc %g2, %g1, %g0 40006ac0: 12 80 00 05 bne 40006ad4 <_Heap_Initialize+0xd0> <== NEVER TAKEN 40006ac4: ba 5f 40 1b smul %i5, %i3, %i5 40006ac8: 80 a7 40 10 cmp %i5, %l0 40006acc: 1a 80 00 15 bcc 40006b20 <_Heap_Initialize+0x11c> <== ALWAYS TAKEN 40006ad0: 94 10 20 68 mov 0x68, %o2 return 0; 40006ad4: ba 10 20 00 clr %i5 <== NOT EXECUTED } 40006ad8: 81 c7 e0 08 ret <== NOT EXECUTED 40006adc: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED } else { return value; 40006ae0: a0 10 20 10 mov 0x10, %l0 <== NOT EXECUTED _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 40006ae4: b8 06 60 08 add %i1, 8, %i4 uintptr_t remainder = value % alignment; 40006ae8: 81 80 20 00 wr %g0, %y 40006aec: 01 00 00 00 nop 40006af0: 01 00 00 00 nop 40006af4: 01 00 00 00 nop 40006af8: 82 77 00 1b udiv %i4, %i3, %g1 40006afc: 82 58 40 1b smul %g1, %i3, %g1 if ( remainder != 0 ) { 40006b00: 82 a7 00 01 subcc %i4, %g1, %g1 40006b04: 22 bf ff e5 be,a 40006a98 <_Heap_Initialize+0x94> 40006b08: b8 10 00 19 mov %i1, %i4 40006b0c: b8 06 40 1b add %i1, %i3, %i4 40006b10: b8 27 00 01 sub %i4, %g1, %i4 40006b14: 82 27 00 19 sub %i4, %i1, %g1 40006b18: 10 bf ff e1 b 40006a9c <_Heap_Initialize+0x98> 40006b1c: 82 00 60 08 add %g1, 8, %g1 memset(heap, 0, sizeof(*heap)); 40006b20: 92 10 20 00 clr %o1 40006b24: 40 00 1e b3 call 4000e5f0 40006b28: 90 10 00 18 mov %i0, %o0 first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED; 40006b2c: 82 17 60 01 or %i5, 1, %g1 first_block->next = _Heap_Free_list_tail( heap ); 40006b30: f0 27 20 08 st %i0, [ %i4 + 8 ] return (Heap_Block *) ((uintptr_t) block + offset); 40006b34: 86 07 40 1c add %i5, %i4, %g3 first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED; 40006b38: c2 27 20 04 st %g1, [ %i4 + 4 ] _Heap_Block_set_size( 40006b3c: 82 20 00 1d neg %i5, %g1 first_block->prev = _Heap_Free_list_head( heap ); 40006b40: f0 27 20 0c st %i0, [ %i4 + 0xc ] stats->free_blocks = 1; 40006b44: 84 10 20 01 mov 1, %g2 first_block->prev_size = heap_area_end; 40006b48: e2 27 00 00 st %l1, [ %i4 ] heap->page_size = page_size; 40006b4c: f6 26 20 10 st %i3, [ %i0 + 0x10 ] heap->min_block_size = min_block_size; 40006b50: e0 26 20 14 st %l0, [ %i0 + 0x14 ] heap->area_begin = heap_area_begin; 40006b54: f2 26 20 18 st %i1, [ %i0 + 0x18 ] heap->area_end = heap_area_end; 40006b58: e2 26 20 1c st %l1, [ %i0 + 0x1c ] heap->first_block = first_block; 40006b5c: f8 26 20 20 st %i4, [ %i0 + 0x20 ] heap->last_block = last_block; 40006b60: c6 26 20 24 st %g3, [ %i0 + 0x24 ] _Heap_Free_list_head( heap )->next = first_block; 40006b64: f8 26 20 08 st %i4, [ %i0 + 8 ] _Heap_Free_list_tail( heap )->prev = first_block; 40006b68: f8 26 20 0c st %i4, [ %i0 + 0xc ] last_block->prev_size = first_block_size; 40006b6c: fa 27 40 1c st %i5, [ %i5 + %i4 ] block->size_and_flag = size | flag; 40006b70: c2 20 e0 04 st %g1, [ %g3 + 4 ] stats->size = first_block_size; 40006b74: fa 26 20 38 st %i5, [ %i0 + 0x38 ] stats->free_size = first_block_size; 40006b78: fa 26 20 3c st %i5, [ %i0 + 0x3c ] stats->min_free_size = first_block_size; 40006b7c: fa 26 20 40 st %i5, [ %i0 + 0x40 ] stats->free_blocks = 1; 40006b80: c4 26 20 44 st %g2, [ %i0 + 0x44 ] stats->max_free_blocks = 1; 40006b84: c4 26 20 48 st %g2, [ %i0 + 0x48 ] } 40006b88: 81 c7 e0 08 ret 40006b8c: 91 e8 00 1d restore %g0, %i5, %o0 =============================================================================== 400583d0 <_Heap_Iterate>: void _Heap_Iterate( Heap_Control *heap, Heap_Block_visitor visitor, void *visitor_arg ) { 400583d0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Heap_Block *current = heap->first_block; 400583d4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED Heap_Block *end = heap->last_block; 400583d8: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 <== NOT EXECUTED bool stop = false; while ( !stop && current != end ) { 400583dc: 80 a0 40 1c cmp %g1, %i4 <== NOT EXECUTED 400583e0: 32 80 00 07 bne,a 400583fc <_Heap_Iterate+0x2c> <== NOT EXECUTED 400583e4: d2 00 60 04 ld [ %g1 + 4 ], %o1 <== NOT EXECUTED 400583e8: 30 80 00 10 b,a 40058428 <_Heap_Iterate+0x58> <== NOT EXECUTED 400583ec: 80 a7 00 1d cmp %i4, %i5 <== NOT EXECUTED 400583f0: 02 80 00 0e be 40058428 <_Heap_Iterate+0x58> <== NOT EXECUTED 400583f4: 01 00 00 00 nop <== NOT EXECUTED 400583f8: d2 00 60 04 ld [ %g1 + 4 ], %o1 <== NOT EXECUTED 400583fc: 92 0a 7f fe and %o1, -2, %o1 <== NOT EXECUTED return (Heap_Block *) ((uintptr_t) block + offset); 40058400: ba 00 40 09 add %g1, %o1, %i5 <== NOT EXECUTED return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40058404: d4 07 60 04 ld [ %i5 + 4 ], %o2 <== NOT EXECUTED 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 ); 40058408: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED 4005840c: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 40058410: 9f c6 40 00 call %i1 <== NOT EXECUTED 40058414: 94 0a a0 01 and %o2, 1, %o2 <== NOT EXECUTED while ( !stop && current != end ) { 40058418: 90 1a 20 01 xor %o0, 1, %o0 <== NOT EXECUTED 4005841c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED 40058420: 12 bf ff f3 bne 400583ec <_Heap_Iterate+0x1c> <== NOT EXECUTED 40058424: 82 10 00 1d mov %i5, %g1 <== NOT EXECUTED current = next; } } 40058428: 81 c7 e0 08 ret <== NOT EXECUTED 4005842c: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000fa7c <_Heap_Resize_block>: void *alloc_begin_ptr, uintptr_t new_alloc_size, uintptr_t *old_size, uintptr_t *new_size ) { 4000fa7c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED return value - (value % alignment); 4000fa80: 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; 4000fa84: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED 4000fa88: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 4000fa8c: 01 00 00 00 nop <== NOT EXECUTED 4000fa90: 01 00 00 00 nop <== NOT EXECUTED 4000fa94: 01 00 00 00 nop <== NOT EXECUTED 4000fa98: 92 76 40 01 udiv %i1, %g1, %o1 <== NOT EXECUTED *new_size = 0; 4000fa9c: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED 4000faa0: 92 5a 40 01 smul %o1, %g1, %o1 <== NOT EXECUTED && (uintptr_t) block <= (uintptr_t) heap->last_block; 4000faa4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED { 4000faa8: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED - HEAP_BLOCK_HEADER_SIZE); 4000faac: 92 02 7f f8 add %o1, -8, %o1 <== NOT EXECUTED && (uintptr_t) block <= (uintptr_t) heap->last_block; 4000fab0: 80 a0 40 09 cmp %g1, %o1 <== NOT EXECUTED 4000fab4: 18 80 00 3a bgu 4000fb9c <_Heap_Resize_block+0x120> <== NOT EXECUTED 4000fab8: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED 4000fabc: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 <== NOT EXECUTED 4000fac0: 80 a0 40 09 cmp %g1, %o1 <== NOT EXECUTED 4000fac4: 0a 80 00 36 bcs 4000fb9c <_Heap_Resize_block+0x120> <== NOT EXECUTED 4000fac8: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000facc: c2 02 60 04 ld [ %o1 + 4 ], %g1 <== NOT EXECUTED 4000fad0: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED uintptr_t block_end = block_begin + block_size; 4000fad4: 86 02 40 01 add %o1, %g1, %g3 <== NOT EXECUTED 4000fad8: c4 00 e0 04 ld [ %g3 + 4 ], %g2 <== NOT EXECUTED 4000fadc: 84 08 bf fe and %g2, -2, %g2 <== NOT EXECUTED return block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000fae0: b0 00 c0 02 add %g3, %g2, %i0 <== NOT EXECUTED 4000fae4: a0 22 00 19 sub %o0, %i1, %l0 <== NOT EXECUTED 4000fae8: f0 06 20 04 ld [ %i0 + 4 ], %i0 <== NOT EXECUTED uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS; 4000faec: 88 00 c0 10 add %g3, %l0, %g4 <== NOT EXECUTED if ( next_block_is_free ) { 4000faf0: 80 8e 20 01 btst 1, %i0 <== NOT EXECUTED 4000faf4: 12 80 00 27 bne 4000fb90 <_Heap_Resize_block+0x114> <== NOT EXECUTED 4000faf8: c8 26 c0 00 st %g4, [ %i3 ] <== NOT EXECUTED alloc_size += next_block_size; 4000fafc: 88 01 00 02 add %g4, %g2, %g4 <== NOT EXECUTED if ( new_alloc_size > alloc_size ) { 4000fb00: 80 a6 80 04 cmp %i2, %g4 <== NOT EXECUTED 4000fb04: 18 80 00 26 bgu 4000fb9c <_Heap_Resize_block+0x120> <== NOT EXECUTED 4000fb08: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000fb0c: c8 02 60 04 ld [ %o1 + 4 ], %g4 <== NOT EXECUTED 4000fb10: f6 00 e0 08 ld [ %g3 + 8 ], %i3 <== NOT EXECUTED 4000fb14: f0 00 e0 0c ld [ %g3 + 0xc ], %i0 <== NOT EXECUTED block_size += next_block_size; 4000fb18: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED 4000fb1c: 86 09 20 01 and %g4, 1, %g3 <== NOT EXECUTED block->size_and_flag = size | flag; 4000fb20: 86 10 c0 01 or %g3, %g1, %g3 <== NOT EXECUTED 4000fb24: c6 22 60 04 st %g3, [ %o1 + 4 ] <== NOT EXECUTED return (Heap_Block *) ((uintptr_t) block + offset); 4000fb28: 82 02 40 01 add %o1, %g1, %g1 <== NOT EXECUTED prev->next = next; 4000fb2c: f6 26 20 08 st %i3, [ %i0 + 8 ] <== NOT EXECUTED next_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 4000fb30: c8 00 60 04 ld [ %g1 + 4 ], %g4 <== NOT EXECUTED next->prev = prev; 4000fb34: f0 26 e0 0c st %i0, [ %i3 + 0xc ] <== NOT EXECUTED 4000fb38: 88 11 20 01 or %g4, 1, %g4 <== NOT EXECUTED --stats->free_blocks; 4000fb3c: c6 07 60 44 ld [ %i5 + 0x44 ], %g3 <== NOT EXECUTED next_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 4000fb40: c8 20 60 04 st %g4, [ %g1 + 4 ] <== NOT EXECUTED --stats->free_blocks; 4000fb44: 86 00 ff ff add %g3, -1, %g3 <== NOT EXECUTED stats->free_size -= next_block_size; 4000fb48: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED 4000fb4c: 84 20 40 02 sub %g1, %g2, %g2 <== NOT EXECUTED --stats->free_blocks; 4000fb50: c6 27 60 44 st %g3, [ %i5 + 0x44 ] <== NOT EXECUTED stats->free_size -= next_block_size; 4000fb54: c4 27 60 3c st %g2, [ %i5 + 0x3c ] <== NOT EXECUTED block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size ); 4000fb58: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 4000fb5c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 4000fb60: 7f ff fe e4 call 4000f6f0 <_Heap_Block_allocate> <== NOT EXECUTED 4000fb64: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000fb68: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED ++stats->resizes; 4000fb6c: c4 07 60 64 ld [ %i5 + 0x64 ], %g2 <== NOT EXECUTED 4000fb70: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED *new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS; 4000fb74: 90 02 00 10 add %o0, %l0, %o0 <== NOT EXECUTED 4000fb78: 90 00 40 08 add %g1, %o0, %o0 <== NOT EXECUTED 4000fb7c: d0 27 00 00 st %o0, [ %i4 ] <== NOT EXECUTED ++stats->resizes; 4000fb80: 82 00 a0 01 add %g2, 1, %g1 <== NOT EXECUTED 4000fb84: c2 27 60 64 st %g1, [ %i5 + 0x64 ] <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; 4000fb88: 81 c7 e0 08 ret <== NOT EXECUTED 4000fb8c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED if ( new_alloc_size > alloc_size ) { 4000fb90: 80 a6 80 04 cmp %i2, %g4 <== NOT EXECUTED 4000fb94: 08 bf ff f1 bleu 4000fb58 <_Heap_Resize_block+0xdc> <== NOT EXECUTED 4000fb98: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED old_size, new_size ); } return HEAP_RESIZE_FATAL_ERROR; } 4000fb9c: 81 c7 e0 08 ret <== NOT EXECUTED 4000fba0: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4005849c <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 4005849c: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED 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; 400584a0: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 400584a4: 02 80 00 0b be 400584d0 <_Heap_Walk+0x34> <== NOT EXECUTED 400584a8: 03 10 02 3f sethi %hi(0x4008fc00), %g1 <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) { 400584ac: c2 00 62 68 ld [ %g1 + 0x268 ], %g1 ! 4008fe68 <_System_state_Current> <== NOT EXECUTED _Heap_Walk_print : _Heap_Walk_print_nothing; 400584b0: 21 10 01 61 sethi %hi(0x40058400), %l0 <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) { 400584b4: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 400584b8: 02 80 00 0b be 400584e4 <_Heap_Walk+0x48> <== NOT EXECUTED 400584bc: a0 14 20 38 or %l0, 0x38, %l0 <== NOT EXECUTED return true; 400584c0: b4 10 20 01 mov 1, %i2 <== NOT EXECUTED 400584c4: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED block = next_block; } while ( block != first_block ); return true; } 400584c8: 81 c7 e0 08 ret <== NOT EXECUTED 400584cc: 81 e8 00 00 restore <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) { 400584d0: c2 00 62 68 ld [ %g1 + 0x268 ], %g1 <== NOT EXECUTED _Heap_Walk_print : _Heap_Walk_print_nothing; 400584d4: 21 10 01 61 sethi %hi(0x40058400), %l0 <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) { 400584d8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 400584dc: 12 bf ff f9 bne 400584c0 <_Heap_Walk+0x24> <== NOT EXECUTED 400584e0: a0 14 20 30 or %l0, 0x30, %l0 <== NOT EXECUTED Heap_Block *const first_block = heap->first_block; 400584e4: e4 06 20 20 ld [ %i0 + 0x20 ], %l2 <== NOT EXECUTED Heap_Block *const last_block = heap->last_block; 400584e8: e2 06 20 24 ld [ %i0 + 0x24 ], %l1 <== NOT EXECUTED (*printer)( 400584ec: c6 06 20 0c ld [ %i0 + 0xc ], %g3 <== NOT EXECUTED 400584f0: c4 06 20 08 ld [ %i0 + 8 ], %g2 <== NOT EXECUTED 400584f4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED 400584f8: c2 23 a0 5c st %g1, [ %sp + 0x5c ] <== NOT EXECUTED 400584fc: 15 10 02 21 sethi %hi(0x40088400), %o2 <== NOT EXECUTED 40058500: c6 23 a0 6c st %g3, [ %sp + 0x6c ] <== NOT EXECUTED 40058504: 94 12 a2 38 or %o2, 0x238, %o2 <== NOT EXECUTED 40058508: c4 23 a0 68 st %g2, [ %sp + 0x68 ] <== NOT EXECUTED 4005850c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40058510: e2 23 a0 64 st %l1, [ %sp + 0x64 ] <== NOT EXECUTED 40058514: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 40058518: e4 23 a0 60 st %l2, [ %sp + 0x60 ] <== NOT EXECUTED uintptr_t const page_size = heap->page_size; 4005851c: ec 06 20 10 ld [ %i0 + 0x10 ], %l6 <== NOT EXECUTED uintptr_t const min_block_size = heap->min_block_size; 40058520: e6 06 20 14 ld [ %i0 + 0x14 ], %l3 <== NOT EXECUTED (*printer)( 40058524: da 06 20 18 ld [ %i0 + 0x18 ], %o5 <== NOT EXECUTED 40058528: 98 10 00 13 mov %l3, %o4 <== NOT EXECUTED 4005852c: 9f c4 00 00 call %l0 <== NOT EXECUTED 40058530: 96 10 00 16 mov %l6, %o3 <== NOT EXECUTED if ( page_size == 0 ) { 40058534: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 40058538: 12 80 00 0a bne 40058560 <_Heap_Walk+0xc4> <== NOT EXECUTED 4005853c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED (*printer)( source, true, "page size is zero\n" ); 40058540: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED return false; 40058544: b4 10 20 00 clr %i2 <== NOT EXECUTED (*printer)( source, true, "page size is zero\n" ); 40058548: 15 10 02 21 sethi %hi(0x40088400), %o2 <== NOT EXECUTED 4005854c: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 40058550: 9f c4 00 00 call %l0 <== NOT EXECUTED 40058554: 94 12 a2 d0 or %o2, 0x2d0, %o2 <== NOT EXECUTED } 40058558: 81 c7 e0 08 ret <== NOT EXECUTED 4005855c: 81 e8 00 00 restore <== NOT EXECUTED if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 40058560: 80 8d a0 07 btst 7, %l6 <== NOT EXECUTED 40058564: 02 80 00 0b be 40058590 <_Heap_Walk+0xf4> <== NOT EXECUTED 40058568: 96 10 00 16 mov %l6, %o3 <== NOT EXECUTED (*printer)( 4005856c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40058570: 15 10 02 21 sethi %hi(0x40088400), %o2 <== NOT EXECUTED 40058574: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 40058578: 94 12 a2 e8 or %o2, 0x2e8, %o2 <== NOT EXECUTED 4005857c: 9f c4 00 00 call %l0 <== NOT EXECUTED 40058580: b4 10 20 00 clr %i2 <== NOT EXECUTED 40058584: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 40058588: 81 c7 e0 08 ret <== NOT EXECUTED 4005858c: 81 e8 00 00 restore <== NOT EXECUTED return (value % alignment) == 0; 40058590: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 40058594: 01 00 00 00 nop <== NOT EXECUTED 40058598: 01 00 00 00 nop <== NOT EXECUTED 4005859c: 01 00 00 00 nop <== NOT EXECUTED 400585a0: 82 74 c0 16 udiv %l3, %l6, %g1 <== NOT EXECUTED 400585a4: 82 58 40 16 smul %g1, %l6, %g1 <== NOT EXECUTED if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 400585a8: 80 a4 c0 01 cmp %l3, %g1 <== NOT EXECUTED 400585ac: 02 80 00 0b be 400585d8 <_Heap_Walk+0x13c> <== NOT EXECUTED 400585b0: 96 10 00 13 mov %l3, %o3 <== NOT EXECUTED (*printer)( 400585b4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 400585b8: 15 10 02 21 sethi %hi(0x40088400), %o2 <== NOT EXECUTED 400585bc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 400585c0: 94 12 a3 08 or %o2, 0x308, %o2 <== NOT EXECUTED 400585c4: 9f c4 00 00 call %l0 <== NOT EXECUTED 400585c8: b4 10 20 00 clr %i2 <== NOT EXECUTED 400585cc: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 400585d0: 81 c7 e0 08 ret <== NOT EXECUTED 400585d4: 81 e8 00 00 restore <== NOT EXECUTED return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 400585d8: 86 04 a0 08 add %l2, 8, %g3 <== NOT EXECUTED return (value % alignment) == 0; 400585dc: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 400585e0: 01 00 00 00 nop <== NOT EXECUTED 400585e4: 01 00 00 00 nop <== NOT EXECUTED 400585e8: 01 00 00 00 nop <== NOT EXECUTED 400585ec: 82 70 c0 16 udiv %g3, %l6, %g1 <== NOT EXECUTED 400585f0: 82 58 40 16 smul %g1, %l6, %g1 <== NOT EXECUTED if ( 400585f4: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 400585f8: 02 80 00 0b be 40058624 <_Heap_Walk+0x188> <== NOT EXECUTED 400585fc: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED (*printer)( 40058600: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40058604: 15 10 02 21 sethi %hi(0x40088400), %o2 <== NOT EXECUTED 40058608: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4005860c: 94 12 a3 30 or %o2, 0x330, %o2 <== NOT EXECUTED 40058610: 9f c4 00 00 call %l0 <== NOT EXECUTED 40058614: b4 10 20 00 clr %i2 <== NOT EXECUTED 40058618: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 4005861c: 81 c7 e0 08 ret <== NOT EXECUTED 40058620: 81 e8 00 00 restore <== NOT EXECUTED return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40058624: c2 04 a0 04 ld [ %l2 + 4 ], %g1 <== NOT EXECUTED if ( !_Heap_Is_prev_used( first_block ) ) { 40058628: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 4005862c: 12 80 00 0a bne 40058654 <_Heap_Walk+0x1b8> <== NOT EXECUTED 40058630: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED (*printer)( 40058634: 15 10 02 21 sethi %hi(0x40088400), %o2 <== NOT EXECUTED 40058638: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4005863c: 94 12 a3 68 or %o2, 0x368, %o2 <== NOT EXECUTED 40058640: 9f c4 00 00 call %l0 <== NOT EXECUTED 40058644: b4 10 20 00 clr %i2 <== NOT EXECUTED 40058648: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 4005864c: 81 c7 e0 08 ret <== NOT EXECUTED 40058650: 81 e8 00 00 restore <== NOT EXECUTED return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40058654: c2 04 60 04 ld [ %l1 + 4 ], %g1 <== NOT EXECUTED 40058658: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED return (Heap_Block *) ((uintptr_t) block + offset); 4005865c: 82 04 40 01 add %l1, %g1, %g1 <== NOT EXECUTED return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40058660: c6 00 60 04 ld [ %g1 + 4 ], %g3 <== NOT EXECUTED if ( _Heap_Is_free( last_block ) ) { 40058664: 80 88 e0 01 btst 1, %g3 <== NOT EXECUTED 40058668: 12 80 00 09 bne 4005868c <_Heap_Walk+0x1f0> <== NOT EXECUTED 4005866c: 15 10 02 21 sethi %hi(0x40088400), %o2 <== NOT EXECUTED (*printer)( 40058670: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 40058674: 94 12 a3 98 or %o2, 0x398, %o2 <== NOT EXECUTED 40058678: 9f c4 00 00 call %l0 <== NOT EXECUTED 4005867c: b4 10 20 00 clr %i2 <== NOT EXECUTED 40058680: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 40058684: 81 c7 e0 08 ret <== NOT EXECUTED 40058688: 81 e8 00 00 restore <== NOT EXECUTED if ( 4005868c: 80 a4 80 01 cmp %l2, %g1 <== NOT EXECUTED 40058690: 02 80 00 0a be 400586b8 <_Heap_Walk+0x21c> <== NOT EXECUTED 40058694: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED (*printer)( 40058698: 15 10 02 21 sethi %hi(0x40088400), %o2 <== NOT EXECUTED 4005869c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 400586a0: 94 12 a3 b0 or %o2, 0x3b0, %o2 <== NOT EXECUTED 400586a4: 9f c4 00 00 call %l0 <== NOT EXECUTED 400586a8: b4 10 20 00 clr %i2 <== NOT EXECUTED 400586ac: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 400586b0: 81 c7 e0 08 ret <== NOT EXECUTED 400586b4: 81 e8 00 00 restore <== NOT EXECUTED uintptr_t const page_size = heap->page_size; 400586b8: fa 06 20 10 ld [ %i0 + 0x10 ], %i5 <== NOT EXECUTED return _Heap_Free_list_head(heap)->next; 400586bc: e8 06 20 08 ld [ %i0 + 8 ], %l4 <== NOT EXECUTED 400586c0: c6 06 20 20 ld [ %i0 + 0x20 ], %g3 <== NOT EXECUTED const Heap_Block *prev_block = free_list_tail; 400586c4: 88 10 00 18 mov %i0, %g4 <== NOT EXECUTED while ( free_block != free_list_tail ) { 400586c8: 80 a6 00 14 cmp %i0, %l4 <== NOT EXECUTED 400586cc: 02 80 00 1f be 40058748 <_Heap_Walk+0x2ac> <== NOT EXECUTED 400586d0: 80 a5 00 03 cmp %l4, %g3 <== NOT EXECUTED && (uintptr_t) block <= (uintptr_t) heap->last_block; 400586d4: 0a 80 00 f9 bcs 40058ab8 <_Heap_Walk+0x61c> <== NOT EXECUTED 400586d8: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED 400586dc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED 400586e0: 80 a0 40 14 cmp %g1, %l4 <== NOT EXECUTED 400586e4: 0a 80 00 f6 bcs 40058abc <_Heap_Walk+0x620> <== NOT EXECUTED 400586e8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 400586ec: b8 05 20 08 add %l4, 8, %i4 <== NOT EXECUTED return (value % alignment) == 0; 400586f0: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 400586f4: 01 00 00 00 nop <== NOT EXECUTED 400586f8: 01 00 00 00 nop <== NOT EXECUTED 400586fc: 01 00 00 00 nop <== NOT EXECUTED 40058700: 82 77 00 1d udiv %i4, %i5, %g1 <== NOT EXECUTED 40058704: 82 58 40 1d smul %g1, %i5, %g1 <== NOT EXECUTED if ( 40058708: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED 4005870c: 12 80 00 e4 bne 40058a9c <_Heap_Walk+0x600> <== NOT EXECUTED 40058710: 15 10 02 21 sethi %hi(0x40088400), %o2 <== NOT EXECUTED return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40058714: c2 05 20 04 ld [ %l4 + 4 ], %g1 <== NOT EXECUTED 40058718: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED return block->size_and_flag & HEAP_PREV_BLOCK_USED; 4005871c: 82 05 00 01 add %l4, %g1, %g1 <== NOT EXECUTED 40058720: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED if ( _Heap_Is_used( free_block ) ) { 40058724: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 40058728: 12 80 00 d6 bne 40058a80 <_Heap_Walk+0x5e4> <== NOT EXECUTED 4005872c: 15 10 02 22 sethi %hi(0x40088800), %o2 <== NOT EXECUTED if ( free_block->prev != prev_block ) { 40058730: d8 05 20 0c ld [ %l4 + 0xc ], %o4 <== NOT EXECUTED 40058734: 80 a3 00 04 cmp %o4, %g4 <== NOT EXECUTED 40058738: 12 80 00 c9 bne 40058a5c <_Heap_Walk+0x5c0> <== NOT EXECUTED 4005873c: 88 10 00 14 mov %l4, %g4 <== NOT EXECUTED free_block = free_block->next; 40058740: 10 bf ff e2 b 400586c8 <_Heap_Walk+0x22c> <== NOT EXECUTED 40058744: e8 05 20 08 ld [ %l4 + 8 ], %l4 <== NOT EXECUTED (*printer)( 40058748: 2f 10 02 21 sethi %hi(0x40088400), %l7 <== NOT EXECUTED 4005874c: 82 15 e2 18 or %l7, 0x218, %g1 ! 40088618 <== NOT EXECUTED 40058750: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED : (block->next == free_list_tail ? " (= tail)" : "") 40058754: 03 10 02 21 sethi %hi(0x40088400), %g1 <== NOT EXECUTED 40058758: 82 10 62 28 or %g1, 0x228, %g1 ! 40088628 <== NOT EXECUTED 4005875c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED (*printer)( 40058760: 03 10 02 21 sethi %hi(0x40088400), %g1 <== NOT EXECUTED 40058764: 82 10 61 f8 or %g1, 0x1f8, %g1 ! 400885f8 <== NOT EXECUTED 40058768: c2 27 bf f8 st %g1, [ %fp + -8 ] <== NOT EXECUTED : (block->prev == free_list_head ? " (= head)" : ""), 4005876c: 03 10 02 21 sethi %hi(0x40088400), %g1 <== NOT EXECUTED 40058770: 82 10 62 08 or %g1, 0x208, %g1 ! 40088608 <== NOT EXECUTED 40058774: c2 27 bf f0 st %g1, [ %fp + -16 ] <== NOT EXECUTED : (block->next == free_list_tail ? " (= tail)" : "") 40058778: 2b 10 01 fa sethi %hi(0x4007e800), %l5 <== NOT EXECUTED while ( free_block != free_list_tail ) { 4005877c: ba 10 00 12 mov %l2, %i5 <== NOT EXECUTED : (block->next == free_list_tail ? " (= tail)" : "") 40058780: aa 15 61 38 or %l5, 0x138, %l5 <== NOT EXECUTED 40058784: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40058788: b6 08 7f fe and %g1, -2, %i3 <== NOT EXECUTED return (Heap_Block *) ((uintptr_t) block + offset); 4005878c: b8 07 40 1b add %i5, %i3, %i4 <== NOT EXECUTED && (uintptr_t) block <= (uintptr_t) heap->last_block; 40058790: 80 a0 c0 1c cmp %g3, %i4 <== NOT EXECUTED 40058794: 18 80 00 06 bgu 400587ac <_Heap_Walk+0x310> <== NOT EXECUTED 40058798: ae 08 60 01 and %g1, 1, %l7 <== NOT EXECUTED 4005879c: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 <== NOT EXECUTED 400587a0: 80 a0 c0 1c cmp %g3, %i4 <== NOT EXECUTED 400587a4: 1a 80 00 0d bcc 400587d8 <_Heap_Walk+0x33c> <== NOT EXECUTED 400587a8: 01 00 00 00 nop <== NOT EXECUTED (*printer)( 400587ac: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED 400587b0: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED 400587b4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 400587b8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED return false; 400587bc: b4 10 20 00 clr %i2 <== NOT EXECUTED (*printer)( 400587c0: 15 10 02 22 sethi %hi(0x40088800), %o2 <== NOT EXECUTED 400587c4: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 400587c8: 9f c4 00 00 call %l0 <== NOT EXECUTED 400587cc: 94 12 a2 08 or %o2, 0x208, %o2 <== NOT EXECUTED } 400587d0: 81 c7 e0 08 ret <== NOT EXECUTED 400587d4: 81 e8 00 00 restore <== NOT EXECUTED return (value % alignment) == 0; 400587d8: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 400587dc: 01 00 00 00 nop <== NOT EXECUTED 400587e0: 01 00 00 00 nop <== NOT EXECUTED 400587e4: 01 00 00 00 nop <== NOT EXECUTED 400587e8: 86 76 c0 16 udiv %i3, %l6, %g3 <== NOT EXECUTED 400587ec: 86 58 c0 16 smul %g3, %l6, %g3 <== NOT EXECUTED if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 400587f0: 80 a6 c0 03 cmp %i3, %g3 <== NOT EXECUTED 400587f4: 02 80 00 17 be 40058850 <_Heap_Walk+0x3b4> <== NOT EXECUTED 400587f8: 86 1f 40 11 xor %i5, %l1, %g3 <== NOT EXECUTED 400587fc: 80 a7 40 11 cmp %i5, %l1 <== NOT EXECUTED 40058800: 12 80 00 79 bne 400589e4 <_Heap_Walk+0x548> <== NOT EXECUTED 40058804: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40058808: c6 07 20 04 ld [ %i4 + 4 ], %g3 <== NOT EXECUTED if ( !_Heap_Is_prev_used( next_block ) ) { 4005880c: 80 88 e0 01 btst 1, %g3 <== NOT EXECUTED 40058810: 02 80 00 30 be 400588d0 <_Heap_Walk+0x434> <== NOT EXECUTED 40058814: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED } else if (prev_used) { 40058818: 22 80 00 25 be,a 400588ac <_Heap_Walk+0x410> <== NOT EXECUTED 4005881c: da 07 40 00 ld [ %i5 ], %o5 <== NOT EXECUTED (*printer)( 40058820: 15 10 02 22 sethi %hi(0x40088800), %o2 <== NOT EXECUTED 40058824: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED 40058828: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED 4005882c: 94 12 a1 a8 or %o2, 0x1a8, %o2 <== NOT EXECUTED 40058830: 92 10 20 00 clr %o1 <== NOT EXECUTED 40058834: 9f c4 00 00 call %l0 <== NOT EXECUTED 40058838: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED } while ( block != first_block ); 4005883c: 80 a4 80 1c cmp %l2, %i4 <== NOT EXECUTED 40058840: 02 bf ff 20 be 400584c0 <_Heap_Walk+0x24> <== NOT EXECUTED 40058844: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED 40058848: 10 bf ff cf b 40058784 <_Heap_Walk+0x2e8> <== NOT EXECUTED 4005884c: c6 06 20 20 ld [ %i0 + 0x20 ], %g3 <== NOT EXECUTED bool const is_not_last_block = block != last_block; 40058850: 80 a0 00 03 cmp %g0, %g3 <== NOT EXECUTED 40058854: 88 40 20 00 addx %g0, 0, %g4 <== NOT EXECUTED if ( block_size < min_block_size && is_not_last_block ) { 40058858: 80 a6 c0 13 cmp %i3, %l3 <== NOT EXECUTED 4005885c: 86 40 20 00 addx %g0, 0, %g3 <== NOT EXECUTED 40058860: 86 09 00 03 and %g4, %g3, %g3 <== NOT EXECUTED 40058864: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40058868: 12 80 00 53 bne 400589b4 <_Heap_Walk+0x518> <== NOT EXECUTED 4005886c: b4 10 00 03 mov %g3, %i2 <== NOT EXECUTED if ( next_block_begin <= block_begin && is_not_last_block ) { 40058870: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED 40058874: 0a bf ff e5 bcs 40058808 <_Heap_Walk+0x36c> <== NOT EXECUTED 40058878: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED 4005887c: 22 bf ff e4 be,a 4005880c <_Heap_Walk+0x370> <== NOT EXECUTED 40058880: c6 07 20 04 ld [ %i4 + 4 ], %g3 <== NOT EXECUTED (*printer)( 40058884: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED 40058888: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED 4005888c: 15 10 02 22 sethi %hi(0x40088800), %o2 <== NOT EXECUTED 40058890: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40058894: 94 12 a0 c8 or %o2, 0xc8, %o2 <== NOT EXECUTED 40058898: 9f c4 00 00 call %l0 <== NOT EXECUTED 4005889c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 400588a0: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 400588a4: 81 c7 e0 08 ret <== NOT EXECUTED 400588a8: 81 e8 00 00 restore <== NOT EXECUTED (*printer)( 400588ac: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED 400588b0: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED 400588b4: 15 10 02 22 sethi %hi(0x40088800), %o2 <== NOT EXECUTED 400588b8: 92 10 20 00 clr %o1 <== NOT EXECUTED 400588bc: 94 12 a1 c0 or %o2, 0x1c0, %o2 <== NOT EXECUTED 400588c0: 9f c4 00 00 call %l0 <== NOT EXECUTED 400588c4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED } while ( block != first_block ); 400588c8: 10 bf ff de b 40058840 <_Heap_Walk+0x3a4> <== NOT EXECUTED 400588cc: 80 a4 80 1c cmp %l2, %i4 <== NOT EXECUTED (*printer)( 400588d0: da 07 60 0c ld [ %i5 + 0xc ], %o5 <== NOT EXECUTED 400588d4: c6 06 20 08 ld [ %i0 + 8 ], %g3 <== NOT EXECUTED return _Heap_Free_list_tail(heap)->prev; 400588d8: de 06 20 0c ld [ %i0 + 0xc ], %o7 <== NOT EXECUTED 400588dc: 80 a0 c0 0d cmp %g3, %o5 <== NOT EXECUTED 400588e0: 02 80 00 05 be 400588f4 <_Heap_Walk+0x458> <== NOT EXECUTED 400588e4: c8 07 bf f8 ld [ %fp + -8 ], %g4 <== NOT EXECUTED : (block->prev == free_list_head ? " (= head)" : ""), 400588e8: 80 a5 00 0d cmp %l4, %o5 <== NOT EXECUTED 400588ec: 02 80 00 22 be 40058974 <_Heap_Walk+0x4d8> <== NOT EXECUTED 400588f0: 88 10 00 15 mov %l5, %g4 <== NOT EXECUTED (*printer)( 400588f4: c6 07 60 08 ld [ %i5 + 8 ], %g3 <== NOT EXECUTED 400588f8: 80 a3 c0 03 cmp %o7, %g3 <== NOT EXECUTED 400588fc: 02 80 00 05 be 40058910 <_Heap_Walk+0x474> <== NOT EXECUTED 40058900: f4 07 bf fc ld [ %fp + -4 ], %i2 <== NOT EXECUTED : (block->next == free_list_tail ? " (= tail)" : "") 40058904: 80 a5 00 03 cmp %l4, %g3 <== NOT EXECUTED 40058908: 02 80 00 1d be 4005897c <_Heap_Walk+0x4e0> <== NOT EXECUTED 4005890c: b4 10 00 15 mov %l5, %i2 <== NOT EXECUTED (*printer)( 40058910: f4 23 a0 64 st %i2, [ %sp + 0x64 ] <== NOT EXECUTED 40058914: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED 40058918: c6 23 a0 60 st %g3, [ %sp + 0x60 ] <== NOT EXECUTED 4005891c: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED 40058920: c8 23 a0 5c st %g4, [ %sp + 0x5c ] <== NOT EXECUTED 40058924: 92 10 20 00 clr %o1 <== NOT EXECUTED 40058928: 15 10 02 22 sethi %hi(0x40088800), %o2 <== NOT EXECUTED 4005892c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 40058930: 9f c4 00 00 call %l0 <== NOT EXECUTED 40058934: 94 12 a1 00 or %o2, 0x100, %o2 <== NOT EXECUTED if ( block_size != next_block->prev_size ) { 40058938: da 07 00 00 ld [ %i4 ], %o5 <== NOT EXECUTED 4005893c: 80 a6 c0 0d cmp %i3, %o5 <== NOT EXECUTED 40058940: 02 80 00 11 be 40058984 <_Heap_Walk+0x4e8> <== NOT EXECUTED 40058944: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED (*printer)( 40058948: f8 23 a0 5c st %i4, [ %sp + 0x5c ] <== NOT EXECUTED 4005894c: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED 40058950: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40058954: 15 10 02 22 sethi %hi(0x40088800), %o2 <== NOT EXECUTED 40058958: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4005895c: 94 12 a1 38 or %o2, 0x138, %o2 <== NOT EXECUTED 40058960: 9f c4 00 00 call %l0 <== NOT EXECUTED 40058964: b4 10 20 00 clr %i2 <== NOT EXECUTED 40058968: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 4005896c: 81 c7 e0 08 ret <== NOT EXECUTED 40058970: 81 e8 00 00 restore <== NOT EXECUTED : (block->prev == free_list_head ? " (= head)" : ""), 40058974: 10 bf ff e0 b 400588f4 <_Heap_Walk+0x458> <== NOT EXECUTED 40058978: c8 07 bf f0 ld [ %fp + -16 ], %g4 <== NOT EXECUTED : (block->next == free_list_tail ? " (= tail)" : "") 4005897c: 10 bf ff e5 b 40058910 <_Heap_Walk+0x474> <== NOT EXECUTED 40058980: f4 07 bf f4 ld [ %fp + -12 ], %i2 <== NOT EXECUTED if ( !prev_used ) { 40058984: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED 40058988: 12 80 00 21 bne 40058a0c <_Heap_Walk+0x570> <== NOT EXECUTED 4005898c: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED (*printer)( 40058990: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40058994: 15 10 02 22 sethi %hi(0x40088800), %o2 <== NOT EXECUTED 40058998: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4005899c: 94 12 a1 78 or %o2, 0x178, %o2 <== NOT EXECUTED 400589a0: 9f c4 00 00 call %l0 <== NOT EXECUTED 400589a4: b4 10 20 00 clr %i2 <== NOT EXECUTED 400589a8: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 400589ac: 81 c7 e0 08 ret <== NOT EXECUTED 400589b0: 81 e8 00 00 restore <== NOT EXECUTED (*printer)( 400589b4: 9a 10 00 13 mov %l3, %o5 <== NOT EXECUTED 400589b8: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED 400589bc: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED 400589c0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 400589c4: 15 10 02 22 sethi %hi(0x40088800), %o2 <== NOT EXECUTED 400589c8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 400589cc: 94 12 a0 98 or %o2, 0x98, %o2 <== NOT EXECUTED 400589d0: 9f c4 00 00 call %l0 <== NOT EXECUTED 400589d4: b4 10 20 00 clr %i2 <== NOT EXECUTED 400589d8: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 400589dc: 81 c7 e0 08 ret <== NOT EXECUTED 400589e0: 81 e8 00 00 restore <== NOT EXECUTED (*printer)( 400589e4: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED 400589e8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 400589ec: 15 10 02 22 sethi %hi(0x40088800), %o2 <== NOT EXECUTED 400589f0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 400589f4: 94 12 a0 68 or %o2, 0x68, %o2 <== NOT EXECUTED 400589f8: 9f c4 00 00 call %l0 <== NOT EXECUTED 400589fc: b4 10 20 00 clr %i2 <== NOT EXECUTED 40058a00: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 40058a04: 81 c7 e0 08 ret <== NOT EXECUTED 40058a08: 81 e8 00 00 restore <== NOT EXECUTED return _Heap_Free_list_head(heap)->next; 40058a0c: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED while ( free_block != free_list_tail ) { 40058a10: 80 a5 00 01 cmp %l4, %g1 <== NOT EXECUTED 40058a14: 02 80 00 09 be 40058a38 <_Heap_Walk+0x59c> <== NOT EXECUTED 40058a18: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED if ( free_block == block ) { 40058a1c: 02 bf ff 89 be 40058840 <_Heap_Walk+0x3a4> <== NOT EXECUTED 40058a20: 80 a4 80 1c cmp %l2, %i4 <== NOT EXECUTED free_block = free_block->next; 40058a24: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED while ( free_block != free_list_tail ) { 40058a28: 80 a5 00 01 cmp %l4, %g1 <== NOT EXECUTED 40058a2c: 12 bf ff fc bne 40058a1c <_Heap_Walk+0x580> <== NOT EXECUTED 40058a30: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED (*printer)( 40058a34: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED 40058a38: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40058a3c: 15 10 02 22 sethi %hi(0x40088800), %o2 <== NOT EXECUTED 40058a40: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 40058a44: 94 12 a2 38 or %o2, 0x238, %o2 <== NOT EXECUTED 40058a48: 9f c4 00 00 call %l0 <== NOT EXECUTED 40058a4c: b4 10 20 00 clr %i2 <== NOT EXECUTED 40058a50: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 40058a54: 81 c7 e0 08 ret <== NOT EXECUTED 40058a58: 81 e8 00 00 restore <== NOT EXECUTED (*printer)( 40058a5c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40058a60: 15 10 02 22 sethi %hi(0x40088800), %o2 <== NOT EXECUTED 40058a64: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 40058a68: 94 12 a0 30 or %o2, 0x30, %o2 <== NOT EXECUTED 40058a6c: 9f c4 00 00 call %l0 <== NOT EXECUTED 40058a70: b4 10 20 00 clr %i2 <== NOT EXECUTED 40058a74: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 40058a78: 81 c7 e0 08 ret <== NOT EXECUTED 40058a7c: 81 e8 00 00 restore <== NOT EXECUTED (*printer)( 40058a80: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 40058a84: 94 12 a0 10 or %o2, 0x10, %o2 <== NOT EXECUTED 40058a88: 9f c4 00 00 call %l0 <== NOT EXECUTED 40058a8c: b4 10 20 00 clr %i2 <== NOT EXECUTED 40058a90: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 40058a94: 81 c7 e0 08 ret <== NOT EXECUTED 40058a98: 81 e8 00 00 restore <== NOT EXECUTED (*printer)( 40058a9c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 40058aa0: 94 12 a3 e0 or %o2, 0x3e0, %o2 <== NOT EXECUTED 40058aa4: 9f c4 00 00 call %l0 <== NOT EXECUTED 40058aa8: b4 10 20 00 clr %i2 <== NOT EXECUTED 40058aac: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 40058ab0: 81 c7 e0 08 ret <== NOT EXECUTED 40058ab4: 81 e8 00 00 restore <== NOT EXECUTED (*printer)( 40058ab8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40058abc: 15 10 02 22 sethi %hi(0x40088800), %o2 <== NOT EXECUTED 40058ac0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 40058ac4: 94 12 a1 e8 or %o2, 0x1e8, %o2 <== NOT EXECUTED 40058ac8: 9f c4 00 00 call %l0 <== NOT EXECUTED 40058acc: b4 10 20 00 clr %i2 <== NOT EXECUTED 40058ad0: b0 0e a0 ff and %i2, 0xff, %i0 <== NOT EXECUTED 40058ad4: 81 c7 e0 08 ret <== NOT EXECUTED 40058ad8: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 400070dc <_IO_Vprintf>: return (p); } int _IO_Vprintf(IO_Put_char put_char, void *arg, char const *fmt, va_list ap) { 400070dc: 9d e3 bf 50 save %sp, -176, %sp char padc; int stop = 0, retval = 0; num = 0; if (fmt == NULL) 400070e0: 80 a6 a0 00 cmp %i2, 0 400070e4: 02 80 00 3e be 400071dc <_IO_Vprintf+0x100> <== NEVER TAKEN 400070e8: 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++) { 400070ec: 31 10 00 1b sethi %hi(0x40006c00), %i0 400070f0: 03 10 00 42 sethi %hi(0x40010800), %g1 400070f4: a8 10 20 00 clr %l4 400070f8: a4 10 20 00 clr %l2 400070fc: b0 16 23 7c or %i0, 0x37c, %i0 40007100: ae 10 60 0f or %g1, 0xf, %l7 while ((ch = (u_char)*fmt++) != '%' || stop) { 40007104: c2 0e 80 00 ldub [ %i2 ], %g1 40007108: a4 0c a0 01 and %l2, 1, %l2 4000710c: ba 06 a0 01 add %i2, 1, %i5 40007110: 90 10 00 01 mov %g1, %o0 40007114: 80 a0 60 25 cmp %g1, 0x25 40007118: 12 80 00 05 bne 4000712c <_IO_Vprintf+0x50> 4000711c: a0 10 00 12 mov %l2, %l0 40007120: 80 a4 a0 00 cmp %l2, 0 40007124: 22 80 00 16 be,a 4000717c <_IO_Vprintf+0xa0> <== ALWAYS TAKEN 40007128: 82 10 00 1d mov %i5, %g1 if (ch == '\0') 4000712c: 80 a0 60 00 cmp %g1, 0 40007130: 02 80 00 32 be 400071f8 <_IO_Vprintf+0x11c> 40007134: b4 25 00 1a sub %l4, %i2, %i2 while ((ch = (u_char)*fmt++) != '%' || stop) { 40007138: a0 0c 20 ff and %l0, 0xff, %l0 PCHAR(ch); 4000713c: 9f c7 00 00 call %i4 40007140: 92 10 00 19 mov %i1, %o1 while ((ch = (u_char)*fmt++) != '%' || stop) { 40007144: 82 07 60 01 add %i5, 1, %g1 40007148: d0 08 7f ff ldub [ %g1 + -1 ], %o0 4000714c: 80 a2 20 25 cmp %o0, 0x25 40007150: 12 80 00 05 bne 40007164 <_IO_Vprintf+0x88> 40007154: aa 07 40 1a add %i5, %i2, %l5 40007158: 80 a4 20 00 cmp %l0, 0 4000715c: 02 80 00 0b be 40007188 <_IO_Vprintf+0xac> <== ALWAYS TAKEN 40007160: 84 10 20 20 mov 0x20, %g2 if (ch == '\0') 40007164: 80 a2 20 00 cmp %o0, 0 40007168: 12 bf ff f5 bne 4000713c <_IO_Vprintf+0x60> 4000716c: ba 10 00 01 mov %g1, %i5 40007170: ac 10 00 15 mov %l5, %l6 stop = 1; break; } } #undef PCHAR } 40007174: 81 c7 e0 08 ret 40007178: 91 e8 00 16 restore %g0, %l6, %o0 while ((ch = (u_char)*fmt++) != '%' || stop) { 4000717c: aa 10 00 14 mov %l4, %l5 40007180: ba 10 00 1a mov %i2, %i5 padc = ' '; 40007184: 84 10 20 20 mov 0x20, %g2 sign = 0; dot = 0; dwidth = 0; upper = 0; 40007188: c0 27 bf d0 clr [ %fp + -48 ] cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0; 4000718c: a8 10 20 00 clr %l4 padc = ' '; 40007190: c4 2f bf c3 stb %g2, [ %fp + -61 ] cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0; 40007194: 9e 10 20 00 clr %o7 lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 40007198: c0 27 bf c4 clr [ %fp + -60 ] cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0; 4000719c: 9a 10 20 00 clr %o5 width = 0; 400071a0: c0 27 bf d4 clr [ %fp + -44 ] sign = 0; dot = 0; dwidth = 0; upper = 0; 400071a4: 96 10 20 00 clr %o3 400071a8: d8 08 40 00 ldub [ %g1 ], %o4 lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 400071ac: a4 10 20 00 clr %l2 cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0; 400071b0: 88 10 20 00 clr %g4 reswitch: switch (ch = (u_char)*fmt++) { 400071b4: 84 03 3f dd add %o4, -35, %g2 400071b8: b4 00 60 01 add %g1, 1, %i2 400071bc: 84 08 a0 ff and %g2, 0xff, %g2 400071c0: 80 a0 a0 57 cmp %g2, 0x57 400071c4: 18 80 01 d9 bgu 40007928 <_IO_Vprintf+0x84c> <== NEVER TAKEN 400071c8: 90 0b 20 ff and %o4, 0xff, %o0 400071cc: 85 28 a0 02 sll %g2, 2, %g2 400071d0: c4 06 00 02 ld [ %i0 + %g2 ], %g2 400071d4: 81 c0 80 00 jmp %g2 400071d8: 01 00 00 00 nop fmt = "(fmt null)\n"; 400071dc: 35 10 00 41 sethi %hi(0x40010400), %i2 <== NOT EXECUTED 400071e0: 10 bf ff c3 b 400070ec <_IO_Vprintf+0x10> <== NOT EXECUTED 400071e4: b4 16 a3 f8 or %i2, 0x3f8, %i2 ! 400107f8 <_Objects_Information_table+0x24> <== NOT EXECUTED 400071e8: d8 08 60 01 ldub [ %g1 + 1 ], %o4 <== NOT EXECUTED zflag = 1; 400071ec: 88 10 20 01 mov 1, %g4 goto reswitch; 400071f0: 10 bf ff f1 b 400071b4 <_IO_Vprintf+0xd8> 400071f4: 82 10 00 1a mov %i2, %g1 return (retval); 400071f8: 10 bf ff df b 40007174 <_IO_Vprintf+0x98> 400071fc: ac 10 00 14 mov %l4, %l6 if (!dot) { 40007200: 80 a2 e0 00 cmp %o3, 0 40007204: 32 80 02 5b bne,a 40007b70 <_IO_Vprintf+0xa94> <== NEVER TAKEN 40007208: c6 48 60 01 ldsb [ %g1 + 1 ], %g3 <== NOT EXECUTED padc = '0'; 4000720c: d8 2f bf c3 stb %o4, [ %fp + -61 ] if (!dot) { 40007210: d8 08 60 01 ldub [ %g1 + 1 ], %o4 reswitch: switch (ch = (u_char)*fmt++) { 40007214: 10 bf ff e8 b 400071b4 <_IO_Vprintf+0xd8> 40007218: 82 10 00 1a mov %i2, %g1 4000721c: 84 10 20 00 clr %g2 40007220: 86 10 20 10 mov 0x10, %g3 base = 16; 40007224: 82 10 20 10 mov 0x10, %g1 reswitch: switch (ch = (u_char)*fmt++) { 40007228: c4 3f bf b0 std %g2, [ %fp + -80 ] sign = 0; dot = 0; dwidth = 0; upper = 0; 4000722c: ba 10 20 00 clr %i5 base = 16; 40007230: c2 27 bf bc st %g1, [ %fp + -68 ] if (jflag) 40007234: 80 a5 20 00 cmp %l4, 0 40007238: 02 80 01 dc be 400079a8 <_IO_Vprintf+0x8cc> <== ALWAYS TAKEN 4000723c: 80 a1 20 00 cmp %g4, 0 num = va_arg(ap, uintmax_t); 40007240: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 40007244: 94 10 20 08 mov 8, %o2 <== NOT EXECUTED 40007248: 40 00 1c ae call 4000e500 <== NOT EXECUTED 4000724c: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED 40007250: c4 1f bf d8 ldd [ %fp + -40 ], %g2 <== NOT EXECUTED 40007254: c4 3f bf c8 std %g2, [ %fp + -56 ] <== NOT EXECUTED 40007258: b6 06 e0 08 add %i3, 8, %i3 <== NOT EXECUTED lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 4000725c: a8 10 20 00 clr %l4 <== NOT EXECUTED 40007260: bb 2f 60 04 sll %i5, 4, %i5 *p = '\0'; 40007264: c0 2f bf e8 clrb [ %fp + -24 ] *++p = hex2ascii_data[upper][num % base]; 40007268: a2 05 c0 1d add %l7, %i5, %l1 4000726c: f4 27 a0 4c st %i2, [ %fp + 0x4c ] 40007270: ac 10 00 1c mov %i4, %l6 *p = '\0'; 40007274: c4 1f bf c8 ldd [ %fp + -56 ], %g2 *++p = hex2ascii_data[upper][num % base]; 40007278: f8 1f bf b0 ldd [ %fp + -80 ], %i4 4000727c: f6 27 a0 50 st %i3, [ %fp + 0x50 ] *p = '\0'; 40007280: a6 10 00 02 mov %g2, %l3 p = nbuf; 40007284: a0 07 bf e8 add %fp, -24, %l0 *++p = hex2ascii_data[upper][num % base]; 40007288: b6 10 00 03 mov %g3, %i3 4000728c: 94 10 00 1c mov %i4, %o2 40007290: 96 10 00 1d mov %i5, %o3 40007294: 90 10 00 13 mov %l3, %o0 40007298: 40 00 20 64 call 4000f428 <__umoddi3> 4000729c: 92 10 00 1b mov %i3, %o1 400072a0: f4 0c 40 09 ldub [ %l1 + %o1 ], %i2 400072a4: a0 04 20 01 inc %l0 400072a8: f4 2c 00 00 stb %i2, [ %l0 ] } while (num /= base); 400072ac: 90 10 00 13 mov %l3, %o0 400072b0: 92 10 00 1b mov %i3, %o1 400072b4: 94 10 00 1c mov %i4, %o2 400072b8: 40 00 1f e3 call 4000f244 <__udivdi3> 400072bc: 96 10 00 1d mov %i5, %o3 400072c0: a6 10 00 08 mov %o0, %l3 400072c4: 80 92 40 13 orcc %o1, %l3, %g0 400072c8: 12 bf ff f1 bne 4000728c <_IO_Vprintf+0x1b0> 400072cc: b6 10 00 09 mov %o1, %i3 if (sharpflag && num != 0) { 400072d0: c4 1f bf c8 ldd [ %fp + -56 ], %g2 400072d4: 82 10 00 02 mov %g2, %g1 400072d8: c4 07 bf c4 ld [ %fp + -60 ], %g2 400072dc: 82 10 40 03 or %g1, %g3, %g1 400072e0: 80 a0 00 01 cmp %g0, %g1 400072e4: 86 40 20 00 addx %g0, 0, %g3 400072e8: 84 88 c0 02 andcc %g3, %g2, %g2 400072ec: c4 27 bf c4 st %g2, [ %fp + -60 ] *lenp = p - nbuf; 400072f0: 82 07 bf e8 add %fp, -24, %g1 400072f4: ba 10 00 1a mov %i2, %i5 400072f8: a2 24 00 01 sub %l0, %g1, %l1 400072fc: b8 10 00 16 mov %l6, %i4 40007300: f4 07 a0 4c ld [ %fp + 0x4c ], %i2 40007304: f6 07 a0 50 ld [ %fp + 0x50 ], %i3 if (sharpflag && num != 0) { 40007308: 02 80 00 0a be 40007330 <_IO_Vprintf+0x254> 4000730c: 82 10 20 00 clr %g1 if (base == 8) 40007310: c4 07 bf bc ld [ %fp + -68 ], %g2 40007314: 80 a0 a0 08 cmp %g2, 8 40007318: 02 80 00 06 be 40007330 <_IO_Vprintf+0x254> <== NEVER TAKEN 4000731c: 82 10 20 01 mov 1, %g1 tmp = 0; 40007320: 82 18 a0 10 xor %g2, 0x10, %g1 40007324: 80 a0 00 01 cmp %g0, %g1 40007328: 82 60 3f ff subx %g0, -1, %g1 4000732c: 83 28 60 01 sll %g1, 1, %g1 tmp++; 40007330: 80 a0 00 14 cmp %g0, %l4 40007334: 82 40 00 01 addx %g0, %g1, %g1 if (!ladjust && padc == '0') 40007338: 80 8c a0 01 btst 1, %l2 4000733c: 12 80 01 8d bne 40007970 <_IO_Vprintf+0x894> <== NEVER TAKEN 40007340: c4 0f bf c3 ldub [ %fp + -61 ], %g2 40007344: 87 28 a0 18 sll %g2, 0x18, %g3 40007348: 87 38 e0 18 sra %g3, 0x18, %g3 4000734c: 80 a0 e0 30 cmp %g3, 0x30 40007350: 12 80 01 88 bne 40007970 <_IO_Vprintf+0x894> 40007354: c4 07 bf d4 ld [ %fp + -44 ], %g2 dwidth = width - tmp; 40007358: ac 20 80 01 sub %g2, %g1, %l6 static inline int imax(int a, int b) { return (a > b ? a : b); } 4000735c: 80 a5 80 11 cmp %l6, %l1 40007360: 16 80 00 04 bge 40007370 <_IO_Vprintf+0x294> <== ALWAYS TAKEN 40007364: 86 10 00 16 mov %l6, %g3 40007368: 86 10 00 11 mov %l1, %g3 <== NOT EXECUTED width -= tmp + imax(dwidth, n); 4000736c: c4 07 bf d4 ld [ %fp + -44 ], %g2 <== NOT EXECUTED 40007370: 82 00 c0 01 add %g3, %g1, %g1 dwidth -= n; 40007374: a2 25 80 11 sub %l6, %l1, %l1 width -= tmp + imax(dwidth, n); 40007378: a6 20 80 01 sub %g2, %g1, %l3 while (width-- > 0) 4000737c: ac 04 ff ff add %l3, -1, %l6 40007380: 80 a4 e0 00 cmp %l3, 0 40007384: 04 80 00 0b ble 400073b0 <_IO_Vprintf+0x2d4> 40007388: a6 10 00 16 mov %l6, %l3 PCHAR(' '); 4000738c: 92 10 00 19 mov %i1, %o1 40007390: 9f c7 00 00 call %i4 40007394: 90 10 20 20 mov 0x20, %o0 while (width-- > 0) 40007398: a6 04 ff ff add %l3, -1, %l3 4000739c: 80 a4 ff ff cmp %l3, -1 400073a0: 12 bf ff fc bne 40007390 <_IO_Vprintf+0x2b4> 400073a4: 92 10 00 19 mov %i1, %o1 400073a8: 84 05 60 01 add %l5, 1, %g2 400073ac: aa 05 80 02 add %l6, %g2, %l5 if (neg) 400073b0: 80 a5 20 00 cmp %l4, 0 400073b4: 02 80 01 8e be 400079ec <_IO_Vprintf+0x910> <== ALWAYS TAKEN 400073b8: 92 10 00 19 mov %i1, %o1 PCHAR('-'); 400073bc: 90 10 20 2d mov 0x2d, %o0 <== NOT EXECUTED 400073c0: 9f c7 00 00 call %i4 <== NOT EXECUTED 400073c4: a8 05 60 01 add %l5, 1, %l4 <== NOT EXECUTED if (sharpflag && num != 0) { 400073c8: c2 07 bf c4 ld [ %fp + -60 ], %g1 400073cc: 80 a0 60 00 cmp %g1, 0 400073d0: 02 80 00 0a be 400073f8 <_IO_Vprintf+0x31c> 400073d4: 80 a4 60 00 cmp %l1, 0 if (base == 8) { 400073d8: c2 07 bf bc ld [ %fp + -68 ], %g1 400073dc: 80 a0 60 08 cmp %g1, 8 400073e0: 12 80 01 92 bne 40007a28 <_IO_Vprintf+0x94c> <== ALWAYS TAKEN 400073e4: 92 10 00 19 mov %i1, %o1 PCHAR('0'); 400073e8: 90 10 20 30 mov 0x30, %o0 <== NOT EXECUTED 400073ec: 9f c7 00 00 call %i4 <== NOT EXECUTED 400073f0: a8 05 20 01 inc %l4 <== NOT EXECUTED while (dwidth-- > 0) 400073f4: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED 400073f8: 04 80 00 0c ble 40007428 <_IO_Vprintf+0x34c> 400073fc: aa 04 7f ff add %l1, -1, %l5 40007400: a2 10 00 15 mov %l5, %l1 PCHAR('0'); 40007404: 92 10 00 19 mov %i1, %o1 40007408: 9f c7 00 00 call %i4 4000740c: 90 10 20 30 mov 0x30, %o0 while (dwidth-- > 0) 40007410: a2 04 7f ff add %l1, -1, %l1 40007414: 80 a4 7f ff cmp %l1, -1 40007418: 12 bf ff fc bne 40007408 <_IO_Vprintf+0x32c> <== NEVER TAKEN 4000741c: 92 10 00 19 mov %i1, %o1 40007420: a8 05 20 01 inc %l4 40007424: a8 05 00 15 add %l4, %l5, %l4 while (*p) 40007428: bb 2f 60 18 sll %i5, 0x18, %i5 4000742c: 80 a7 60 00 cmp %i5, 0 40007430: 02 80 00 0c be 40007460 <_IO_Vprintf+0x384> <== NEVER TAKEN 40007434: 80 a4 a0 00 cmp %l2, 0 PCHAR(*p--); 40007438: 91 3f 60 18 sra %i5, 0x18, %o0 4000743c: a0 04 3f ff add %l0, -1, %l0 40007440: 9f c7 00 00 call %i4 40007444: 92 10 00 19 mov %i1, %o1 while (*p) 40007448: fa 0c 00 00 ldub [ %l0 ], %i5 4000744c: bb 2f 60 18 sll %i5, 0x18, %i5 40007450: 80 a7 60 00 cmp %i5, 0 40007454: 12 bf ff f9 bne 40007438 <_IO_Vprintf+0x35c> 40007458: a8 05 20 01 inc %l4 if (ladjust) 4000745c: 80 a4 a0 00 cmp %l2, 0 40007460: 22 bf ff 2a be,a 40007108 <_IO_Vprintf+0x2c> <== ALWAYS TAKEN 40007464: c2 0e 80 00 ldub [ %i2 ], %g1 while (width-- > 0) 40007468: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED 4000746c: 04 80 01 59 ble 400079d0 <_IO_Vprintf+0x8f4> <== NOT EXECUTED 40007470: a0 04 ff ff add %l3, -1, %l0 <== NOT EXECUTED 40007474: ba 10 00 10 mov %l0, %i5 <== NOT EXECUTED PCHAR(' '); 40007478: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000747c: 9f c7 00 00 call %i4 <== NOT EXECUTED 40007480: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED while (width-- > 0) 40007484: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED 40007488: 80 a7 7f ff cmp %i5, -1 <== NOT EXECUTED 4000748c: 12 bf ff fc bne 4000747c <_IO_Vprintf+0x3a0> <== NOT EXECUTED 40007490: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40007494: a8 05 20 01 inc %l4 <== NOT EXECUTED 40007498: a4 10 20 00 clr %l2 <== NOT EXECUTED 4000749c: 10 bf ff 1a b 40007104 <_IO_Vprintf+0x28> <== NOT EXECUTED 400074a0: a8 04 00 14 add %l0, %l4, %l4 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 400074a4: 84 10 20 00 clr %g2 <== NOT EXECUTED 400074a8: 86 10 20 10 mov 0x10, %g3 <== NOT EXECUTED base = 16; 400074ac: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 400074b0: c4 3f bf b0 std %g2, [ %fp + -80 ] <== NOT EXECUTED base = 16; 400074b4: c2 27 bf bc st %g1, [ %fp + -68 ] <== NOT EXECUTED if (jflag) 400074b8: 80 a5 20 00 cmp %l4, 0 400074bc: 02 80 01 4e be 400079f4 <_IO_Vprintf+0x918> 400074c0: 82 06 e0 04 add %i3, 4, %g1 num = va_arg(ap, intmax_t); 400074c4: 92 10 00 1b mov %i3, %o1 400074c8: 94 10 20 08 mov 8, %o2 400074cc: 40 00 1c 0d call 4000e500 400074d0: 90 07 bf e0 add %fp, -32, %o0 400074d4: c4 1f bf e0 ldd [ %fp + -32 ], %g2 400074d8: c4 3f bf c8 std %g2, [ %fp + -56 ] 400074dc: b6 06 e0 08 add %i3, 8, %i3 if (sign && (intmax_t)num < 0) { 400074e0: c4 1f bf c8 ldd [ %fp + -56 ], %g2 400074e4: 82 90 a0 00 orcc %g2, 0, %g1 400074e8: 16 80 01 c8 bge 40007c08 <_IO_Vprintf+0xb2c> <== ALWAYS TAKEN 400074ec: 9a a0 00 03 subcc %g0, %g3, %o5 num = -(intmax_t)num; 400074f0: ba 10 20 00 clr %i5 <== NOT EXECUTED 400074f4: 98 60 00 02 subx %g0, %g2, %o4 <== NOT EXECUTED neg = 1; 400074f8: a8 10 20 01 mov 1, %l4 <== NOT EXECUTED num = -(intmax_t)num; 400074fc: 10 bf ff 59 b 40007260 <_IO_Vprintf+0x184> <== NOT EXECUTED 40007500: d8 3f bf c8 std %o4, [ %fp + -56 ] <== NOT EXECUTED if (!ladjust && width > 0) 40007504: c2 07 bf d4 ld [ %fp + -44 ], %g1 40007508: 80 a0 60 01 cmp %g1, 1 4000750c: 14 80 00 03 bg 40007518 <_IO_Vprintf+0x43c> <== NEVER TAKEN 40007510: ba 10 20 01 mov 1, %i5 40007514: ba 10 20 00 clr %i5 40007518: a8 05 60 01 add %l5, 1, %l4 4000751c: 80 8c a0 01 btst 1, %l2 40007520: 12 80 01 52 bne 40007a68 <_IO_Vprintf+0x98c> <== NEVER TAKEN 40007524: a0 06 e0 04 add %i3, 4, %l0 40007528: 80 8f 60 ff btst 0xff, %i5 4000752c: 02 80 01 4f be 40007a68 <_IO_Vprintf+0x98c> <== ALWAYS TAKEN 40007530: c2 07 bf d4 ld [ %fp + -44 ], %g1 while (width--) 40007534: a6 00 7f fe add %g1, -2, %l3 <== NOT EXECUTED 40007538: c2 0f bf c3 ldub [ %fp + -61 ], %g1 <== NOT EXECUTED 4000753c: a3 28 60 18 sll %g1, 0x18, %l1 <== NOT EXECUTED 40007540: ba 10 00 13 mov %l3, %i5 <== NOT EXECUTED 40007544: a3 3c 60 18 sra %l1, 0x18, %l1 <== NOT EXECUTED PCHAR(padc); 40007548: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000754c: 9f c7 00 00 call %i4 <== NOT EXECUTED 40007550: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED while (width--) 40007554: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED 40007558: 80 a7 7f ff cmp %i5, -1 <== NOT EXECUTED 4000755c: 12 bf ff fc bne 4000754c <_IO_Vprintf+0x470> <== NOT EXECUTED 40007560: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED PCHAR(va_arg(ap, int)); 40007564: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED 40007568: a6 05 00 13 add %l4, %l3, %l3 <== NOT EXECUTED 4000756c: a8 04 e0 01 add %l3, 1, %l4 <== NOT EXECUTED 40007570: 9f c7 00 00 call %i4 <== NOT EXECUTED 40007574: b6 10 00 10 mov %l0, %i3 <== NOT EXECUTED 40007578: 10 bf fe e3 b 40007104 <_IO_Vprintf+0x28> <== NOT EXECUTED 4000757c: a4 10 20 00 clr %l2 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 40007580: 84 10 20 00 clr %g2 40007584: 86 10 20 0a mov 0xa, %g3 base = 10; 40007588: 82 10 20 0a mov 0xa, %g1 reswitch: switch (ch = (u_char)*fmt++) { 4000758c: c4 3f bf b0 std %g2, [ %fp + -80 ] base = 10; 40007590: 10 bf ff ca b 400074b8 <_IO_Vprintf+0x3dc> 40007594: c2 27 bf bc st %g1, [ %fp + -68 ] if (hflag) { 40007598: 80 a3 e0 00 cmp %o7, 0 <== NOT EXECUTED 4000759c: 12 80 01 55 bne 40007af0 <_IO_Vprintf+0xa14> <== NOT EXECUTED 400075a0: d8 08 60 01 ldub [ %g1 + 1 ], %o4 <== NOT EXECUTED hflag = 1; 400075a4: 9e 10 20 01 mov 1, %o7 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 400075a8: 10 bf ff 03 b 400071b4 <_IO_Vprintf+0xd8> <== NOT EXECUTED 400075ac: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED 400075b0: d8 08 60 01 ldub [ %g1 + 1 ], %o4 <== NOT EXECUTED jflag = 1; 400075b4: a8 10 20 01 mov 1, %l4 <== NOT EXECUTED goto reswitch; 400075b8: 10 bf fe ff b 400071b4 <_IO_Vprintf+0xd8> <== NOT EXECUTED 400075bc: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 400075c0: 84 10 20 00 clr %g2 400075c4: 86 10 20 10 mov 0x10, %g3 base = 16; 400075c8: 82 10 20 10 mov 0x10, %g1 reswitch: switch (ch = (u_char)*fmt++) { 400075cc: c4 3f bf b0 std %g2, [ %fp + -80 ] upper = 1; 400075d0: ba 10 20 01 mov 1, %i5 base = 16; 400075d4: 10 bf ff 18 b 40007234 <_IO_Vprintf+0x158> 400075d8: c2 27 bf bc st %g1, [ %fp + -68 ] reswitch: switch (ch = (u_char)*fmt++) { 400075dc: 84 10 20 00 clr %g2 400075e0: 86 10 20 0a mov 0xa, %g3 base = 10; 400075e4: 82 10 20 0a mov 0xa, %g1 reswitch: switch (ch = (u_char)*fmt++) { 400075e8: c4 3f bf b0 std %g2, [ %fp + -80 ] sign = 0; dot = 0; dwidth = 0; upper = 0; 400075ec: ba 10 20 00 clr %i5 base = 10; 400075f0: 10 bf ff 11 b 40007234 <_IO_Vprintf+0x158> 400075f4: c2 27 bf bc st %g1, [ %fp + -68 ] 400075f8: d8 08 60 01 ldub [ %g1 + 1 ], %o4 <== NOT EXECUTED dot = 1; 400075fc: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 40007600: 10 bf fe ed b 400071b4 <_IO_Vprintf+0xd8> <== NOT EXECUTED 40007604: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED ch = *fmt; 40007608: c6 48 60 01 ldsb [ %g1 + 1 ], %g3 if (ch < '0' || ch > '9') 4000760c: 84 00 ff d0 add %g3, -48, %g2 n = n * 10 + ch - '0'; 40007610: 90 02 3f d0 add %o0, -48, %o0 if (ch < '0' || ch > '9') 40007614: 80 a0 a0 09 cmp %g2, 9 40007618: 18 80 00 d4 bgu 40007968 <_IO_Vprintf+0x88c> <== ALWAYS TAKEN 4000761c: d8 08 60 01 ldub [ %g1 + 1 ], %o4 reswitch: switch (ch = (u_char)*fmt++) { 40007620: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED for (n = 0;; ++fmt) { 40007624: 82 00 60 01 inc %g1 <== NOT EXECUTED n = n * 10 + ch - '0'; 40007628: 85 2a 20 02 sll %o0, 2, %g2 <== NOT EXECUTED 4000762c: 84 00 80 08 add %g2, %o0, %g2 <== NOT EXECUTED 40007630: 85 28 a0 01 sll %g2, 1, %g2 <== NOT EXECUTED 40007634: 84 00 80 03 add %g2, %g3, %g2 <== NOT EXECUTED ch = *fmt; 40007638: c6 48 40 00 ldsb [ %g1 ], %g3 <== NOT EXECUTED if (ch < '0' || ch > '9') 4000763c: b4 00 ff d0 add %g3, -48, %i2 <== NOT EXECUTED n = n * 10 + ch - '0'; 40007640: 90 00 bf d0 add %g2, -48, %o0 <== NOT EXECUTED if (ch < '0' || ch > '9') 40007644: 80 a6 a0 09 cmp %i2, 9 <== NOT EXECUTED 40007648: 08 bf ff f7 bleu 40007624 <_IO_Vprintf+0x548> <== NOT EXECUTED 4000764c: d8 08 40 00 ldub [ %g1 ], %o4 <== NOT EXECUTED if (dot) 40007650: 80 a2 e0 00 cmp %o3, 0 40007654: 22 bf fe d8 be,a 400071b4 <_IO_Vprintf+0xd8> <== ALWAYS TAKEN 40007658: d0 27 bf d4 st %o0, [ %fp + -44 ] 4000765c: 10 bf fe d6 b 400071b4 <_IO_Vprintf+0xd8> <== NOT EXECUTED 40007660: d0 27 bf d0 st %o0, [ %fp + -48 ] <== NOT EXECUTED if (!width) 40007664: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED up = va_arg(ap, u_char *); 40007668: e0 06 c0 00 ld [ %i3 ], %l0 <== NOT EXECUTED p = va_arg(ap, char *); 4000766c: e2 06 e0 04 ld [ %i3 + 4 ], %l1 <== NOT EXECUTED if (!width) 40007670: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40007674: 12 80 00 04 bne 40007684 <_IO_Vprintf+0x5a8> <== NOT EXECUTED 40007678: b6 06 e0 08 add %i3, 8, %i3 <== NOT EXECUTED width = 16; 4000767c: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED 40007680: c2 27 bf d4 st %g1, [ %fp + -44 ] <== NOT EXECUTED 40007684: 82 04 3f ff add %l0, -1, %g1 <== NOT EXECUTED 40007688: c4 07 bf d4 ld [ %fp + -44 ], %g2 <== NOT EXECUTED for (q=p;*q;q++) 4000768c: a8 10 00 15 mov %l5, %l4 <== NOT EXECUTED 40007690: a4 04 00 02 add %l0, %g2, %l2 <== NOT EXECUTED 40007694: a6 00 40 02 add %g1, %g2, %l3 <== NOT EXECUTED while(width--) { 40007698: 80 a4 80 10 cmp %l2, %l0 <== NOT EXECUTED 4000769c: 22 bf fe 9a be,a 40007104 <_IO_Vprintf+0x28> <== NOT EXECUTED 400076a0: a4 10 20 00 clr %l2 <== NOT EXECUTED PCHAR(hex2ascii(*up >> 4)); 400076a4: c2 0c 00 00 ldub [ %l0 ], %g1 <== NOT EXECUTED 400076a8: 83 30 60 04 srl %g1, 4, %g1 <== NOT EXECUTED 400076ac: d0 4d c0 01 ldsb [ %l7 + %g1 ], %o0 <== NOT EXECUTED 400076b0: 9f c7 00 00 call %i4 <== NOT EXECUTED 400076b4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED PCHAR(hex2ascii(*up & 0x0f)); 400076b8: c2 0c 00 00 ldub [ %l0 ], %g1 <== NOT EXECUTED 400076bc: 82 08 60 0f and %g1, 0xf, %g1 <== NOT EXECUTED 400076c0: d0 4d c0 01 ldsb [ %l7 + %g1 ], %o0 <== NOT EXECUTED 400076c4: 9f c7 00 00 call %i4 <== NOT EXECUTED 400076c8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED if (width) 400076cc: 80 a4 c0 10 cmp %l3, %l0 <== NOT EXECUTED 400076d0: 02 80 00 c0 be 400079d0 <_IO_Vprintf+0x8f4> <== NOT EXECUTED 400076d4: a8 05 20 02 add %l4, 2, %l4 <== NOT EXECUTED for (q=p;*q;q++) 400076d8: d0 0c 40 00 ldub [ %l1 ], %o0 <== NOT EXECUTED 400076dc: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED 400076e0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400076e4: 22 bf ff ed be,a 40007698 <_IO_Vprintf+0x5bc> <== NOT EXECUTED 400076e8: a0 04 20 01 inc %l0 <== NOT EXECUTED 400076ec: ba 10 00 11 mov %l1, %i5 <== NOT EXECUTED PCHAR(*q); 400076f0: 91 3a 20 18 sra %o0, 0x18, %o0 <== NOT EXECUTED 400076f4: 9f c7 00 00 call %i4 <== NOT EXECUTED 400076f8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED for (q=p;*q;q++) 400076fc: ba 07 60 01 inc %i5 <== NOT EXECUTED 40007700: d0 0f 40 00 ldub [ %i5 ], %o0 <== NOT EXECUTED 40007704: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED 40007708: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000770c: 12 bf ff f9 bne 400076f0 <_IO_Vprintf+0x614> <== NOT EXECUTED 40007710: a8 05 20 01 inc %l4 <== NOT EXECUTED 40007714: 10 bf ff e1 b 40007698 <_IO_Vprintf+0x5bc> <== NOT EXECUTED 40007718: a0 04 20 01 inc %l0 <== NOT EXECUTED if (lflag) { 4000771c: 80 a1 20 00 cmp %g4, 0 40007720: 02 bf fe b3 be 400071ec <_IO_Vprintf+0x110> 40007724: d8 08 60 01 ldub [ %g1 + 1 ], %o4 jflag = 1; 40007728: a8 10 00 04 mov %g4, %l4 reswitch: switch (ch = (u_char)*fmt++) { 4000772c: 10 bf fe a2 b 400071b4 <_IO_Vprintf+0xd8> 40007730: 82 10 00 1a mov %i2, %g1 40007734: 84 10 20 00 clr %g2 <== NOT EXECUTED 40007738: 86 10 20 08 mov 8, %g3 <== NOT EXECUTED base = 8; 4000773c: 82 10 20 08 mov 8, %g1 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 40007740: c4 3f bf b0 std %g2, [ %fp + -80 ] <== NOT EXECUTED sign = 0; dot = 0; dwidth = 0; upper = 0; 40007744: ba 10 20 00 clr %i5 <== NOT EXECUTED base = 8; 40007748: 10 bf fe bb b 40007234 <_IO_Vprintf+0x158> <== NOT EXECUTED 4000774c: c2 27 bf bc st %g1, [ %fp + -68 ] <== NOT EXECUTED sharpflag = (width == 0); 40007750: c4 07 bf d4 ld [ %fp + -44 ], %g2 num = (uintptr_t)va_arg(ap, void *); 40007754: c2 06 c0 00 ld [ %i3 ], %g1 sharpflag = (width == 0); 40007758: 80 a0 00 02 cmp %g0, %g2 4000775c: 84 60 3f ff subx %g0, -1, %g2 num = (uintptr_t)va_arg(ap, void *); 40007760: 86 10 00 01 mov %g1, %g3 sharpflag = (width == 0); 40007764: c4 27 bf c4 st %g2, [ %fp + -60 ] num = (uintptr_t)va_arg(ap, void *); 40007768: 84 10 20 00 clr %g2 base = 16; 4000776c: 82 10 20 10 mov 0x10, %g1 num = (uintptr_t)va_arg(ap, void *); 40007770: c4 3f bf c8 std %g2, [ %fp + -56 ] 40007774: b6 06 e0 04 add %i3, 4, %i3 goto number; 40007778: 84 10 20 00 clr %g2 4000777c: 86 10 20 10 mov 0x10, %g3 sign = 0; dot = 0; dwidth = 0; upper = 0; 40007780: ba 10 20 00 clr %i5 goto number; 40007784: c4 3f bf b0 std %g2, [ %fp + -80 ] lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 40007788: a8 10 20 00 clr %l4 goto number; 4000778c: 10 bf fe b5 b 40007260 <_IO_Vprintf+0x184> 40007790: c2 27 bf bc st %g1, [ %fp + -68 ] p = va_arg(ap, char *); 40007794: fa 06 c0 00 ld [ %i3 ], %i5 if (p == NULL) 40007798: 80 a7 60 00 cmp %i5, 0 4000779c: 02 80 00 fd be 40007b90 <_IO_Vprintf+0xab4> <== NEVER TAKEN 400077a0: b6 06 e0 04 add %i3, 4, %i3 if (!dot) 400077a4: 80 a2 e0 00 cmp %o3, 0 400077a8: 12 80 00 db bne 40007b14 <_IO_Vprintf+0xa38> <== NEVER TAKEN 400077ac: c2 07 bf d0 ld [ %fp + -48 ], %g1 n = strlen (p); 400077b0: 40 00 1c 76 call 4000e988 400077b4: 90 10 00 1d mov %i5, %o0 400077b8: a2 10 00 08 mov %o0, %l1 width -= n; 400077bc: c2 07 bf d4 ld [ %fp + -44 ], %g1 400077c0: 84 20 40 11 sub %g1, %l1, %g2 400077c4: c4 27 bf d4 st %g2, [ %fp + -44 ] if (!ladjust && width > 0) 400077c8: a1 38 a0 1f sra %g2, 0x1f, %l0 400077cc: 82 0c a0 01 and %l2, 1, %g1 400077d0: a0 24 00 02 sub %l0, %g2, %l0 400077d4: a8 04 7f ff add %l1, -1, %l4 400077d8: 80 8c a0 01 btst 1, %l2 400077dc: 12 80 00 c9 bne 40007b00 <_IO_Vprintf+0xa24> <== NEVER TAKEN 400077e0: a1 34 20 1f srl %l0, 0x1f, %l0 400077e4: 80 a4 20 00 cmp %l0, 0 400077e8: 02 80 00 c7 be 40007b04 <_IO_Vprintf+0xa28> <== ALWAYS TAKEN 400077ec: 80 a4 60 00 cmp %l1, 0 while (width--) 400077f0: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED 400077f4: a6 00 7f ff add %g1, -1, %l3 <== NOT EXECUTED 400077f8: c2 0f bf c3 ldub [ %fp + -61 ], %g1 <== NOT EXECUTED 400077fc: a5 28 60 18 sll %g1, 0x18, %l2 <== NOT EXECUTED 40007800: a0 10 00 13 mov %l3, %l0 <== NOT EXECUTED 40007804: a5 3c a0 18 sra %l2, 0x18, %l2 <== NOT EXECUTED PCHAR(padc); 40007808: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000780c: 9f c7 00 00 call %i4 <== NOT EXECUTED 40007810: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED while (width--) 40007814: a0 04 3f ff add %l0, -1, %l0 <== NOT EXECUTED 40007818: 80 a4 3f ff cmp %l0, -1 <== NOT EXECUTED 4000781c: 12 bf ff fc bne 4000780c <_IO_Vprintf+0x730> <== NOT EXECUTED 40007820: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40007824: 84 05 60 01 add %l5, 1, %g2 <== NOT EXECUTED while (n--) 40007828: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED 4000782c: 02 80 00 fa be 40007c14 <_IO_Vprintf+0xb38> <== NOT EXECUTED 40007830: aa 00 80 13 add %g2, %l3, %l5 <== NOT EXECUTED 40007834: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED 40007838: c2 27 bf d4 st %g1, [ %fp + -44 ] <== NOT EXECUTED 4000783c: a0 10 20 00 clr %l0 <== NOT EXECUTED 40007840: a2 05 20 01 add %l4, 1, %l1 40007844: a2 07 40 11 add %i5, %l1, %l1 PCHAR(*p++); 40007848: ba 07 60 01 inc %i5 4000784c: d0 4f 7f ff ldsb [ %i5 + -1 ], %o0 40007850: 9f c7 00 00 call %i4 40007854: 92 10 00 19 mov %i1, %o1 while (n--) 40007858: 80 a7 40 11 cmp %i5, %l1 4000785c: 32 bf ff fc bne,a 4000784c <_IO_Vprintf+0x770> 40007860: ba 07 60 01 inc %i5 40007864: 84 05 60 01 add %l5, 1, %g2 40007868: a8 05 00 02 add %l4, %g2, %l4 if (ladjust && width > 0) 4000786c: 80 8c 20 ff btst 0xff, %l0 40007870: 02 bf fe 25 be 40007104 <_IO_Vprintf+0x28> <== ALWAYS TAKEN 40007874: a4 10 20 00 clr %l2 while (width--) 40007878: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED 4000787c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40007880: 02 bf fe 21 be 40007104 <_IO_Vprintf+0x28> <== NOT EXECUTED 40007884: a2 00 7f ff add %g1, -1, %l1 <== NOT EXECUTED 40007888: c2 0f bf c3 ldub [ %fp + -61 ], %g1 <== NOT EXECUTED 4000788c: a1 28 60 18 sll %g1, 0x18, %l0 <== NOT EXECUTED 40007890: ba 10 00 11 mov %l1, %i5 <== NOT EXECUTED 40007894: a1 3c 20 18 sra %l0, 0x18, %l0 <== NOT EXECUTED PCHAR(padc); 40007898: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000789c: 9f c7 00 00 call %i4 <== NOT EXECUTED 400078a0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED while (width--) 400078a4: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED 400078a8: 80 a7 7f ff cmp %i5, -1 <== NOT EXECUTED 400078ac: 12 bf ff fc bne 4000789c <_IO_Vprintf+0x7c0> <== NOT EXECUTED 400078b0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 400078b4: a8 05 20 01 inc %l4 <== NOT EXECUTED 400078b8: a4 10 20 00 clr %l2 <== NOT EXECUTED 400078bc: 10 bf fe 12 b 40007104 <_IO_Vprintf+0x28> <== NOT EXECUTED 400078c0: a8 04 40 14 add %l1, %l4, %l4 <== NOT EXECUTED 400078c4: d8 08 60 01 ldub [ %g1 + 1 ], %o4 <== NOT EXECUTED sharpflag = 1; 400078c8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 400078cc: c2 27 bf c4 st %g1, [ %fp + -60 ] <== NOT EXECUTED goto reswitch; 400078d0: 10 bf fe 39 b 400071b4 <_IO_Vprintf+0xd8> <== NOT EXECUTED 400078d4: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED PCHAR(ch); 400078d8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 400078dc: 9f c7 00 00 call %i4 <== NOT EXECUTED 400078e0: a8 05 60 01 add %l5, 1, %l4 <== NOT EXECUTED break; 400078e4: 10 bf fe 08 b 40007104 <_IO_Vprintf+0x28> <== NOT EXECUTED 400078e8: a4 10 20 00 clr %l2 <== NOT EXECUTED 400078ec: 84 06 e0 04 add %i3, 4, %g2 <== NOT EXECUTED if (!dot) { 400078f0: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED 400078f4: 12 80 00 76 bne 40007acc <_IO_Vprintf+0x9f0> <== NOT EXECUTED 400078f8: c6 06 c0 00 ld [ %i3 ], %g3 <== NOT EXECUTED if (width < 0) { 400078fc: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40007900: 06 80 00 af bl 40007bbc <_IO_Vprintf+0xae0> <== NOT EXECUTED 40007904: c6 27 bf d4 st %g3, [ %fp + -44 ] <== NOT EXECUTED 40007908: d8 08 60 01 ldub [ %g1 + 1 ], %o4 <== NOT EXECUTED dwidth = va_arg(ap, int); 4000790c: b6 10 00 02 mov %g2, %i3 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 40007910: 10 bf fe 29 b 400071b4 <_IO_Vprintf+0xd8> <== NOT EXECUTED 40007914: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED 40007918: d8 08 60 01 ldub [ %g1 + 1 ], %o4 <== NOT EXECUTED ladjust = 1; 4000791c: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED goto reswitch; 40007920: 10 bf fe 25 b 400071b4 <_IO_Vprintf+0xd8> <== NOT EXECUTED 40007924: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED while (percent < fmt) 40007928: a0 10 00 1d mov %i5, %l0 <== NOT EXECUTED 4000792c: a8 10 00 15 mov %l5, %l4 <== NOT EXECUTED 40007930: 80 a6 80 1d cmp %i2, %i5 <== NOT EXECUTED 40007934: 08 bf fd f4 bleu 40007104 <_IO_Vprintf+0x28> <== NOT EXECUTED 40007938: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED PCHAR(*percent++); 4000793c: a0 04 20 01 inc %l0 <== NOT EXECUTED 40007940: d0 4c 3f ff ldsb [ %l0 + -1 ], %o0 <== NOT EXECUTED 40007944: 9f c7 00 00 call %i4 <== NOT EXECUTED 40007948: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED while (percent < fmt) 4000794c: 80 a6 80 10 cmp %i2, %l0 <== NOT EXECUTED 40007950: 32 bf ff fc bne,a 40007940 <_IO_Vprintf+0x864> <== NOT EXECUTED 40007954: a0 04 20 01 inc %l0 <== NOT EXECUTED 40007958: 84 25 40 1d sub %l5, %i5, %g2 <== NOT EXECUTED stop = 1; 4000795c: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED 40007960: 10 bf fd e9 b 40007104 <_IO_Vprintf+0x28> <== NOT EXECUTED 40007964: a8 06 80 02 add %i2, %g2, %l4 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 40007968: 10 bf ff 3a b 40007650 <_IO_Vprintf+0x574> 4000796c: 82 10 00 1a mov %i2, %g1 static inline int imax(int a, int b) { return (a > b ? a : b); } 40007970: c4 07 bf d0 ld [ %fp + -48 ], %g2 40007974: 80 a0 80 11 cmp %g2, %l1 40007978: 16 80 00 04 bge 40007988 <_IO_Vprintf+0x8ac> <== NEVER TAKEN 4000797c: 86 10 00 02 mov %g2, %g3 40007980: 86 10 00 11 mov %l1, %g3 dwidth -= n; 40007984: c4 07 bf d0 ld [ %fp + -48 ], %g2 40007988: a2 20 80 11 sub %g2, %l1, %l1 width -= tmp + imax(dwidth, n); 4000798c: c4 07 bf d4 ld [ %fp + -44 ], %g2 40007990: 82 00 c0 01 add %g3, %g1, %g1 if (!ladjust) 40007994: 80 a4 a0 00 cmp %l2, 0 40007998: 12 bf fe 86 bne 400073b0 <_IO_Vprintf+0x2d4> <== NEVER TAKEN 4000799c: a6 20 80 01 sub %g2, %g1, %l3 while (width-- > 0) 400079a0: 10 bf fe 78 b 40007380 <_IO_Vprintf+0x2a4> 400079a4: ac 04 ff ff add %l3, -1, %l6 else if (lflag) 400079a8: 12 80 00 0c bne 400079d8 <_IO_Vprintf+0x8fc> 400079ac: 82 06 e0 04 add %i3, 4, %g1 else if (hflag) 400079b0: 80 a3 e0 00 cmp %o7, 0 400079b4: 02 80 00 48 be 40007ad4 <_IO_Vprintf+0x9f8> <== ALWAYS TAKEN 400079b8: 80 a3 60 00 cmp %o5, 0 num = (u_short)va_arg(ap, int); 400079bc: c6 16 e0 02 lduh [ %i3 + 2 ], %g3 <== NOT EXECUTED 400079c0: 84 10 20 00 clr %g2 <== NOT EXECUTED 400079c4: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED 400079c8: 10 bf fe 26 b 40007260 <_IO_Vprintf+0x184> <== NOT EXECUTED 400079cc: c4 3f bf c8 std %g2, [ %fp + -56 ] <== NOT EXECUTED while (width-- > 0) 400079d0: 10 bf fd cd b 40007104 <_IO_Vprintf+0x28> <== NOT EXECUTED 400079d4: a4 10 20 00 clr %l2 <== NOT EXECUTED num = va_arg(ap, u_int); 400079d8: c6 06 c0 00 ld [ %i3 ], %g3 400079dc: 84 10 20 00 clr %g2 400079e0: b6 10 00 01 mov %g1, %i3 400079e4: 10 bf fe 1f b 40007260 <_IO_Vprintf+0x184> 400079e8: c4 3f bf c8 std %g2, [ %fp + -56 ] 400079ec: 10 bf fe 77 b 400073c8 <_IO_Vprintf+0x2ec> 400079f0: a8 10 00 15 mov %l5, %l4 else if (tflag) 400079f4: 80 a1 20 00 cmp %g4, 0 400079f8: 12 80 00 17 bne 40007a54 <_IO_Vprintf+0x978> 400079fc: c6 06 c0 00 ld [ %i3 ], %g3 else if (hflag) 40007a00: 80 a3 e0 00 cmp %o7, 0 40007a04: 02 80 00 66 be 40007b9c <_IO_Vprintf+0xac0> <== ALWAYS TAKEN 40007a08: 80 a3 60 00 cmp %o5, 0 num = (short)va_arg(ap, int); 40007a0c: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED 40007a10: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED 40007a14: 83 38 e0 10 sra %g3, 0x10, %g1 <== NOT EXECUTED 40007a18: c2 27 bf cc st %g1, [ %fp + -52 ] <== NOT EXECUTED 40007a1c: 83 38 e0 1f sra %g3, 0x1f, %g1 <== NOT EXECUTED 40007a20: 10 bf fe b0 b 400074e0 <_IO_Vprintf+0x404> <== NOT EXECUTED 40007a24: c2 27 bf c8 st %g1, [ %fp + -56 ] <== NOT EXECUTED } else if (base == 16) { 40007a28: 80 a0 60 10 cmp %g1, 0x10 40007a2c: 32 bf fe 73 bne,a 400073f8 <_IO_Vprintf+0x31c> <== NEVER TAKEN 40007a30: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED PCHAR('0'); 40007a34: 9f c7 00 00 call %i4 40007a38: 90 10 20 30 mov 0x30, %o0 PCHAR('x'); 40007a3c: 92 10 00 19 mov %i1, %o1 40007a40: 90 10 20 78 mov 0x78, %o0 40007a44: 9f c7 00 00 call %i4 40007a48: a8 05 20 02 add %l4, 2, %l4 while (dwidth-- > 0) 40007a4c: 10 bf fe 6b b 400073f8 <_IO_Vprintf+0x31c> 40007a50: 80 a4 60 00 cmp %l1, 0 num = va_arg(ap, int); 40007a54: b6 10 00 01 mov %g1, %i3 40007a58: c6 27 bf cc st %g3, [ %fp + -52 ] 40007a5c: 83 38 e0 1f sra %g3, 0x1f, %g1 40007a60: 10 bf fe a0 b 400074e0 <_IO_Vprintf+0x404> 40007a64: c2 27 bf c8 st %g1, [ %fp + -56 ] PCHAR(va_arg(ap, int)); 40007a68: d0 06 c0 00 ld [ %i3 ], %o0 40007a6c: 9f c7 00 00 call %i4 40007a70: 92 10 00 19 mov %i1, %o1 if (ladjust && width > 0) 40007a74: 80 8c a0 01 btst 1, %l2 40007a78: 02 80 00 3b be 40007b64 <_IO_Vprintf+0xa88> <== ALWAYS TAKEN 40007a7c: 80 8f 60 ff btst 0xff, %i5 40007a80: 02 80 00 39 be 40007b64 <_IO_Vprintf+0xa88> <== NOT EXECUTED 40007a84: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED while (width--) 40007a88: a8 00 7f fe add %g1, -2, %l4 <== NOT EXECUTED 40007a8c: c2 0f bf c3 ldub [ %fp + -61 ], %g1 <== NOT EXECUTED 40007a90: b7 28 60 18 sll %g1, 0x18, %i3 <== NOT EXECUTED 40007a94: ba 10 00 14 mov %l4, %i5 <== NOT EXECUTED 40007a98: b7 3e e0 18 sra %i3, 0x18, %i3 <== NOT EXECUTED PCHAR(padc); 40007a9c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40007aa0: 9f c7 00 00 call %i4 <== NOT EXECUTED 40007aa4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED while (width--) 40007aa8: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED 40007aac: 80 a7 7f ff cmp %i5, -1 <== NOT EXECUTED 40007ab0: 12 bf ff fc bne 40007aa0 <_IO_Vprintf+0x9c4> <== NOT EXECUTED 40007ab4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40007ab8: 84 05 60 02 add %l5, 2, %g2 <== NOT EXECUTED PCHAR(va_arg(ap, int)); 40007abc: b6 10 00 10 mov %l0, %i3 <== NOT EXECUTED 40007ac0: a8 05 00 02 add %l4, %g2, %l4 <== NOT EXECUTED while (width--) 40007ac4: 10 bf fd 90 b 40007104 <_IO_Vprintf+0x28> <== NOT EXECUTED 40007ac8: a4 10 20 00 clr %l2 <== NOT EXECUTED dwidth = va_arg(ap, int); 40007acc: 10 bf ff 8f b 40007908 <_IO_Vprintf+0x82c> <== NOT EXECUTED 40007ad0: c6 27 bf d0 st %g3, [ %fp + -48 ] <== NOT EXECUTED else if (cflag) 40007ad4: 22 bf ff c2 be,a 400079dc <_IO_Vprintf+0x900> <== ALWAYS TAKEN 40007ad8: c6 06 c0 00 ld [ %i3 ], %g3 num = (u_char)va_arg(ap, int); 40007adc: c6 0e e0 03 ldub [ %i3 + 3 ], %g3 <== NOT EXECUTED 40007ae0: 84 10 20 00 clr %g2 <== NOT EXECUTED 40007ae4: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED 40007ae8: 10 bf fd de b 40007260 <_IO_Vprintf+0x184> <== NOT EXECUTED 40007aec: c4 3f bf c8 std %g2, [ %fp + -56 ] <== NOT EXECUTED cflag = 1; 40007af0: 9a 10 00 0f mov %o7, %o5 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 40007af4: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED hflag = 0; 40007af8: 10 bf fd af b 400071b4 <_IO_Vprintf+0xd8> <== NOT EXECUTED 40007afc: 9e 10 20 00 clr %o7 <== NOT EXECUTED while (n--) 40007b00: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED 40007b04: 12 bf ff 4f bne 40007840 <_IO_Vprintf+0x764> <== ALWAYS TAKEN 40007b08: a0 0c 00 01 and %l0, %g1, %l0 40007b0c: 10 bf ff 58 b 4000786c <_IO_Vprintf+0x790> <== NOT EXECUTED 40007b10: a8 10 00 15 mov %l5, %l4 <== NOT EXECUTED for (n = 0; n < dwidth && p[n]; n++) 40007b14: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40007b18: 04 80 00 06 ble 40007b30 <_IO_Vprintf+0xa54> <== NOT EXECUTED 40007b1c: c4 07 bf d4 ld [ %fp + -44 ], %g2 <== NOT EXECUTED 40007b20: c2 4f 40 00 ldsb [ %i5 ], %g1 <== NOT EXECUTED 40007b24: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40007b28: 12 80 00 2d bne 40007bdc <_IO_Vprintf+0xb00> <== NOT EXECUTED 40007b2c: a2 10 20 00 clr %l1 <== NOT EXECUTED if (!ladjust && width > 0) 40007b30: a1 38 a0 1f sra %g2, 0x1f, %l0 <== NOT EXECUTED 40007b34: 82 0c a0 01 and %l2, 1, %g1 <== NOT EXECUTED 40007b38: a0 24 00 02 sub %l0, %g2, %l0 <== NOT EXECUTED 40007b3c: 80 8c a0 01 btst 1, %l2 <== NOT EXECUTED 40007b40: 12 80 00 06 bne 40007b58 <_IO_Vprintf+0xa7c> <== NOT EXECUTED 40007b44: a1 34 20 1f srl %l0, 0x1f, %l0 <== NOT EXECUTED 40007b48: a8 10 3f ff mov -1, %l4 <== NOT EXECUTED 40007b4c: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 40007b50: 12 bf ff 28 bne 400077f0 <_IO_Vprintf+0x714> <== NOT EXECUTED 40007b54: a2 10 20 00 clr %l1 <== NOT EXECUTED 40007b58: a0 0c 00 01 and %l0, %g1, %l0 <== NOT EXECUTED 40007b5c: 10 bf ff 44 b 4000786c <_IO_Vprintf+0x790> <== NOT EXECUTED 40007b60: a8 10 00 15 mov %l5, %l4 <== NOT EXECUTED PCHAR(va_arg(ap, int)); 40007b64: b6 10 00 10 mov %l0, %i3 40007b68: 10 bf fd 67 b 40007104 <_IO_Vprintf+0x28> 40007b6c: a4 10 20 00 clr %l2 if (ch < '0' || ch > '9') 40007b70: 84 00 ff d0 add %g3, -48, %g2 <== NOT EXECUTED n = n * 10 + ch - '0'; 40007b74: 90 02 3f d0 add %o0, -48, %o0 <== NOT EXECUTED if (ch < '0' || ch > '9') 40007b78: 80 a0 a0 09 cmp %g2, 9 <== NOT EXECUTED 40007b7c: 08 bf fe a9 bleu 40007620 <_IO_Vprintf+0x544> <== NOT EXECUTED 40007b80: d8 08 60 01 ldub [ %g1 + 1 ], %o4 <== NOT EXECUTED n = n * 10 + ch - '0'; 40007b84: d0 27 bf d0 st %o0, [ %fp + -48 ] <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 40007b88: 10 bf fd 8b b 400071b4 <_IO_Vprintf+0xd8> <== NOT EXECUTED 40007b8c: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED p = "(null)"; 40007b90: 3b 10 00 42 sethi %hi(0x40010800), %i5 <== NOT EXECUTED 40007b94: 10 bf ff 04 b 400077a4 <_IO_Vprintf+0x6c8> <== NOT EXECUTED 40007b98: ba 17 60 08 or %i5, 8, %i5 ! 40010808 <_Objects_Information_table+0x34> <== NOT EXECUTED else if (cflag) 40007b9c: 02 bf ff af be 40007a58 <_IO_Vprintf+0x97c> <== ALWAYS TAKEN 40007ba0: b6 10 00 01 mov %g1, %i3 num = (char)va_arg(ap, int); 40007ba4: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED 40007ba8: 83 38 e0 18 sra %g3, 0x18, %g1 <== NOT EXECUTED 40007bac: c2 27 bf cc st %g1, [ %fp + -52 ] <== NOT EXECUTED 40007bb0: 83 38 e0 1f sra %g3, 0x1f, %g1 <== NOT EXECUTED 40007bb4: 10 bf fe 4b b 400074e0 <_IO_Vprintf+0x404> <== NOT EXECUTED 40007bb8: c2 27 bf c8 st %g1, [ %fp + -56 ] <== NOT EXECUTED 40007bbc: d8 08 60 01 ldub [ %g1 + 1 ], %o4 <== NOT EXECUTED width = -width; 40007bc0: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED 40007bc4: 82 20 00 01 neg %g1 <== NOT EXECUTED 40007bc8: a4 1c a0 01 xor %l2, 1, %l2 <== NOT EXECUTED 40007bcc: c2 27 bf d4 st %g1, [ %fp + -44 ] <== NOT EXECUTED width = va_arg(ap, int); 40007bd0: b6 10 00 02 mov %g2, %i3 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 40007bd4: 10 bf fd 78 b 400071b4 <_IO_Vprintf+0xd8> <== NOT EXECUTED 40007bd8: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED for (n = 0; n < dwidth && p[n]; n++) 40007bdc: c2 07 bf d0 ld [ %fp + -48 ], %g1 <== NOT EXECUTED 40007be0: a2 04 60 01 inc %l1 <== NOT EXECUTED 40007be4: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 40007be8: 02 bf fe f6 be 400077c0 <_IO_Vprintf+0x6e4> <== NOT EXECUTED 40007bec: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED 40007bf0: c2 4f 40 11 ldsb [ %i5 + %l1 ], %g1 <== NOT EXECUTED 40007bf4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40007bf8: 22 bf fe f2 be,a 400077c0 <_IO_Vprintf+0x6e4> <== NOT EXECUTED 40007bfc: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED 40007c00: 10 bf ff f8 b 40007be0 <_IO_Vprintf+0xb04> <== NOT EXECUTED 40007c04: c2 07 bf d0 ld [ %fp + -48 ], %g1 <== NOT EXECUTED 40007c08: ba 10 20 00 clr %i5 lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 40007c0c: 10 bf fd 95 b 40007260 <_IO_Vprintf+0x184> 40007c10: a8 10 20 00 clr %l4 while (n--) 40007c14: a8 10 00 15 mov %l5, %l4 <== NOT EXECUTED 40007c18: 10 bf fd 3b b 40007104 <_IO_Vprintf+0x28> <== NOT EXECUTED 40007c1c: a4 10 20 00 clr %l2 <== NOT EXECUTED =============================================================================== 40007c20 <_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 ) { 40007c20: 9d e3 bf a0 save %sp, -96, %sp _CPU_Initialize_vectors(); #endif #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) { size_t stack_size = rtems_configuration_get_interrupt_stack_size(); 40007c24: 03 10 00 3f sethi %hi(0x4000fc00), %g1 _ISR_Nest_level = 0; 40007c28: c0 21 a0 10 clr [ %g6 + 0x10 ] size_t stack_size = rtems_configuration_get_interrupt_stack_size(); 40007c2c: fa 00 62 b8 ld [ %g1 + 0x2b8 ], %i5 uint32_t cpu_max = rtems_configuration_get_maximum_processors(); uint32_t cpu_index; if ( !_Stack_Is_enough( stack_size ) ) 40007c30: 03 10 00 43 sethi %hi(0x40010c00), %g1 40007c34: c2 00 62 00 ld [ %g1 + 0x200 ], %g1 ! 40010e00 <_data_load_start> 40007c38: 80 a7 40 01 cmp %i5, %g1 40007c3c: 0a 80 00 0c bcs 40007c6c <_ISR_Handler_initialization+0x4c> <== NEVER TAKEN 40007c40: 01 00 00 00 nop _Internal_error( INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); for ( cpu_index = 0 ; cpu_index < cpu_max; ++cpu_index ) { Per_CPU_Control *cpu = _Per_CPU_Get_by_index( cpu_index ); void *low = _Workspace_Allocate_or_fatal_error( stack_size ); 40007c44: 40 00 11 0b call 4000c070 <_Workspace_Allocate_or_fatal_error> 40007c48: 90 10 00 1d mov %i5, %o0 #if (CPU_STACK_ALIGNMENT != 0) high = _Addresses_Align_down( high, CPU_STACK_ALIGNMENT ); #endif cpu->interrupt_stack_low = low; 40007c4c: 03 10 00 4a sethi %hi(0x40012800), %g1 RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( const void *base, uintptr_t offset ) { return (void *)((uintptr_t)base + offset); 40007c50: ba 02 00 1d add %o0, %i5, %i5 40007c54: 82 10 61 c0 or %g1, 0x1c0, %g1 void *address, size_t alignment ) { uintptr_t mask = alignment - (uintptr_t)1; return (void*)((uintptr_t)address & ~mask); 40007c58: ba 0f 7f f8 and %i5, -8, %i5 40007c5c: d0 20 60 08 st %o0, [ %g1 + 8 ] cpu->interrupt_stack_high = high; 40007c60: fa 20 60 0c st %i5, [ %g1 + 0xc ] #endif #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 40007c64: 81 c7 e0 08 ret 40007c68: 81 e8 00 00 restore _Internal_error( INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); 40007c6c: 7f ff fc bf call 40006f68 <_Internal_error> <== NOT EXECUTED 40007c70: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED 40007c74: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40006f68 <_Internal_error>: /* will not return from this routine */ while (true); } void _Internal_error( Internal_errors_Core_list core_error ) { 40006f68: 9d e3 bf a0 save %sp, -96, %sp _Terminate( INTERNAL_ERROR_CORE, core_error ); 40006f6c: 90 10 20 00 clr %o0 40006f70: 7f ff ff eb call 40006f1c <_Terminate> 40006f74: 92 10 00 18 mov %i0, %o1 40006f78: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 400110b0 <_Mutex_Acquire>: ); } } void _Mutex_Acquire( struct _Mutex_Control *_mutex ) { 400110b0: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400110b4: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 400110b8: 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 ) ) { 400110bc: c4 06 20 0c ld [ %i0 + 0xc ], %g2 400110c0: 80 a0 a0 00 cmp %g2, 0 400110c4: 12 80 00 07 bne 400110e0 <_Mutex_Acquire+0x30> <== NEVER TAKEN 400110c8: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2 <== NOT EXECUTED mutex->Queue.Queue.owner = executing; 400110cc: d4 26 20 0c st %o2, [ %i0 + 0xc ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400110d0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400110d4: 01 00 00 00 nop 400110d8: 81 c7 e0 08 ret 400110dc: 81 e8 00 00 restore queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra; 400110e0: 03 10 00 4e sethi %hi(0x40013800), %g1 <== NOT EXECUTED 400110e4: 82 10 61 24 or %g1, 0x124, %g1 ! 40013924 <_Thread_queue_Enqueue_do_nothing_extra> <== NOT EXECUTED 400110e8: c2 27 bf e4 st %g1, [ %fp + -28 ] <== NOT EXECUTED queue_context->thread_state = thread_state; 400110ec: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 400110f0: c2 27 bf e0 st %g1, [ %fp + -32 ] <== NOT EXECUTED queue_context->deadlock_callout = deadlock_callout; 400110f4: 03 10 00 4e sethi %hi(0x40013800), %g1 <== NOT EXECUTED 400110f8: 82 10 61 3c or %g1, 0x13c, %g1 ! 4001393c <_Thread_queue_Deadlock_fatal> <== NOT EXECUTED _Thread_queue_Enqueue( 400110fc: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED 40011100: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED 40011104: 13 10 00 bb sethi %hi(0x4002ec00), %o1 <== NOT EXECUTED ) { #if defined( RTEMS_SMP ) context->Lock_context.isr_level = level; #else context->isr_level = level; 40011108: c6 27 bf dc st %g3, [ %fp + -36 ] <== NOT EXECUTED 4001110c: 92 12 63 cc or %o1, 0x3cc, %o1 <== NOT EXECUTED 40011110: 40 00 0a 0f call 4001394c <_Thread_queue_Enqueue> <== NOT EXECUTED 40011114: 90 06 20 08 add %i0, 8, %o0 <== NOT EXECUTED _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 ); } } 40011118: 81 c7 e0 08 ret <== NOT EXECUTED 4001111c: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40011120 <_Mutex_Release>: return eno; } void _Mutex_Release( struct _Mutex_Control *_mutex ) { 40011120: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40011124: 91 d0 20 09 ta 9 <== NOT EXECUTED executing = _Thread_Executing; 40011128: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2 mutex->Queue.Queue.owner = NULL; 4001112c: c0 26 20 0c clr [ %i0 + 0xc ] heads = mutex->Queue.Queue.heads; 40011130: d2 06 20 08 ld [ %i0 + 8 ], %o1 if ( __predict_true( heads == NULL ) ) { 40011134: 80 a2 60 00 cmp %o1, 0 40011138: 32 80 00 06 bne,a 40011150 <_Mutex_Release+0x30> <== NEVER TAKEN 4001113c: c2 27 bf dc st %g1, [ %fp + -36 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40011140: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40011144: 01 00 00 00 nop 40011148: 81 c7 e0 08 ret 4001114c: 81 e8 00 00 restore _Thread_queue_Surrender( 40011150: 19 10 00 bb sethi %hi(0x4002ec00), %o4 <== NOT EXECUTED 40011154: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED 40011158: 98 13 23 cc or %o4, 0x3cc, %o4 <== NOT EXECUTED 4001115c: 40 00 0a b3 call 40013c28 <_Thread_queue_Surrender> <== NOT EXECUTED 40011160: 90 06 20 08 add %i0, 8, %o0 <== NOT EXECUTED executing = _Mutex_Queue_acquire_critical( mutex, &queue_context ); _Assert( mutex->Queue.Queue.owner == executing ); _Mutex_Release_critical( mutex, executing, level, &queue_context ); } 40011164: 81 c7 e0 08 ret <== NOT EXECUTED 40011168: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000833c <_Mutex_recursive_Acquire>: { return (Mutex_recursive_Control *) _mutex; } void _Mutex_recursive_Acquire( struct _Mutex_recursive_Control *_mutex ) { 4000833c: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40008340: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 40008344: 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; 40008348: c4 06 20 0c ld [ %i0 + 0xc ], %g2 if ( __predict_true( owner == NULL ) ) { 4000834c: 80 a0 a0 00 cmp %g2, 0 40008350: 12 80 00 07 bne 4000836c <_Mutex_recursive_Acquire+0x30> 40008354: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2 mutex->Mutex.Queue.Queue.owner = executing; 40008358: d4 26 20 0c st %o2, [ %i0 + 0xc ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000835c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40008360: 01 00 00 00 nop 40008364: 81 c7 e0 08 ret 40008368: 81 e8 00 00 restore _Thread_Resource_count_increment( executing ); _Mutex_Queue_release( &mutex->Mutex, level, &queue_context ); } else if ( owner == executing ) { 4000836c: 80 a2 80 02 cmp %o2, %g2 40008370: 02 80 00 11 be 400083b4 <_Mutex_recursive_Acquire+0x78> 40008374: 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; 40008378: 03 10 00 28 sethi %hi(0x4000a000), %g1 4000837c: 82 10 62 e4 or %g1, 0x2e4, %g1 ! 4000a2e4 <_Thread_queue_Enqueue_do_nothing_extra> 40008380: c2 27 bf e4 st %g1, [ %fp + -28 ] queue_context->thread_state = thread_state; 40008384: 82 10 20 01 mov 1, %g1 40008388: 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; 4000838c: 03 10 00 28 sethi %hi(0x4000a000), %g1 40008390: 82 10 62 ec or %g1, 0x2ec, %g1 ! 4000a2ec <_Thread_queue_Deadlock_fatal> 40008394: c2 27 bf fc st %g1, [ %fp + -4 ] _Thread_queue_Enqueue( 40008398: 13 10 00 42 sethi %hi(0x40010800), %o1 ) { #if defined( RTEMS_SMP ) context->Lock_context.isr_level = level; #else context->isr_level = level; 4000839c: c6 27 bf dc st %g3, [ %fp + -36 ] 400083a0: 92 12 60 38 or %o1, 0x38, %o1 400083a4: 40 00 07 d6 call 4000a2fc <_Thread_queue_Enqueue> 400083a8: 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 ); } } 400083ac: 81 c7 e0 08 ret 400083b0: 81 e8 00 00 restore ++mutex->nest_level; 400083b4: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED 400083b8: 84 00 a0 01 inc %g2 <== NOT EXECUTED 400083bc: c4 26 20 14 st %g2, [ %i0 + 0x14 ] <== NOT EXECUTED 400083c0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400083c4: 01 00 00 00 nop 400083c8: 81 c7 e0 08 ret 400083cc: 81 e8 00 00 restore =============================================================================== 400083d0 <_Mutex_recursive_Release>: return eno; } void _Mutex_recursive_Release( struct _Mutex_recursive_Control *_mutex ) { 400083d0: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400083d4: 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; 400083d8: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 if ( __predict_true( nest_level == 0 ) ) { 400083dc: 80 a0 a0 00 cmp %g2, 0 400083e0: 12 80 00 0b bne 4000840c <_Mutex_recursive_Release+0x3c> 400083e4: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2 mutex->Queue.Queue.owner = NULL; 400083e8: c0 26 20 0c clr [ %i0 + 0xc ] heads = mutex->Queue.Queue.heads; 400083ec: d2 06 20 08 ld [ %i0 + 8 ], %o1 if ( __predict_true( heads == NULL ) ) { 400083f0: 80 a2 60 00 cmp %o1, 0 400083f4: 32 80 00 0c bne,a 40008424 <_Mutex_recursive_Release+0x54> 400083f8: c2 27 bf dc st %g1, [ %fp + -36 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400083fc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40008400: 01 00 00 00 nop } else { mutex->nest_level = nest_level - 1; _Mutex_Queue_release( &mutex->Mutex, level, &queue_context ); } } 40008404: 81 c7 e0 08 ret 40008408: 81 e8 00 00 restore mutex->nest_level = nest_level - 1; 4000840c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 40008410: c4 26 20 14 st %g2, [ %i0 + 0x14 ] <== NOT EXECUTED 40008414: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40008418: 01 00 00 00 nop } 4000841c: 81 c7 e0 08 ret 40008420: 81 e8 00 00 restore _Thread_queue_Surrender( 40008424: 19 10 00 42 sethi %hi(0x40010800), %o4 40008428: 96 07 bf dc add %fp, -36, %o3 4000842c: 98 13 20 38 or %o4, 0x38, %o4 40008430: 40 00 08 50 call 4000a570 <_Thread_queue_Surrender> 40008434: 90 06 20 08 add %i0, 8, %o0 40008438: 81 c7 e0 08 ret 4000843c: 81 e8 00 00 restore =============================================================================== 4000e2c8 <_Objects_API_maximum_class>: #include unsigned int _Objects_API_maximum_class( uint32_t api ) { 4000e2c8: 82 02 3f ff add %o0, -1, %g1 4000e2cc: 80 a0 60 02 cmp %g1, 2 4000e2d0: 18 80 00 06 bgu 4000e2e8 <_Objects_API_maximum_class+0x20> <== NEVER TAKEN 4000e2d4: 90 10 20 00 clr %o0 4000e2d8: 83 28 60 02 sll %g1, 2, %g1 4000e2dc: 05 10 00 43 sethi %hi(0x40010c00), %g2 4000e2e0: 84 10 a0 18 or %g2, 0x18, %g2 ! 40010c18 4000e2e4: d0 00 80 01 ld [ %g2 + %g1 ], %o0 case OBJECTS_NO_API: default: break; } return 0; } 4000e2e8: 81 c3 e0 08 retl 4000e2ec: 01 00 00 00 nop =============================================================================== 40008440 <_Objects_Allocate_unprotected>: } Objects_Control *_Objects_Allocate_unprotected( Objects_Information *information ) { 40008440: 9d e3 bf a0 save %sp, -96, %sp * 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 ) 40008444: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 40008448: 80 a0 60 00 cmp %g1, 0 4000844c: 02 80 00 31 be 40008510 <_Objects_Allocate_unprotected+0xd0> <== NEVER TAKEN 40008450: ba 10 00 18 mov %i0, %i5 return _Chain_Immutable_head( the_chain )->next; 40008454: f0 06 20 20 ld [ %i0 + 0x20 ], %i0 return &the_chain->Tail.Node; 40008458: b8 07 60 24 add %i5, 0x24, %i4 4000845c: b6 07 60 20 add %i5, 0x20, %i3 if ( !_Chain_Is_empty(the_chain)) 40008460: 80 a7 00 18 cmp %i4, %i0 40008464: 02 80 00 1e be 400084dc <_Objects_Allocate_unprotected+0x9c> 40008468: c4 0f 60 12 ldub [ %i5 + 0x12 ], %g2 new_first = old_first->next; 4000846c: c2 06 00 00 ld [ %i0 ], %g1 head->next = new_first; 40008470: 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 ) { 40008474: 80 88 a0 ff btst 0xff, %g2 40008478: 02 80 00 17 be 400084d4 <_Objects_Allocate_unprotected+0x94> 4000847c: f6 20 60 04 st %i3, [ %g1 + 4 ] } if ( the_object ) { uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 40008480: c2 06 20 08 ld [ %i0 + 8 ], %g1 40008484: c6 07 60 08 ld [ %i5 + 8 ], %g3 40008488: 05 00 00 3f sethi %hi(0xfc00), %g2 4000848c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40008490: 82 08 40 02 and %g1, %g2, %g1 40008494: 84 08 c0 02 and %g3, %g2, %g2 _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 40008498: c8 07 60 30 ld [ %i5 + 0x30 ], %g4 block = (uint32_t) _Objects_Get_index( the_object->id ) - 4000849c: 82 20 40 02 sub %g1, %g2, %g1 block /= information->allocation_size; 400084a0: c4 17 60 14 lduh [ %i5 + 0x14 ], %g2 400084a4: 81 80 20 00 wr %g0, %y 400084a8: 01 00 00 00 nop 400084ac: 01 00 00 00 nop 400084b0: 01 00 00 00 nop 400084b4: 84 70 40 02 udiv %g1, %g2, %g2 information->inactive_per_block[ block ]--; 400084b8: 83 28 a0 02 sll %g2, 2, %g1 400084bc: c6 01 00 01 ld [ %g4 + %g1 ], %g3 information->inactive--; 400084c0: c4 17 60 2c lduh [ %i5 + 0x2c ], %g2 information->inactive_per_block[ block ]--; 400084c4: 86 00 ff ff add %g3, -1, %g3 400084c8: c6 21 00 01 st %g3, [ %g4 + %g1 ] information->inactive--; 400084cc: 82 00 bf ff add %g2, -1, %g1 400084d0: c2 37 60 2c sth %g1, [ %i5 + 0x2c ] ); } #endif return the_object; } 400084d4: 81 c7 e0 08 ret 400084d8: 81 e8 00 00 restore if ( information->auto_extend ) { 400084dc: 80 88 a0 ff btst 0xff, %g2 400084e0: 02 80 00 0c be 40008510 <_Objects_Allocate_unprotected+0xd0> 400084e4: 01 00 00 00 nop _Objects_Extend_information( information ); 400084e8: 40 00 00 11 call 4000852c <_Objects_Extend_information> 400084ec: 90 10 00 1d mov %i5, %o0 return _Chain_Immutable_head( the_chain )->next; 400084f0: f0 07 60 20 ld [ %i5 + 0x20 ], %i0 if ( !_Chain_Is_empty(the_chain)) 400084f4: 80 a7 00 18 cmp %i4, %i0 400084f8: 02 80 00 06 be 40008510 <_Objects_Allocate_unprotected+0xd0> <== NEVER TAKEN 400084fc: 01 00 00 00 nop new_first = old_first->next; 40008500: c2 06 00 00 ld [ %i0 ], %g1 head->next = new_first; 40008504: c2 27 60 20 st %g1, [ %i5 + 0x20 ] new_first->previous = head; 40008508: 10 bf ff de b 40008480 <_Objects_Allocate_unprotected+0x40> 4000850c: f6 20 60 04 st %i3, [ %g1 + 4 ] return NULL; 40008510: 81 c7 e0 08 ret 40008514: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 4000d8a0 <_Objects_Do_initialize_information>: #if defined(RTEMS_MULTIPROCESSING) , Objects_Thread_queue_Extract_callout extract #endif ) { 4000d8a0: 9d e3 bf a0 save %sp, -96, %sp information->maximum = 0; /* * Register this Object Class in the Object Information Table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 4000d8a4: 05 10 00 41 sethi %hi(0x40010400), %g2 information->size = size; 4000d8a8: f8 26 20 18 st %i4, [ %i0 + 0x18 ] _Objects_Information_table[ the_api ][ the_class ] = information; 4000d8ac: 84 10 a3 d4 or %g2, 0x3d4, %g2 information->the_api = the_api; 4000d8b0: f2 26 00 00 st %i1, [ %i0 ] _Objects_Information_table[ the_api ][ the_class ] = information; 4000d8b4: b9 2e 60 02 sll %i1, 2, %i4 information->the_class = the_class; 4000d8b8: f4 36 20 04 sth %i2, [ %i0 + 4 ] _Objects_Information_table[ the_api ][ the_class ] = information; 4000d8bc: 89 2e a0 02 sll %i2, 2, %g4 information->local_table = 0; 4000d8c0: 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; 4000d8c4: 87 36 e0 1f srl %i3, 0x1f, %g3 information->inactive_per_block = 0; 4000d8c8: 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) { 4000d8cc: 83 2e e0 10 sll %i3, 0x10, %g1 information->object_blocks = 0; 4000d8d0: c0 26 20 34 clr [ %i0 + 0x34 ] if ( information->auto_extend && maximum_per_allocation == 0) { 4000d8d4: 80 a0 60 00 cmp %g1, 0 information->inactive = 0; 4000d8d8: c0 36 20 2c clrh [ %i0 + 0x2c ] information->is_string = is_string; 4000d8dc: fa 2e 20 38 stb %i5, [ %i0 + 0x38 ] information->maximum = 0; 4000d8e0: c0 36 20 10 clrh [ %i0 + 0x10 ] _Objects_Information_table[ the_api ][ the_class ] = information; 4000d8e4: c4 00 80 1c ld [ %g2 + %i4 ], %g2 4000d8e8: f0 20 80 04 st %i0, [ %g2 + %g4 ] information->auto_extend = _Objects_Is_unlimited( maximum ); 4000d8ec: c6 2e 20 12 stb %g3, [ %i0 + 0x12 ] if ( information->auto_extend && maximum_per_allocation == 0) { 4000d8f0: 12 80 00 05 bne 4000d904 <_Objects_Do_initialize_information+0x64> 4000d8f4: c8 07 a0 5c ld [ %fp + 0x5c ], %g4 4000d8f8: 80 a0 e0 00 cmp %g3, 0 4000d8fc: 12 80 00 1c bne 4000d96c <_Objects_Do_initialize_information+0xcc> <== NEVER TAKEN 4000d900: 01 00 00 00 nop (( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) | 4000d904: 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; 4000d908: 87 30 60 10 srl %g1, 0x10, %g3 4000d90c: 80 a0 00 03 cmp %g0, %g3 4000d910: 82 40 20 00 addx %g0, 0, %g1 4000d914: 82 10 40 02 or %g1, %g2, %g1 (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 4000d918: 85 2e a0 1b sll %i2, 0x1b, %g2 return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 4000d91c: b3 2e 60 18 sll %i1, 0x18, %i1 return &the_chain->Tail.Node; 4000d920: ba 06 20 20 add %i0, 0x20, %i5 (( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) | 4000d924: b4 10 40 19 or %g1, %i1, %i2 information->allocation_size = maximum_per_allocation; 4000d928: f6 36 20 14 sth %i3, [ %i0 + 0x14 ] 4000d92c: b4 16 80 02 or %i2, %g2, %i2 information->local_table = &null_local_table; 4000d930: 03 10 00 48 sethi %hi(0x40012000), %g1 4000d934: 84 06 20 24 add %i0, 0x24, %g2 4000d938: 82 10 60 0c or %g1, 0xc, %g1 information->minimum_id = 4000d93c: f4 26 20 08 st %i2, [ %i0 + 8 ] _Chain_Initialize_empty( &information->Inactive ); /* * Initialize objects .. if there are any */ if ( maximum_per_allocation ) { 4000d940: 80 a0 e0 00 cmp %g3, 0 information->local_table = &null_local_table; 4000d944: c2 26 20 1c st %g1, [ %i0 + 0x1c ] information->name_length = maximum_name_length; 4000d948: c8 36 20 3a sth %g4, [ %i0 + 0x3a ] head->next = tail; 4000d94c: c4 26 20 20 st %g2, [ %i0 + 0x20 ] head->previous = NULL; 4000d950: c0 26 20 24 clr [ %i0 + 0x24 ] if ( maximum_per_allocation ) { 4000d954: 12 80 00 04 bne 4000d964 <_Objects_Do_initialize_information+0xc4> 4000d958: 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 } 4000d95c: 81 c7 e0 08 ret 4000d960: 81 e8 00 00 restore _Objects_Extend_information( information ); 4000d964: 7f ff ea f2 call 4000852c <_Objects_Extend_information> 4000d968: 81 e8 00 00 restore _Internal_error( INTERNAL_ERROR_UNLIMITED_AND_MAXIMUM_IS_0 ); 4000d96c: 7f ff e5 7f call 40006f68 <_Internal_error> <== NOT EXECUTED 4000d970: 90 10 20 13 mov 0x13, %o0 <== NOT EXECUTED 4000d974: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 4000852c <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 4000852c: 9d e3 bf a0 save %sp, -96, %sp minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) 40008530: c4 06 20 34 ld [ %i0 + 0x34 ], %g2 40008534: e2 16 20 14 lduh [ %i0 + 0x14 ], %l1 40008538: e4 16 20 0a lduh [ %i0 + 0xa ], %l2 4000853c: e0 16 20 10 lduh [ %i0 + 0x10 ], %l0 40008540: 80 a0 a0 00 cmp %g2, 0 40008544: 02 80 00 95 be 40008798 <_Objects_Extend_information+0x26c> 40008548: b6 10 00 11 mov %l1, %i3 block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 4000854c: 81 80 20 00 wr %g0, %y 40008550: 01 00 00 00 nop 40008554: 01 00 00 00 nop 40008558: 01 00 00 00 nop 4000855c: b2 f4 00 11 udivcc %l0, %l1, %i1 40008560: 02 80 00 b1 be 40008824 <_Objects_Extend_information+0x2f8> <== NEVER TAKEN 40008564: b5 2c 20 10 sll %l0, 0x10, %i2 if ( information->object_blocks[ block ] == NULL ) { 40008568: c2 00 80 00 ld [ %g2 ], %g1 4000856c: 80 a0 60 00 cmp %g1, 0 40008570: 02 80 00 b1 be 40008834 <_Objects_Extend_information+0x308> <== NEVER TAKEN 40008574: ba 10 00 12 mov %l2, %i5 block = 0; 40008578: 10 80 00 06 b 40008590 <_Objects_Extend_information+0x64> 4000857c: b8 10 20 00 clr %i4 if ( information->object_blocks[ block ] == NULL ) { 40008580: c2 00 80 01 ld [ %g2 + %g1 ], %g1 40008584: 80 a0 60 00 cmp %g1, 0 40008588: 02 80 00 08 be 400085a8 <_Objects_Extend_information+0x7c> 4000858c: a8 10 20 00 clr %l4 for ( ; block < block_count; block++ ) { 40008590: b8 07 20 01 inc %i4 do_extend = false; break; } else index_base += information->allocation_size; 40008594: ba 07 40 1b add %i5, %i3, %i5 for ( ; block < block_count; block++ ) { 40008598: 80 a6 40 1c cmp %i1, %i4 4000859c: 12 bf ff f9 bne 40008580 <_Objects_Extend_information+0x54> 400085a0: 83 2f 20 02 sll %i4, 2, %g1 do_extend = true; 400085a4: a8 10 20 01 mov 1, %l4 } } index_end = index_base + information->allocation_size; maximum = (uint32_t) information->maximum + information->allocation_size; 400085a8: 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 ) { 400085ac: 03 00 00 3f sethi %hi(0xfc00), %g1 maximum = (uint32_t) information->maximum + information->allocation_size; 400085b0: b4 06 80 1b add %i2, %i3, %i2 if ( maximum > OBJECTS_ID_FINAL_INDEX ) { 400085b4: 82 10 63 ff or %g1, 0x3ff, %g1 400085b8: 80 a6 80 01 cmp %i2, %g1 400085bc: 18 80 00 88 bgu 400087dc <_Objects_Extend_information+0x2b0> <== NEVER TAKEN 400085c0: 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; 400085c4: d0 06 20 18 ld [ %i0 + 0x18 ], %o0 if ( information->auto_extend ) { 400085c8: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1 400085cc: 80 a0 60 00 cmp %g1, 0 400085d0: 02 80 00 78 be 400087b0 <_Objects_Extend_information+0x284> 400085d4: 90 5e c0 08 smul %i3, %o0, %o0 new_object_block = _Workspace_Allocate( block_size ); 400085d8: 40 00 0e 90 call 4000c018 <_Workspace_Allocate> 400085dc: 01 00 00 00 nop if ( !new_object_block ) 400085e0: a6 92 20 00 orcc %o0, 0, %l3 400085e4: 02 80 00 6b be 40008790 <_Objects_Extend_information+0x264> <== NEVER TAKEN 400085e8: b6 07 40 1b add %i5, %i3, %i3 } /* * Do we need to grow the tables? */ if ( do_extend ) { 400085ec: 80 8d 20 ff btst 0xff, %l4 400085f0: 22 80 00 45 be,a 40008704 <_Objects_Extend_information+0x1d8> 400085f4: 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 ) { 400085f8: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1 block_count++; 400085fc: b2 06 60 01 inc %i1 ((maximum + minimum_index) * sizeof(Objects_Control *)); 40008600: 90 04 80 1a add %l2, %i2, %o0 if ( information->auto_extend ) { 40008604: 80 a0 60 00 cmp %g1, 0 (void*)(block_count * sizeof(void*)), 40008608: b5 2e 60 02 sll %i1, 2, %i2 ((maximum + minimum_index) * sizeof(Objects_Control *)); 4000860c: 91 2a 20 02 sll %o0, 2, %o0 return (void*)(((uintptr_t)address + mask) & ~mask); 40008610: b2 06 a0 07 add %i2, 7, %i1 40008614: b2 0e 7f f8 and %i1, -8, %i1 block_size = object_blocks_size + inactive_per_block_size + 40008618: 83 2e 60 01 sll %i1, 1, %g1 if ( information->auto_extend ) { 4000861c: 12 80 00 69 bne 400087c0 <_Objects_Extend_information+0x294> 40008620: 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 ); 40008624: 40 00 0e 93 call 4000c070 <_Workspace_Allocate_or_fatal_error> 40008628: 01 00 00 00 nop 4000862c: 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 ) { 40008630: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 return (void *)((uintptr_t)base + offset); 40008634: a8 05 40 19 add %l5, %i1, %l4 40008638: b4 06 bf fc add %i2, -4, %i2 4000863c: 80 a0 40 12 cmp %g1, %l2 40008640: 18 80 00 69 bgu 400087e4 <_Objects_Extend_information+0x2b8> 40008644: 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++ ) { 40008648: 80 a4 a0 00 cmp %l2, 0 4000864c: 22 80 00 0b be,a 40008678 <_Objects_Extend_information+0x14c> <== NEVER TAKEN 40008650: c0 25 40 1a clr [ %l5 + %i2 ] <== NOT EXECUTED 40008654: a5 2c a0 02 sll %l2, 2, %l2 40008658: 82 10 00 19 mov %i1, %g1 4000865c: a4 04 80 19 add %l2, %i1, %l2 local_table[ index ] = NULL; 40008660: c0 20 40 00 clr [ %g1 ] 40008664: 82 00 60 04 add %g1, 4, %g1 for ( index = 0; index < minimum_index; index++ ) { 40008668: 80 a4 80 01 cmp %l2, %g1 4000866c: 32 bf ff fe bne,a 40008664 <_Objects_Extend_information+0x138> <== NEVER TAKEN 40008670: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED } /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 40008674: c0 25 40 1a clr [ %l5 + %i2 ] inactive_per_block[block_count] = 0; for ( index = index_base ; index < index_end ; ++index ) { 40008678: 80 a7 40 1b cmp %i5, %i3 4000867c: 1a 80 00 0b bcc 400086a8 <_Objects_Extend_information+0x17c> <== NEVER TAKEN 40008680: c0 25 00 1a clr [ %l4 + %i2 ] 40008684: 83 2f 60 02 sll %i5, 2, %g1 40008688: 85 2e e0 02 sll %i3, 2, %g2 4000868c: 82 00 40 19 add %g1, %i1, %g1 40008690: 84 00 80 19 add %g2, %i1, %g2 local_table[ index ] = NULL; 40008694: c0 20 40 00 clr [ %g1 ] 40008698: 82 00 60 04 add %g1, 4, %g1 for ( index = index_base ; index < index_end ; ++index ) { 4000869c: 80 a0 80 01 cmp %g2, %g1 400086a0: 32 bf ff fe bne,a 40008698 <_Objects_Extend_information+0x16c> 400086a4: c0 20 40 00 clr [ %g1 ] __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400086a8: 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) | 400086ac: 07 00 00 40 sethi %hi(0x10000), %g3 <== NOT EXECUTED return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 400086b0: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 400086b4: c8 16 20 04 lduh [ %i0 + 4 ], %g4 <== NOT EXECUTED 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; 400086b8: a0 04 00 11 add %l0, %l1, %l0 <== NOT EXECUTED old_tables = information->object_blocks; 400086bc: d0 06 20 34 ld [ %i0 + 0x34 ], %o0 <== NOT EXECUTED 400086c0: 89 29 20 1b sll %g4, 0x1b, %g4 <== NOT EXECUTED return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 400086c4: 85 28 a0 18 sll %g2, 0x18, %g2 <== NOT EXECUTED information->object_blocks = object_blocks; 400086c8: ea 26 20 34 st %l5, [ %i0 + 0x34 ] <== NOT EXECUTED (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 400086cc: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED information->inactive_per_block = inactive_per_block; 400086d0: e8 26 20 30 st %l4, [ %i0 + 0x30 ] <== NOT EXECUTED #if !defined(RTEMS_USE_16_BIT_OBJECT) (( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) | 400086d4: 87 2c 20 10 sll %l0, 0x10, %g3 <== NOT EXECUTED (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 400086d8: 84 10 80 04 or %g2, %g4, %g2 <== NOT EXECUTED (( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) | 400086dc: 87 30 e0 10 srl %g3, 0x10, %g3 <== NOT EXECUTED information->local_table = local_table; 400086e0: f2 26 20 1c st %i1, [ %i0 + 0x1c ] <== NOT EXECUTED 400086e4: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED information->maximum = (Objects_Maximum) maximum; 400086e8: e0 36 20 10 sth %l0, [ %i0 + 0x10 ] <== NOT EXECUTED information->maximum_id = _Objects_Build_id( 400086ec: c4 26 20 0c st %g2, [ %i0 + 0xc ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400086f0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400086f4: 01 00 00 00 nop information->maximum ); _ISR_lock_ISR_enable( &lock_context ); _Workspace_Free( old_tables ); 400086f8: 40 00 0e 58 call 4000c058 <_Workspace_Free> 400086fc: 01 00 00 00 nop } /* * Assign the new object block to the object block table. */ information->object_blocks[ block ] = new_object_block; 40008700: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 40008704: b9 2f 20 02 sll %i4, 2, %i4 40008708: 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 ) { 4000870c: 80 a7 40 1b cmp %i5, %i3 the_object = information->object_blocks[ block ]; 40008710: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 for ( index = index_base ; index < index_end ; ++index ) { 40008714: 1a 80 00 19 bcc 40008778 <_Objects_Extend_information+0x24c> <== NEVER TAKEN 40008718: c2 00 40 1c ld [ %g1 + %i4 ], %g1 return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 4000871c: c8 06 00 00 ld [ %i0 ], %g4 (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 40008720: 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 ); 40008724: de 06 20 18 ld [ %i0 + 0x18 ], %o7 return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 40008728: 89 29 20 18 sll %g4, 0x18, %g4 (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 4000872c: 85 28 a0 1b sll %g2, 0x1b, %g2 40008730: 07 00 00 40 sethi %hi(0x10000), %g3 (( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) | 40008734: 35 00 00 3f sethi %hi(0xfc00), %i2 (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 40008738: 88 11 00 03 or %g4, %g3, %g4 4000873c: b2 06 20 24 add %i0, 0x24, %i1 40008740: 88 11 00 02 or %g4, %g2, %g4 (( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) | 40008744: b4 16 a3 ff or %i2, 0x3ff, %i2 old_last = tail->previous; 40008748: c6 06 20 28 ld [ %i0 + 0x28 ], %g3 4000874c: 84 0f 40 1a and %i5, %i2, %g2 the_node->next = tail; 40008750: f2 20 40 00 st %i1, [ %g1 ] 40008754: 84 10 80 04 or %g2, %g4, %g2 the_object->id = _Objects_Build_id( 40008758: c4 20 60 08 st %g2, [ %g1 + 8 ] for ( index = index_base ; index < index_end ; ++index ) { 4000875c: ba 07 60 01 inc %i5 tail->previous = the_node; 40008760: c2 26 20 28 st %g1, [ %i0 + 0x28 ] 40008764: 80 a6 c0 1d cmp %i3, %i5 old_last->next = the_node; 40008768: c2 20 c0 00 st %g1, [ %g3 ] the_node->previous = old_last; 4000876c: c6 20 60 04 st %g3, [ %g1 + 4 ] 40008770: 12 bf ff f6 bne 40008748 <_Objects_Extend_information+0x21c> 40008774: 82 00 40 0f add %g1, %o7, %g1 } information->inactive_per_block[ block ] = information->allocation_size; 40008778: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2 4000877c: c6 06 20 30 ld [ %i0 + 0x30 ], %g3 information->inactive = (Objects_Maximum)(information->inactive + information->allocation_size); 40008780: c2 16 20 2c lduh [ %i0 + 0x2c ], %g1 information->inactive_per_block[ block ] = information->allocation_size; 40008784: c4 20 c0 1c st %g2, [ %g3 + %i4 ] (Objects_Maximum)(information->inactive + information->allocation_size); 40008788: 82 00 40 02 add %g1, %g2, %g1 information->inactive = 4000878c: c2 36 20 2c sth %g1, [ %i0 + 0x2c ] } 40008790: 81 c7 e0 08 ret 40008794: 81 e8 00 00 restore 40008798: ba 10 00 12 mov %l2, %i5 do_extend = true; 4000879c: a8 10 20 01 mov 1, %l4 block = 0; 400087a0: b8 10 20 00 clr %i4 block_count = 0; 400087a4: b2 10 20 00 clr %i1 400087a8: 10 bf ff 80 b 400085a8 <_Objects_Extend_information+0x7c> 400087ac: b5 2c 20 10 sll %l0, 0x10, %i2 new_object_block = _Workspace_Allocate_or_fatal_error( block_size ); 400087b0: 40 00 0e 30 call 4000c070 <_Workspace_Allocate_or_fatal_error> 400087b4: b6 07 40 1b add %i5, %i3, %i3 400087b8: 10 bf ff 8d b 400085ec <_Objects_Extend_information+0xc0> 400087bc: a6 10 00 08 mov %o0, %l3 object_blocks = _Workspace_Allocate( block_size ); 400087c0: 40 00 0e 16 call 4000c018 <_Workspace_Allocate> 400087c4: 01 00 00 00 nop if ( !object_blocks ) { 400087c8: aa 92 20 00 orcc %o0, 0, %l5 400087cc: 32 bf ff 9a bne,a 40008634 <_Objects_Extend_information+0x108> <== ALWAYS TAKEN 400087d0: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 _Workspace_Free( new_object_block ); 400087d4: 40 00 0e 21 call 4000c058 <_Workspace_Free> <== NOT EXECUTED 400087d8: 91 e8 00 13 restore %g0, %l3, %o0 <== NOT EXECUTED 400087dc: 81 c7 e0 08 ret <== NOT EXECUTED 400087e0: 81 e8 00 00 restore <== NOT EXECUTED memcpy( object_blocks, 400087e4: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 400087e8: 94 10 00 1a mov %i2, %o2 400087ec: 40 00 17 45 call 4000e500 400087f0: 90 10 00 15 mov %l5, %o0 memcpy( inactive_per_block, 400087f4: d2 06 20 30 ld [ %i0 + 0x30 ], %o1 400087f8: 94 10 00 1a mov %i2, %o2 400087fc: 40 00 17 41 call 4000e500 40008800: 90 10 00 14 mov %l4, %o0 (information->maximum + minimum_index) * sizeof(Objects_Control *) ); 40008804: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2 memcpy( local_table, 40008808: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 (information->maximum + minimum_index) * sizeof(Objects_Control *) ); 4000880c: 94 02 80 12 add %o2, %l2, %o2 memcpy( local_table, 40008810: 90 10 00 19 mov %i1, %o0 40008814: 40 00 17 3b call 4000e500 40008818: 95 2a a0 02 sll %o2, 2, %o2 4000881c: 10 bf ff 97 b 40008678 <_Objects_Extend_information+0x14c> 40008820: c0 25 40 1a clr [ %l5 + %i2 ] for ( ; block < block_count; block++ ) { 40008824: ba 10 00 12 mov %l2, %i5 <== NOT EXECUTED do_extend = true; 40008828: a8 10 20 01 mov 1, %l4 <== NOT EXECUTED block = 0; 4000882c: 10 bf ff 5f b 400085a8 <_Objects_Extend_information+0x7c> <== NOT EXECUTED 40008830: b8 10 20 00 clr %i4 <== NOT EXECUTED do_extend = false; 40008834: a8 10 20 00 clr %l4 <== NOT EXECUTED block = 0; 40008838: 10 bf ff 5c b 400085a8 <_Objects_Extend_information+0x7c> <== NOT EXECUTED 4000883c: b8 10 20 00 clr %i4 <== NOT EXECUTED =============================================================================== 4000d840 <_Objects_Get>: const Objects_Information *information ) { uint32_t index; index = id - information->minimum_id + 1; 4000d840: c4 02 a0 08 ld [ %o2 + 8 ], %g2 if ( information->maximum >= index ) { 4000d844: c2 12 a0 10 lduh [ %o2 + 0x10 ], %g1 index = id - information->minimum_id + 1; 4000d848: 90 02 20 01 inc %o0 4000d84c: 90 22 00 02 sub %o0, %g2, %o0 if ( information->maximum >= index ) { 4000d850: 80 a0 40 08 cmp %g1, %o0 4000d854: 0a 80 00 0c bcs 4000d884 <_Objects_Get+0x44> <== NEVER TAKEN 4000d858: 01 00 00 00 nop <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000d85c: 91 d0 20 09 ta 9 <== NOT EXECUTED Objects_Control *the_object; _ISR_lock_ISR_disable( lock_context ); 4000d860: c2 22 40 00 st %g1, [ %o1 ] the_object = information->local_table[ index ]; 4000d864: c2 02 a0 1c ld [ %o2 + 0x1c ], %g1 4000d868: 91 2a 20 02 sll %o0, 2, %o0 4000d86c: d0 00 40 08 ld [ %g1 + %o0 ], %o0 if ( the_object != NULL ) { 4000d870: 80 a2 20 00 cmp %o0, 0 4000d874: 02 80 00 06 be 4000d88c <_Objects_Get+0x4c> <== NEVER TAKEN 4000d878: 01 00 00 00 nop _ISR_lock_ISR_enable( lock_context ); } return NULL; } 4000d87c: 81 c3 e0 08 retl 4000d880: 01 00 00 00 nop 4000d884: 81 c3 e0 08 retl <== NOT EXECUTED 4000d888: 90 10 20 00 clr %o0 ! 0 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000d88c: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000d890: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000d894: 01 00 00 00 nop <== NOT EXECUTED 4000d898: 81 c3 e0 08 retl <== NOT EXECUTED 4000d89c: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 4000d7cc <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 4000d7cc: 9d e3 bf a0 save %sp, -96, %sp Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 4000d7d0: 80 a6 60 00 cmp %i1, 0 4000d7d4: 02 80 00 19 be 4000d838 <_Objects_Get_information+0x6c> <== NEVER TAKEN 4000d7d8: 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 ); 4000d7dc: 40 00 02 bb call 4000e2c8 <_Objects_API_maximum_class> 4000d7e0: 90 10 00 18 mov %i0, %o0 if ( the_class_api_maximum == 0 ) 4000d7e4: 80 a2 20 00 cmp %o0, 0 4000d7e8: 02 80 00 14 be 4000d838 <_Objects_Get_information+0x6c> <== NEVER TAKEN 4000d7ec: 80 a2 00 19 cmp %o0, %i1 return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 4000d7f0: 0a 80 00 12 bcs 4000d838 <_Objects_Get_information+0x6c> <== NEVER TAKEN 4000d7f4: 03 10 00 41 sethi %hi(0x40010400), %g1 return NULL; if ( !_Objects_Information_table[ the_api ] ) 4000d7f8: b1 2e 20 02 sll %i0, 2, %i0 4000d7fc: 82 10 63 d4 or %g1, 0x3d4, %g1 4000d800: c2 00 40 18 ld [ %g1 + %i0 ], %g1 4000d804: 80 a0 60 00 cmp %g1, 0 4000d808: 02 80 00 0c be 4000d838 <_Objects_Get_information+0x6c> <== NEVER TAKEN 4000d80c: b3 2e 60 02 sll %i1, 2, %i1 return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 4000d810: f0 00 40 19 ld [ %g1 + %i1 ], %i0 if ( !info ) 4000d814: 80 a6 20 00 cmp %i0, 0 4000d818: 02 80 00 08 be 4000d838 <_Objects_Get_information+0x6c> <== NEVER TAKEN 4000d81c: 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 ) 4000d820: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 4000d824: 80 a0 60 00 cmp %g1, 0 4000d828: 02 80 00 04 be 4000d838 <_Objects_Get_information+0x6c> <== NEVER TAKEN 4000d82c: 01 00 00 00 nop return NULL; #endif return info; } 4000d830: 81 c7 e0 08 ret 4000d834: 81 e8 00 00 restore return NULL; 4000d838: 81 c7 e0 08 ret <== NOT EXECUTED 4000d83c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED =============================================================================== 4001a378 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 4001a378: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Objects_Id tmpId; if ( length == 0 ) return NULL; if ( name == NULL ) 4001a37c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4001a380: 02 80 00 1e be 4001a3f8 <_Objects_Get_name_as_string+0x80> <== NOT EXECUTED 4001a384: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 4001a388: 02 80 00 1c be 4001a3f8 <_Objects_Get_name_as_string+0x80> <== NOT EXECUTED 4001a38c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id; 4001a390: 22 80 00 18 be,a 4001a3f0 <_Objects_Get_name_as_string+0x78> <== NOT EXECUTED 4001a394: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1 <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 4001a398: 7f ff dc e9 call 4001173c <_Objects_Get_information_id> <== NOT EXECUTED 4001a39c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !information ) 4001a3a0: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED 4001a3a4: 02 80 00 15 be 4001a3f8 <_Objects_Get_name_as_string+0x80> <== NOT EXECUTED 4001a3a8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED return NULL; the_object = _Objects_Get( tmpId, &lock_context, information ); 4001a3ac: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED 4001a3b0: 7f ff dc e9 call 40011754 <_Objects_Get> <== NOT EXECUTED 4001a3b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( the_object == NULL ) { 4001a3b8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001a3bc: 02 80 00 0f be 4001a3f8 <_Objects_Get_name_as_string+0x80> <== NOT EXECUTED 4001a3c0: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED return NULL; } _Objects_Name_to_string( 4001a3c4: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED 4001a3c8: d2 0f 60 38 ldub [ %i5 + 0x38 ], %o1 <== NOT EXECUTED 4001a3cc: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED 4001a3d0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 4001a3d4: 7f ff ff b5 call 4001a2a8 <_Objects_Name_to_string> <== NOT EXECUTED 4001a3d8: 90 07 bf f4 add %fp, -12, %o0 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4001a3dc: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4001a3e0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4001a3e4: 01 00 00 00 nop <== NOT EXECUTED length ); _ISR_lock_ISR_enable( &lock_context ); return name; } 4001a3e8: 81 c7 e0 08 ret <== NOT EXECUTED 4001a3ec: 91 e8 00 1a restore %g0, %i2, %o0 <== NOT EXECUTED 4001a3f0: 10 bf ff ea b 4001a398 <_Objects_Get_name_as_string+0x20> <== NOT EXECUTED 4001a3f4: f0 00 60 08 ld [ %g1 + 8 ], %i0 <== NOT EXECUTED return NULL; 4001a3f8: 81 c7 e0 08 ret <== NOT EXECUTED 4001a3fc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED =============================================================================== 4001b8d4 <_Objects_Get_next>: Objects_Control *_Objects_Get_next( Objects_Id id, const Objects_Information *information, Objects_Id *next_id_p ) { 4001b8d4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED Objects_Id next_id; if ( !information ) return NULL; if ( !next_id_p ) 4001b8d8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4001b8dc: 02 80 00 20 be 4001b95c <_Objects_Get_next+0x88> <== NOT EXECUTED 4001b8e0: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 4001b8e4: 02 80 00 1e be 4001b95c <_Objects_Get_next+0x88> <== NOT EXECUTED 4001b8e8: 83 2e 20 10 sll %i0, 0x10, %g1 <== NOT EXECUTED return NULL; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) 4001b8ec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001b8f0: 22 80 00 02 be,a 4001b8f8 <_Objects_Get_next+0x24> <== NOT EXECUTED 4001b8f4: f0 06 60 08 ld [ %i1 + 8 ], %i0 <== NOT EXECUTED 4001b8f8: 7f ff ce 46 call 4000f210 <_RTEMS_Lock_allocator> <== NOT EXECUTED 4001b8fc: 01 00 00 00 nop <== NOT EXECUTED _Objects_Allocator_lock(); do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 4001b900: 10 80 00 08 b 4001b920 <_Objects_Get_next+0x4c> <== NOT EXECUTED 4001b904: c4 16 60 10 lduh [ %i1 + 0x10 ], %g2 <== NOT EXECUTED *next_id_p = OBJECTS_ID_FINAL; return NULL; } /* try to grab one */ the_object = _Objects_Get_no_protection( next_id, information ); 4001b908: 7f ff d7 ab call 400117b4 <_Objects_Get_no_protection> <== NOT EXECUTED 4001b90c: b0 06 20 01 inc %i0 <== NOT EXECUTED next_id++; } while ( the_object == NULL ); 4001b910: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001b914: 32 80 00 10 bne,a 4001b954 <_Objects_Get_next+0x80> <== NOT EXECUTED 4001b918: f0 26 80 00 st %i0, [ %i2 ] <== NOT EXECUTED if (_Objects_Get_index(next_id) > information->maximum) 4001b91c: c4 16 60 10 lduh [ %i1 + 0x10 ], %g2 <== NOT EXECUTED 4001b920: 83 2e 20 10 sll %i0, 0x10, %g1 <== NOT EXECUTED the_object = _Objects_Get_no_protection( next_id, information ); 4001b924: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (_Objects_Get_index(next_id) > information->maximum) 4001b928: 83 30 60 10 srl %g1, 0x10, %g1 <== NOT EXECUTED 4001b92c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 4001b930: 1a bf ff f6 bcc 4001b908 <_Objects_Get_next+0x34> <== NOT EXECUTED 4001b934: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED _RTEMS_Unlock_allocator(); 4001b938: 7f ff ce 3b call 4000f224 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 4001b93c: 01 00 00 00 nop <== NOT EXECUTED *next_id_p = OBJECTS_ID_FINAL; 4001b940: 82 10 3f ff mov -1, %g1 ! ffffffff <== NOT EXECUTED 4001b944: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED return NULL; 4001b948: 90 10 20 00 clr %o0 <== NOT EXECUTED *next_id_p = next_id; return the_object; } 4001b94c: 81 c7 e0 08 ret <== NOT EXECUTED 4001b950: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 4001b954: 81 c7 e0 08 ret <== NOT EXECUTED 4001b958: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return NULL; 4001b95c: 10 bf ff fc b 4001b94c <_Objects_Get_next+0x78> <== NOT EXECUTED 4001b960: 90 10 20 00 clr %o0 <== NOT EXECUTED =============================================================================== 40008908 <_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; 40008908: c4 02 60 08 ld [ %o1 + 8 ], %g2 <== NOT EXECUTED if ( information->maximum >= index ) { 4000890c: c2 12 60 10 lduh [ %o1 + 0x10 ], %g1 <== NOT EXECUTED index = id - information->minimum_id + 1; 40008910: 90 02 20 01 inc %o0 <== NOT EXECUTED 40008914: 90 22 00 02 sub %o0, %g2, %o0 <== NOT EXECUTED if ( information->maximum >= index ) { 40008918: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED 4000891c: 0a 80 00 06 bcs 40008934 <_Objects_Get_no_protection+0x2c> <== NOT EXECUTED 40008920: 01 00 00 00 nop <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { 40008924: c2 02 60 1c ld [ %o1 + 0x1c ], %g1 <== NOT EXECUTED 40008928: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED 4000892c: 81 c3 e0 08 retl <== NOT EXECUTED 40008930: d0 00 40 08 ld [ %g1 + %o0 ], %o0 <== NOT EXECUTED /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ return NULL; } 40008934: 81 c3 e0 08 retl <== NOT EXECUTED 40008938: 90 10 20 00 clr %o0 <== NOT EXECUTED =============================================================================== 400117e8 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 400117e8: 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; 400117ec: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 400117f0: 12 80 00 04 bne 40011800 <_Objects_Id_to_name+0x18> <== NOT EXECUTED 400117f4: 01 00 00 00 nop <== NOT EXECUTED 400117f8: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1 <== NOT EXECUTED 400117fc: f0 00 60 08 ld [ %g1 + 8 ], %i0 <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 40011800: 7f ff ff cf call 4001173c <_Objects_Get_information_id> <== NOT EXECUTED 40011804: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !information ) 40011808: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001180c: 02 80 00 13 be 40011858 <_Objects_Id_to_name+0x70> <== NOT EXECUTED 40011810: 01 00 00 00 nop <== NOT EXECUTED return OBJECTS_INVALID_ID; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) 40011814: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1 <== NOT EXECUTED 40011818: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001181c: 12 80 00 0f bne 40011858 <_Objects_Id_to_name+0x70> <== NOT EXECUTED 40011820: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED return OBJECTS_INVALID_ID; #endif the_object = _Objects_Get( 40011824: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED 40011828: 7f ff ff cb call 40011754 <_Objects_Get> <== NOT EXECUTED 4001182c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED tmpId, &lock_context, information ); if ( !the_object ) 40011830: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40011834: 02 80 00 09 be 40011858 <_Objects_Id_to_name+0x70> <== NOT EXECUTED 40011838: 01 00 00 00 nop <== NOT EXECUTED return OBJECTS_INVALID_ID; *name = the_object->name; 4001183c: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED 40011840: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40011844: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40011848: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4001184c: 01 00 00 00 nop <== NOT EXECUTED _ISR_lock_ISR_enable( &lock_context ); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 40011850: 81 c7 e0 08 ret <== NOT EXECUTED 40011854: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED return OBJECTS_INVALID_ID; 40011858: 81 c7 e0 08 ret <== NOT EXECUTED 4001185c: 91 e8 20 03 restore %g0, 3, %o0 <== NOT EXECUTED =============================================================================== 4000893c <_Objects_Name_to_id_u32>: Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == false */ if ( !id ) 4000893c: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED 40008940: 02 80 00 21 be 400089c4 <_Objects_Name_to_id_u32+0x88> <== NOT EXECUTED 40008944: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 40008948: 02 80 00 1d be 400089bc <_Objects_Name_to_id_u32+0x80> <== NOT EXECUTED 4000894c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED search_local_node = false; if ( information->maximum != 0 && (node == OBJECTS_SEARCH_ALL_NODES || node == OBJECTS_SEARCH_LOCAL_NODE || 40008950: 05 20 00 00 sethi %hi(0x80000000), %g2 <== NOT EXECUTED 40008954: 84 38 80 0a xnor %g2, %o2, %g2 <== NOT EXECUTED 40008958: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000895c: 02 80 00 05 be 40008970 <_Objects_Name_to_id_u32+0x34> <== NOT EXECUTED 40008960: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 <== NOT EXECUTED 40008964: 80 a2 a0 01 cmp %o2, 1 <== NOT EXECUTED 40008968: 18 80 00 15 bgu 400089bc <_Objects_Name_to_id_u32+0x80> <== NOT EXECUTED 4000896c: 01 00 00 00 nop <== NOT EXECUTED _Objects_Is_local_node( node ) )) search_local_node = true; if ( search_local_node ) { for ( index = 1; index <= information->maximum; index++ ) { 40008970: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40008974: 02 80 00 11 be 400089b8 <_Objects_Name_to_id_u32+0x7c> <== NOT EXECUTED 40008978: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_object = information->local_table[ index ]; 4000897c: da 02 20 1c ld [ %o0 + 0x1c ], %o5 <== NOT EXECUTED 40008980: 86 00 e0 01 inc %g3 <== NOT EXECUTED 40008984: 85 28 60 02 sll %g1, 2, %g2 <== NOT EXECUTED 40008988: c4 03 40 02 ld [ %o5 + %g2 ], %g2 <== NOT EXECUTED if ( !the_object ) 4000898c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40008990: 22 80 00 07 be,a 400089ac <_Objects_Name_to_id_u32+0x70> <== NOT EXECUTED 40008994: 82 00 60 01 inc %g1 <== NOT EXECUTED continue; if ( name == the_object->name.name_u32 ) { 40008998: c8 00 a0 0c ld [ %g2 + 0xc ], %g4 <== NOT EXECUTED 4000899c: 80 a1 00 09 cmp %g4, %o1 <== NOT EXECUTED 400089a0: 22 80 00 0c be,a 400089d0 <_Objects_Name_to_id_u32+0x94> <== NOT EXECUTED 400089a4: c2 00 a0 08 ld [ %g2 + 8 ], %g1 <== NOT EXECUTED for ( index = 1; index <= information->maximum; index++ ) { 400089a8: 82 00 60 01 inc %g1 <== NOT EXECUTED 400089ac: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 400089b0: 32 bf ff f6 bne,a 40008988 <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED 400089b4: 85 28 60 02 sll %g1, 2, %g2 <== NOT EXECUTED return OBJECTS_INVALID_NAME; 400089b8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 400089bc: 81 c3 e0 08 retl <== NOT EXECUTED 400089c0: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED return OBJECTS_INVALID_ADDRESS; 400089c4: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED } 400089c8: 81 c3 e0 08 retl <== NOT EXECUTED 400089cc: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED *id = the_object->id; 400089d0: c2 22 c0 00 st %g1, [ %o3 ] <== NOT EXECUTED return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 400089d4: 10 bf ff fa b 400089bc <_Objects_Name_to_id_u32+0x80> <== NOT EXECUTED 400089d8: 82 10 20 00 clr %g1 <== NOT EXECUTED =============================================================================== 4001a2a8 <_Objects_Name_to_string>: Objects_Name name, bool is_string, char *buffer, size_t buffer_size ) { 4001a2a8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED const char *s; char *d; size_t i; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( is_string ) { 4001a2ac: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4001a2b0: 12 80 00 2d bne 4001a364 <_Objects_Name_to_string+0xbc> <== NOT EXECUTED 4001a2b4: fa 06 00 00 ld [ %i0 ], %i5 <== NOT EXECUTED s = name.name_p; } else #endif { lname[ 0 ] = (name.name_u32 >> 24) & 0xff; 4001a2b8: 83 37 60 18 srl %i5, 0x18, %g1 <== NOT EXECUTED lname[ 1 ] = (name.name_u32 >> 16) & 0xff; 4001a2bc: 87 37 60 10 srl %i5, 0x10, %g3 <== NOT EXECUTED lname[ 2 ] = (name.name_u32 >> 8) & 0xff; 4001a2c0: 85 37 60 08 srl %i5, 8, %g2 <== NOT EXECUTED lname[ 0 ] = (name.name_u32 >> 24) & 0xff; 4001a2c4: c2 2f bf f8 stb %g1, [ %fp + -8 ] <== NOT EXECUTED lname[ 1 ] = (name.name_u32 >> 16) & 0xff; 4001a2c8: c6 2f bf f9 stb %g3, [ %fp + -7 ] <== NOT EXECUTED lname[ 2 ] = (name.name_u32 >> 8) & 0xff; 4001a2cc: c4 2f bf fa stb %g2, [ %fp + -6 ] <== NOT EXECUTED lname[ 3 ] = (name.name_u32 >> 0) & 0xff; lname[ 4 ] = '\0'; 4001a2d0: c0 2f bf fc clrb [ %fp + -4 ] <== NOT EXECUTED lname[ 3 ] = (name.name_u32 >> 0) & 0xff; 4001a2d4: fa 2f bf fb stb %i5, [ %fp + -5 ] <== NOT EXECUTED s = lname; 4001a2d8: ba 07 bf f8 add %fp, -8, %i5 <== NOT EXECUTED d = buffer; i = 1; if ( s != NULL ) { while ( *s != '\0' ) { 4001a2dc: 83 28 60 18 sll %g1, 0x18, %g1 <== NOT EXECUTED 4001a2e0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001a2e4: 12 80 00 09 bne 4001a308 <_Objects_Name_to_string+0x60> <== NOT EXECUTED 4001a2e8: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED if ( i < buffer_size ) { *d = isprint((unsigned char) *s) ? *s : '*'; 4001a2ec: 10 80 00 19 b 4001a350 <_Objects_Name_to_string+0xa8> <== NOT EXECUTED 4001a2f0: b0 10 20 00 clr %i0 <== NOT EXECUTED while ( *s != '\0' ) { 4001a2f4: c2 4f 40 00 ldsb [ %i5 ], %g1 <== NOT EXECUTED 4001a2f8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001a2fc: 02 80 00 15 be 4001a350 <_Objects_Name_to_string+0xa8> <== NOT EXECUTED 4001a300: 84 06 20 01 add %i0, 1, %g2 <== NOT EXECUTED ++d; } ++s; ++i; 4001a304: b0 10 00 02 mov %g2, %i0 <== NOT EXECUTED if ( i < buffer_size ) { 4001a308: 80 a6 c0 18 cmp %i3, %i0 <== NOT EXECUTED 4001a30c: 28 bf ff fa bleu,a 4001a2f4 <_Objects_Name_to_string+0x4c> <== NOT EXECUTED 4001a310: ba 07 60 01 inc %i5 <== NOT EXECUTED *d = isprint((unsigned char) *s) ? *s : '*'; 4001a314: 40 00 0d 73 call 4001d8e0 <__locale_ctype_ptr> <== NOT EXECUTED 4001a318: 01 00 00 00 nop <== NOT EXECUTED 4001a31c: c2 0f 40 00 ldub [ %i5 ], %g1 <== NOT EXECUTED 4001a320: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED 4001a324: c4 4a 20 01 ldsb [ %o0 + 1 ], %g2 <== NOT EXECUTED 4001a328: 80 88 a0 97 btst 0x97, %g2 <== NOT EXECUTED 4001a32c: 22 80 00 02 be,a 4001a334 <_Objects_Name_to_string+0x8c> <== NOT EXECUTED 4001a330: 82 10 20 2a mov 0x2a, %g1 <== NOT EXECUTED 4001a334: c2 2e 80 00 stb %g1, [ %i2 ] <== NOT EXECUTED ++s; 4001a338: ba 07 60 01 inc %i5 <== NOT EXECUTED while ( *s != '\0' ) { 4001a33c: c2 4f 40 00 ldsb [ %i5 ], %g1 <== NOT EXECUTED ++d; 4001a340: b4 06 a0 01 inc %i2 <== NOT EXECUTED while ( *s != '\0' ) { 4001a344: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001a348: 12 bf ff ef bne 4001a304 <_Objects_Name_to_string+0x5c> <== NOT EXECUTED 4001a34c: 84 06 20 01 add %i0, 1, %g2 <== NOT EXECUTED } } if ( buffer_size > 0 ) { 4001a350: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 4001a354: 32 80 00 02 bne,a 4001a35c <_Objects_Name_to_string+0xb4> <== NOT EXECUTED 4001a358: c0 2e 80 00 clrb [ %i2 ] <== NOT EXECUTED *d = '\0'; } return i - 1; } 4001a35c: 81 c7 e0 08 ret <== NOT EXECUTED 4001a360: 81 e8 00 00 restore <== NOT EXECUTED if ( s != NULL ) { 4001a364: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED 4001a368: 32 bf ff dd bne,a 4001a2dc <_Objects_Name_to_string+0x34> <== NOT EXECUTED 4001a36c: c2 0f 40 00 ldub [ %i5 ], %g1 <== NOT EXECUTED *d = isprint((unsigned char) *s) ? *s : '*'; 4001a370: 10 bf ff f8 b 4001a350 <_Objects_Name_to_string+0xa8> <== NOT EXECUTED 4001a374: b0 10 20 00 clr %i0 <== NOT EXECUTED =============================================================================== 4000d978 <_Objects_Namespace_remove>: void _Objects_Namespace_remove( Objects_Information *information, Objects_Control *the_object ) { 4000d978: 9d e3 bf a0 save %sp, -96, %sp #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) /* * If this is a string format name, then free the memory. */ if ( information->is_string ) 4000d97c: c2 0e 20 38 ldub [ %i0 + 0x38 ], %g1 4000d980: 80 a0 60 00 cmp %g1, 0 4000d984: 22 80 00 05 be,a 4000d998 <_Objects_Namespace_remove+0x20> <== ALWAYS TAKEN 4000d988: c0 26 60 0c clr [ %i1 + 0xc ] _Workspace_Free( (void *)the_object->name.name_p ); 4000d98c: 7f ff f9 b3 call 4000c058 <_Workspace_Free> <== NOT EXECUTED 4000d990: d0 06 60 0c ld [ %i1 + 0xc ], %o0 <== NOT EXECUTED /* * Clear out either format. */ #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) the_object->name.name_p = NULL; 4000d994: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED #endif the_object->name.name_u32 = 0; } 4000d998: 81 c7 e0 08 ret 4000d99c: 81 e8 00 00 restore =============================================================================== 400089dc <_Objects_Shrink_information>: #include void _Objects_Shrink_information( Objects_Information *information ) { 400089dc: 9d e3 bf a0 save %sp, -96, %sp 400089e0: c6 16 20 0a lduh [ %i0 + 0xa ], %g3 * 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; 400089e4: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2 block_count = (information->maximum - index_base) / 400089e8: c8 16 20 10 lduh [ %i0 + 0x10 ], %g4 400089ec: 88 21 00 03 sub %g4, %g3, %g4 for ( block = 0; block < block_count; block++ ) { 400089f0: 81 80 20 00 wr %g0, %y 400089f4: 01 00 00 00 nop 400089f8: 01 00 00 00 nop 400089fc: 01 00 00 00 nop 40008a00: 88 f1 00 02 udivcc %g4, %g2, %g4 40008a04: 02 80 00 35 be 40008ad8 <_Objects_Shrink_information+0xfc> 40008a08: 01 00 00 00 nop if ( information->inactive_per_block[ block ] == 40008a0c: f4 06 20 30 ld [ %i0 + 0x30 ], %i2 40008a10: c2 06 80 00 ld [ %i2 ], %g1 40008a14: 80 a0 80 01 cmp %g2, %g1 40008a18: 02 80 00 0f be 40008a54 <_Objects_Shrink_information+0x78> <== NEVER TAKEN 40008a1c: ba 10 20 04 mov 4, %i5 for ( block = 0; block < block_count; block++ ) { 40008a20: 10 80 00 07 b 40008a3c <_Objects_Shrink_information+0x60> 40008a24: 82 10 20 00 clr %g1 if ( information->inactive_per_block[ block ] == 40008a28: f8 06 80 1d ld [ %i2 + %i5 ], %i4 40008a2c: 80 a0 80 1c cmp %g2, %i4 40008a30: 02 80 00 0a be 40008a58 <_Objects_Shrink_information+0x7c> 40008a34: b6 07 60 04 add %i5, 4, %i3 40008a38: ba 10 00 1b mov %i3, %i5 for ( block = 0; block < block_count; block++ ) { 40008a3c: 82 00 60 01 inc %g1 40008a40: 80 a1 00 01 cmp %g4, %g1 40008a44: 12 bf ff f9 bne 40008a28 <_Objects_Shrink_information+0x4c> 40008a48: 86 00 c0 02 add %g3, %g2, %g3 return; } index_base += information->allocation_size; } } 40008a4c: 81 c7 e0 08 ret 40008a50: 81 e8 00 00 restore if ( information->inactive_per_block[ block ] == 40008a54: ba 10 20 00 clr %i5 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 40008a58: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 return &the_chain->Tail.Node; 40008a5c: b4 06 20 24 add %i0, 0x24, %i2 while ( node != tail ) { 40008a60: 80 a0 40 1a cmp %g1, %i2 40008a64: 02 80 00 12 be 40008aac <_Objects_Shrink_information+0xd0> <== NEVER TAKEN 40008a68: 84 00 80 03 add %g2, %g3, %g2 40008a6c: 37 00 00 3f sethi %hi(0xfc00), %i3 40008a70: b6 16 e3 ff or %i3, 0x3ff, %i3 ! ffff 40008a74: c8 00 60 08 ld [ %g1 + 8 ], %g4 40008a78: 88 09 00 1b and %g4, %i3, %g4 if ( index >= index_base && index < index_end ) { 40008a7c: 80 a1 00 03 cmp %g4, %g3 40008a80: 0a 80 00 08 bcs 40008aa0 <_Objects_Shrink_information+0xc4> 40008a84: f8 00 40 00 ld [ %g1 ], %i4 40008a88: 80 a1 00 02 cmp %g4, %g2 40008a8c: 1a 80 00 06 bcc 40008aa4 <_Objects_Shrink_information+0xc8> <== NEVER TAKEN 40008a90: 80 a6 80 1c cmp %i2, %i4 previous = the_node->previous; 40008a94: c2 00 60 04 ld [ %g1 + 4 ], %g1 next->previous = previous; 40008a98: c2 27 20 04 st %g1, [ %i4 + 4 ] previous->next = next; 40008a9c: f8 20 40 00 st %i4, [ %g1 ] while ( node != tail ) { 40008aa0: 80 a6 80 1c cmp %i2, %i4 40008aa4: 12 bf ff f4 bne 40008a74 <_Objects_Shrink_information+0x98> 40008aa8: 82 10 00 1c mov %i4, %g1 _Workspace_Free( information->object_blocks[ block ] ); 40008aac: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 40008ab0: 40 00 0d 6a call 4000c058 <_Workspace_Free> 40008ab4: d0 00 40 1d ld [ %g1 + %i5 ], %o0 information->object_blocks[ block ] = NULL; 40008ab8: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 40008abc: c0 20 40 1d clr [ %g1 + %i5 ] information->inactive_per_block[ block ] = 0; 40008ac0: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 information->inactive -= information->allocation_size; 40008ac4: c2 16 20 2c lduh [ %i0 + 0x2c ], %g1 information->inactive_per_block[ block ] = 0; 40008ac8: c0 20 80 1d clr [ %g2 + %i5 ] information->inactive -= information->allocation_size; 40008acc: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2 40008ad0: 82 20 40 02 sub %g1, %g2, %g1 40008ad4: c2 36 20 2c sth %g1, [ %i0 + 0x2c ] return; 40008ad8: 81 c7 e0 08 ret 40008adc: 81 e8 00 00 restore =============================================================================== 4001198c <_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 ) ) { 4001198c: 9d e3 bf a0 save %sp, -96, %sp int eno = 0; if ( *once_state != ONCE_STATE_COMPLETE ) { 40011990: c2 0e 00 00 ldub [ %i0 ], %g1 40011994: 80 a0 60 02 cmp %g1, 2 40011998: 02 80 00 0e be 400119d0 <_Once+0x44> 4001199c: 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 ); 400119a0: 39 10 00 c7 sethi %hi(0x40031c00), %i4 400119a4: 7f ff f6 25 call 4000f238 <_API_Mutex_Lock> 400119a8: 90 17 22 70 or %i4, 0x270, %o0 ! 40031e70 <_Once_Mutex> switch ( *once_state ) { 400119ac: c2 0e 00 00 ldub [ %i0 ], %g1 400119b0: 80 a0 60 00 cmp %g1, 0 400119b4: 02 80 00 09 be 400119d8 <_Once+0x4c> <== ALWAYS TAKEN 400119b8: 82 18 60 01 xor %g1, 1, %g1 int eno = 0; 400119bc: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 400119c0: ba 40 3f ff addx %g0, -1, %i5 <== NOT EXECUTED 400119c4: ba 0f 60 16 and %i5, 0x16, %i5 <== NOT EXECUTED } void _Once_Unlock( void ) { _API_Mutex_Unlock( &_Once_Mutex ); 400119c8: 7f ff f6 28 call 4000f268 <_API_Mutex_Unlock> 400119cc: 90 17 22 70 or %i4, 0x270, %o0 } 400119d0: 81 c7 e0 08 ret 400119d4: 91 e8 00 1d restore %g0, %i5, %o0 *once_state = ONCE_STATE_RUNNING; 400119d8: 82 10 20 01 mov 1, %g1 ( *init_routine )(); 400119dc: 9f c6 40 00 call %i1 400119e0: c2 2e 00 00 stb %g1, [ %i0 ] *once_state = ONCE_STATE_COMPLETE; 400119e4: 82 10 20 02 mov 2, %g1 break; 400119e8: 10 bf ff f8 b 400119c8 <_Once+0x3c> 400119ec: c2 2e 00 00 stb %g1, [ %i0 ] =============================================================================== 4001c48c <_Protected_heap_Get_free_information>: bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 4001c48c: 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(); 4001c490: 7f ff f5 fd call 40019c84 <_RTEMS_Lock_allocator> <== NOT EXECUTED 4001c494: 01 00 00 00 nop <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 4001c498: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001c49c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4001c4a0: 40 00 a0 c2 call 400447a8 <_Heap_Get_free_information> <== NOT EXECUTED 4001c4a4: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED _RTEMS_Unlock_allocator(); 4001c4a8: 7f ff f5 fc call 40019c98 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 4001c4ac: 01 00 00 00 nop <== NOT EXECUTED return true; } 4001c4b0: 81 c7 e0 08 ret <== NOT EXECUTED 4001c4b4: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40044bf4 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 40044bf4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED if ( !the_heap ) return false; if ( !the_info ) 40044bf8: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 40044bfc: 02 80 00 0e be 40044c34 <_Protected_heap_Get_information+0x40> <== NOT EXECUTED 40044c00: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 40044c04: 22 80 00 0d be,a 40044c38 <_Protected_heap_Get_information+0x44> <== NOT EXECUTED 40044c08: b0 10 20 00 clr %i0 <== NOT EXECUTED return false; _RTEMS_Lock_allocator(); 40044c0c: 7f ff 54 1e call 40019c84 <_RTEMS_Lock_allocator> <== NOT EXECUTED 40044c10: 01 00 00 00 nop <== NOT EXECUTED _Heap_Get_information( the_heap, the_info ); 40044c14: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40044c18: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40044c1c: 40 00 4d dd call 40058390 <_Heap_Get_information> <== NOT EXECUTED 40044c20: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED _RTEMS_Unlock_allocator(); 40044c24: 7f ff 54 1d call 40019c98 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 40044c28: b0 0e 20 01 and %i0, 1, %i0 <== NOT EXECUTED return true; } 40044c2c: 81 c7 e0 08 ret <== NOT EXECUTED 40044c30: 81 e8 00 00 restore <== NOT EXECUTED return false; 40044c34: b0 10 20 00 clr %i0 <== NOT EXECUTED } 40044c38: b0 0e 20 01 and %i0, 1, %i0 <== NOT EXECUTED 40044c3c: 81 c7 e0 08 ret <== NOT EXECUTED 40044c40: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40044c44 <_Protected_heap_Walk>: bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 40044c44: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED enabled = _Thread_Dispatch_disable_level == 0; 40044c48: 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() ) { 40044c4c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40044c50: 02 80 00 04 be 40044c60 <_Protected_heap_Walk+0x1c> <== NOT EXECUTED 40044c54: 01 00 00 00 nop <== NOT EXECUTED _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 40044c58: 40 00 4e 11 call 4005849c <_Heap_Walk> <== NOT EXECUTED 40044c5c: 81 e8 00 00 restore <== NOT EXECUTED _RTEMS_Lock_allocator(); 40044c60: 7f ff 54 09 call 40019c84 <_RTEMS_Lock_allocator> <== NOT EXECUTED 40044c64: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Walk( the_heap, source, do_dump ); 40044c68: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 40044c6c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40044c70: 40 00 4e 0b call 4005849c <_Heap_Walk> <== NOT EXECUTED 40044c74: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _RTEMS_Unlock_allocator(); 40044c78: 7f ff 54 08 call 40019c98 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 40044c7c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED } return status; } 40044c80: 81 c7 e0 08 ret <== NOT EXECUTED 40044c84: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40008b08 <_RBTree_Extract>: #include RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 40008b08: c6 02 40 00 ld [ %o1 ], %g3 40008b0c: 80 a0 e0 00 cmp %g3, 0 40008b10: 02 80 00 d0 be 40008e50 <_RBTree_Extract+0x348> 40008b14: c4 02 60 04 ld [ %o1 + 4 ], %g2 40008b18: 80 a0 a0 00 cmp %g2, 0 40008b1c: 32 80 00 13 bne,a 40008b68 <_RBTree_Extract+0x60> <== ALWAYS TAKEN 40008b20: c2 00 80 00 ld [ %g2 ], %g1 40008b24: c2 02 60 08 ld [ %o1 + 8 ], %g1 <== NOT EXECUTED 40008b28: c8 02 60 0c ld [ %o1 + 0xc ], %g4 <== NOT EXECUTED 40008b2c: c2 20 e0 08 st %g1, [ %g3 + 8 ] 40008b30: 80 a0 60 00 cmp %g1, 0 40008b34: 22 80 00 cf be,a 40008e70 <_RBTree_Extract+0x368> 40008b38: c6 22 00 00 st %g3, [ %o0 ] 40008b3c: c4 00 40 00 ld [ %g1 ], %g2 40008b40: 80 a2 40 02 cmp %o1, %g2 40008b44: 22 80 00 d3 be,a 40008e90 <_RBTree_Extract+0x388> <== ALWAYS TAKEN 40008b48: c6 20 40 00 st %g3, [ %g1 ] 40008b4c: c6 20 60 04 st %g3, [ %g1 + 4 ] <== NOT EXECUTED 40008b50: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED 40008b54: 02 80 00 55 be 40008ca8 <_RBTree_Extract+0x1a0> <== NOT EXECUTED 40008b58: 9a 10 20 01 mov 1, %o5 <== NOT EXECUTED ) { _Assert( _RBTree_Find_root( the_node ) == _RBTree_Root( the_rbtree ) ); RB_REMOVE( RBTree_Control, the_rbtree, the_node ); _RBTree_Initialize_node( the_node ); } 40008b5c: 81 c3 e0 08 retl 40008b60: 01 00 00 00 nop RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 40008b64: c2 00 80 00 ld [ %g2 ], %g1 40008b68: 80 a0 60 00 cmp %g1, 0 40008b6c: 32 bf ff fe bne,a 40008b64 <_RBTree_Extract+0x5c> 40008b70: 84 10 00 01 mov %g1, %g2 40008b74: c6 00 a0 04 ld [ %g2 + 4 ], %g3 40008b78: c2 00 a0 08 ld [ %g2 + 8 ], %g1 40008b7c: c8 00 a0 0c ld [ %g2 + 0xc ], %g4 40008b80: 80 a0 e0 00 cmp %g3, 0 40008b84: 02 80 00 04 be 40008b94 <_RBTree_Extract+0x8c> <== ALWAYS TAKEN 40008b88: 9a 10 00 01 mov %g1, %o5 40008b8c: c2 20 e0 08 st %g1, [ %g3 + 8 ] <== NOT EXECUTED 40008b90: da 00 a0 08 ld [ %g2 + 8 ], %o5 <== NOT EXECUTED 40008b94: 80 a0 60 00 cmp %g1, 0 40008b98: 22 80 00 07 be,a 40008bb4 <_RBTree_Extract+0xac> <== NEVER TAKEN 40008b9c: c6 22 00 00 st %g3, [ %o0 ] <== NOT EXECUTED 40008ba0: d8 00 40 00 ld [ %g1 ], %o4 40008ba4: 80 a0 80 0c cmp %g2, %o4 40008ba8: 22 80 00 03 be,a 40008bb4 <_RBTree_Extract+0xac> <== ALWAYS TAKEN 40008bac: c6 20 40 00 st %g3, [ %g1 ] 40008bb0: c6 20 60 04 st %g3, [ %g1 + 4 ] <== NOT EXECUTED 40008bb4: 80 a2 40 0d cmp %o1, %o5 40008bb8: 22 80 00 02 be,a 40008bc0 <_RBTree_Extract+0xb8> <== NEVER TAKEN 40008bbc: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED 40008bc0: da 02 40 00 ld [ %o1 ], %o5 40008bc4: da 20 80 00 st %o5, [ %g2 ] 40008bc8: da 02 60 04 ld [ %o1 + 4 ], %o5 40008bcc: da 20 a0 04 st %o5, [ %g2 + 4 ] 40008bd0: da 02 60 08 ld [ %o1 + 8 ], %o5 40008bd4: da 20 a0 08 st %o5, [ %g2 + 8 ] 40008bd8: da 02 60 0c ld [ %o1 + 0xc ], %o5 40008bdc: da 20 a0 0c st %o5, [ %g2 + 0xc ] 40008be0: da 02 60 08 ld [ %o1 + 8 ], %o5 40008be4: 80 a3 60 00 cmp %o5, 0 40008be8: 22 80 00 07 be,a 40008c04 <_RBTree_Extract+0xfc> <== ALWAYS TAKEN 40008bec: c4 22 00 00 st %g2, [ %o0 ] 40008bf0: d8 03 40 00 ld [ %o5 ], %o4 <== NOT EXECUTED 40008bf4: 80 a2 40 0c cmp %o1, %o4 <== NOT EXECUTED 40008bf8: 22 80 00 03 be,a 40008c04 <_RBTree_Extract+0xfc> <== NOT EXECUTED 40008bfc: c4 23 40 00 st %g2, [ %o5 ] <== NOT EXECUTED 40008c00: c4 23 60 04 st %g2, [ %o5 + 4 ] <== NOT EXECUTED 40008c04: da 02 40 00 ld [ %o1 ], %o5 40008c08: c4 23 60 08 st %g2, [ %o5 + 8 ] 40008c0c: da 02 60 04 ld [ %o1 + 4 ], %o5 40008c10: 80 a3 60 00 cmp %o5, 0 40008c14: 32 80 00 02 bne,a 40008c1c <_RBTree_Extract+0x114> <== ALWAYS TAKEN 40008c18: c4 23 60 08 st %g2, [ %o5 + 8 ] 40008c1c: 80 a0 60 00 cmp %g1, 0 40008c20: 02 bf ff cc be 40008b50 <_RBTree_Extract+0x48> <== NEVER TAKEN 40008c24: 84 10 00 01 mov %g1, %g2 40008c28: c4 00 a0 08 ld [ %g2 + 8 ], %g2 40008c2c: 80 a0 a0 00 cmp %g2, 0 40008c30: 32 bf ff ff bne,a 40008c2c <_RBTree_Extract+0x124> 40008c34: c4 00 a0 08 ld [ %g2 + 8 ], %g2 40008c38: 80 a1 20 00 cmp %g4, 0 40008c3c: 12 bf ff c8 bne 40008b5c <_RBTree_Extract+0x54> <== ALWAYS TAKEN 40008c40: 9a 10 20 01 mov 1, %o5 RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 40008c44: 10 80 00 1a b 40008cac <_RBTree_Extract+0x1a4> <== NOT EXECUTED 40008c48: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40008c4c: 80 a0 e0 01 cmp %g3, 1 <== NOT EXECUTED 40008c50: 22 80 00 54 be,a 40008da0 <_RBTree_Extract+0x298> <== NOT EXECUTED 40008c54: c8 00 a0 04 ld [ %g2 + 4 ], %g4 <== NOT EXECUTED 40008c58: c6 00 80 00 ld [ %g2 ], %g3 <== NOT EXECUTED 40008c5c: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40008c60: 22 80 00 07 be,a 40008c7c <_RBTree_Extract+0x174> <== NOT EXECUTED 40008c64: c8 00 a0 04 ld [ %g2 + 4 ], %g4 <== NOT EXECUTED 40008c68: c8 00 e0 0c ld [ %g3 + 0xc ], %g4 <== NOT EXECUTED 40008c6c: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED 40008c70: 32 80 00 98 bne,a 40008ed0 <_RBTree_Extract+0x3c8> <== NOT EXECUTED 40008c74: da 00 60 0c ld [ %g1 + 0xc ], %o5 <== NOT EXECUTED 40008c78: c8 00 a0 04 ld [ %g2 + 4 ], %g4 <== NOT EXECUTED 40008c7c: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED 40008c80: 22 80 00 07 be,a 40008c9c <_RBTree_Extract+0x194> <== NOT EXECUTED 40008c84: da 20 a0 0c st %o5, [ %g2 + 0xc ] <== NOT EXECUTED 40008c88: d8 01 20 0c ld [ %g4 + 0xc ], %o4 <== NOT EXECUTED 40008c8c: 80 a3 20 00 cmp %o4, 0 <== NOT EXECUTED 40008c90: 12 80 00 89 bne 40008eb4 <_RBTree_Extract+0x3ac> <== NOT EXECUTED 40008c94: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40008c98: da 20 a0 0c st %o5, [ %g2 + 0xc ] <== NOT EXECUTED 40008c9c: 86 10 00 01 mov %g1, %g3 40008ca0: c4 00 60 08 ld [ %g1 + 8 ], %g2 40008ca4: 82 10 00 02 mov %g2, %g1 40008ca8: 80 a0 e0 00 cmp %g3, 0 40008cac: 22 80 00 07 be,a 40008cc8 <_RBTree_Extract+0x1c0> 40008cb0: c4 02 00 00 ld [ %o0 ], %g2 40008cb4: c4 00 e0 0c ld [ %g3 + 0xc ], %g2 40008cb8: 80 a0 a0 00 cmp %g2, 0 40008cbc: 12 80 00 37 bne 40008d98 <_RBTree_Extract+0x290> 40008cc0: 01 00 00 00 nop 40008cc4: c4 02 00 00 ld [ %o0 ], %g2 40008cc8: 80 a0 c0 02 cmp %g3, %g2 40008ccc: 02 80 00 31 be 40008d90 <_RBTree_Extract+0x288> 40008cd0: 80 a0 e0 00 cmp %g3, 0 40008cd4: c4 00 40 00 ld [ %g1 ], %g2 40008cd8: 80 a0 80 03 cmp %g2, %g3 40008cdc: 32 bf ff dc bne,a 40008c4c <_RBTree_Extract+0x144> <== NEVER TAKEN 40008ce0: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 <== NOT EXECUTED 40008ce4: c4 00 60 04 ld [ %g1 + 4 ], %g2 40008ce8: c8 00 a0 0c ld [ %g2 + 0xc ], %g4 40008cec: 80 a1 20 01 cmp %g4, 1 40008cf0: 02 80 00 40 be 40008df0 <_RBTree_Extract+0x2e8> <== NEVER TAKEN 40008cf4: c6 00 80 00 ld [ %g2 ], %g3 40008cf8: 80 a0 e0 00 cmp %g3, 0 40008cfc: 22 80 00 06 be,a 40008d14 <_RBTree_Extract+0x20c> 40008d00: c8 00 a0 04 ld [ %g2 + 4 ], %g4 40008d04: c8 00 e0 0c ld [ %g3 + 0xc ], %g4 40008d08: 80 a1 20 00 cmp %g4, 0 40008d0c: 12 80 00 ac bne 40008fbc <_RBTree_Extract+0x4b4> <== ALWAYS TAKEN 40008d10: c8 00 a0 04 ld [ %g2 + 4 ], %g4 40008d14: 80 a1 20 00 cmp %g4, 0 40008d18: 22 bf ff e1 be,a 40008c9c <_RBTree_Extract+0x194> <== ALWAYS TAKEN 40008d1c: da 20 a0 0c st %o5, [ %g2 + 0xc ] 40008d20: c6 01 20 0c ld [ %g4 + 0xc ], %g3 <== NOT EXECUTED 40008d24: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40008d28: 22 bf ff dd be,a 40008c9c <_RBTree_Extract+0x194> <== NOT EXECUTED 40008d2c: da 20 a0 0c st %o5, [ %g2 + 0xc ] <== NOT EXECUTED 40008d30: c6 00 60 0c ld [ %g1 + 0xc ], %g3 <== NOT EXECUTED 40008d34: da 00 60 04 ld [ %g1 + 4 ], %o5 40008d38: c6 20 a0 0c st %g3, [ %g2 + 0xc ] 40008d3c: c0 20 60 0c clr [ %g1 + 0xc ] 40008d40: c0 21 20 0c clr [ %g4 + 0xc ] 40008d44: c4 03 40 00 ld [ %o5 ], %g2 40008d48: 80 a0 a0 00 cmp %g2, 0 40008d4c: 02 80 00 03 be 40008d58 <_RBTree_Extract+0x250> 40008d50: c4 20 60 04 st %g2, [ %g1 + 4 ] 40008d54: c2 20 a0 08 st %g1, [ %g2 + 8 ] 40008d58: c4 00 60 08 ld [ %g1 + 8 ], %g2 40008d5c: 80 a0 a0 00 cmp %g2, 0 40008d60: 02 80 00 c1 be 40009064 <_RBTree_Extract+0x55c> <== ALWAYS TAKEN 40008d64: c4 23 60 08 st %g2, [ %o5 + 8 ] 40008d68: c4 00 60 08 ld [ %g1 + 8 ], %g2 <== NOT EXECUTED 40008d6c: c6 00 80 00 ld [ %g2 ], %g3 <== NOT EXECUTED 40008d70: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40008d74: 22 80 00 c1 be,a 40009078 <_RBTree_Extract+0x570> <== NOT EXECUTED 40008d78: da 20 80 00 st %o5, [ %g2 ] <== NOT EXECUTED 40008d7c: da 20 a0 04 st %o5, [ %g2 + 4 ] <== NOT EXECUTED 40008d80: c6 02 00 00 ld [ %o0 ], %g3 <== NOT EXECUTED 40008d84: c2 23 40 00 st %g1, [ %o5 ] <== NOT EXECUTED 40008d88: da 20 60 08 st %o5, [ %g1 + 8 ] <== NOT EXECUTED 40008d8c: 80 a0 e0 00 cmp %g3, 0 40008d90: 02 bf ff 73 be 40008b5c <_RBTree_Extract+0x54> 40008d94: 01 00 00 00 nop } 40008d98: 81 c3 e0 08 retl 40008d9c: c0 20 e0 0c clr [ %g3 + 0xc ] RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 40008da0: c0 20 a0 0c clr [ %g2 + 0xc ] <== NOT EXECUTED 40008da4: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED 40008da8: c6 20 60 0c st %g3, [ %g1 + 0xc ] <== NOT EXECUTED 40008dac: 02 80 00 03 be 40008db8 <_RBTree_Extract+0x2b0> <== NOT EXECUTED 40008db0: c8 20 40 00 st %g4, [ %g1 ] <== NOT EXECUTED 40008db4: c2 21 20 08 st %g1, [ %g4 + 8 ] <== NOT EXECUTED 40008db8: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED 40008dbc: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40008dc0: 02 80 00 22 be 40008e48 <_RBTree_Extract+0x340> <== NOT EXECUTED 40008dc4: c6 20 a0 08 st %g3, [ %g2 + 8 ] <== NOT EXECUTED 40008dc8: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED 40008dcc: d8 00 c0 00 ld [ %g3 ], %o4 <== NOT EXECUTED 40008dd0: 80 a0 40 0c cmp %g1, %o4 <== NOT EXECUTED 40008dd4: 22 80 00 25 be,a 40008e68 <_RBTree_Extract+0x360> <== NOT EXECUTED 40008dd8: c4 20 c0 00 st %g2, [ %g3 ] <== NOT EXECUTED 40008ddc: c4 20 e0 04 st %g2, [ %g3 + 4 ] <== NOT EXECUTED 40008de0: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED 40008de4: c4 20 60 08 st %g2, [ %g1 + 8 ] <== NOT EXECUTED 40008de8: 10 bf ff 9c b 40008c58 <_RBTree_Extract+0x150> <== NOT EXECUTED 40008dec: 84 10 00 04 mov %g4, %g2 <== NOT EXECUTED 40008df0: c0 20 a0 0c clr [ %g2 + 0xc ] <== NOT EXECUTED 40008df4: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40008df8: c8 20 60 0c st %g4, [ %g1 + 0xc ] <== NOT EXECUTED 40008dfc: 02 80 00 03 be 40008e08 <_RBTree_Extract+0x300> <== NOT EXECUTED 40008e00: c6 20 60 04 st %g3, [ %g1 + 4 ] <== NOT EXECUTED 40008e04: c2 20 e0 08 st %g1, [ %g3 + 8 ] <== NOT EXECUTED 40008e08: c8 00 60 08 ld [ %g1 + 8 ], %g4 <== NOT EXECUTED 40008e0c: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED 40008e10: 02 80 00 1d be 40008e84 <_RBTree_Extract+0x37c> <== NOT EXECUTED 40008e14: c8 20 a0 08 st %g4, [ %g2 + 8 ] <== NOT EXECUTED 40008e18: c8 00 60 08 ld [ %g1 + 8 ], %g4 <== NOT EXECUTED 40008e1c: d8 01 00 00 ld [ %g4 ], %o4 <== NOT EXECUTED 40008e20: 80 a0 40 0c cmp %g1, %o4 <== NOT EXECUTED 40008e24: 22 80 00 22 be,a 40008eac <_RBTree_Extract+0x3a4> <== NOT EXECUTED 40008e28: c4 21 00 00 st %g2, [ %g4 ] <== NOT EXECUTED 40008e2c: c4 21 20 04 st %g2, [ %g4 + 4 ] <== NOT EXECUTED 40008e30: c8 00 60 04 ld [ %g1 + 4 ], %g4 <== NOT EXECUTED 40008e34: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED 40008e38: c6 01 00 00 ld [ %g4 ], %g3 <== NOT EXECUTED 40008e3c: c4 20 60 08 st %g2, [ %g1 + 8 ] <== NOT EXECUTED 40008e40: 10 bf ff ae b 40008cf8 <_RBTree_Extract+0x1f0> <== NOT EXECUTED 40008e44: 84 10 00 04 mov %g4, %g2 <== NOT EXECUTED 40008e48: 10 bf ff e6 b 40008de0 <_RBTree_Extract+0x2d8> <== NOT EXECUTED 40008e4c: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 40008e50: c2 02 60 08 ld [ %o1 + 8 ], %g1 40008e54: 80 a0 a0 00 cmp %g2, 0 40008e58: 02 bf ff 36 be 40008b30 <_RBTree_Extract+0x28> 40008e5c: c8 02 60 0c ld [ %o1 + 0xc ], %g4 40008e60: 10 bf ff 33 b 40008b2c <_RBTree_Extract+0x24> 40008e64: 86 10 00 02 mov %g2, %g3 40008e68: 10 bf ff de b 40008de0 <_RBTree_Extract+0x2d8> <== NOT EXECUTED 40008e6c: c8 00 40 00 ld [ %g1 ], %g4 <== NOT EXECUTED 40008e70: 80 a1 20 00 cmp %g4, 0 40008e74: 12 bf ff 3a bne 40008b5c <_RBTree_Extract+0x54> <== NEVER TAKEN 40008e78: 9a 10 20 01 mov 1, %o5 RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 40008e7c: 10 bf ff 8c b 40008cac <_RBTree_Extract+0x1a4> 40008e80: 80 a0 e0 00 cmp %g3, 0 40008e84: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED 40008e88: 10 bf ff eb b 40008e34 <_RBTree_Extract+0x32c> <== NOT EXECUTED 40008e8c: 88 10 00 03 mov %g3, %g4 <== NOT EXECUTED RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 40008e90: 80 a1 20 00 cmp %g4, 0 40008e94: 12 bf ff 32 bne 40008b5c <_RBTree_Extract+0x54> 40008e98: 9a 10 20 01 mov 1, %o5 RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 40008e9c: 10 bf ff 84 b 40008cac <_RBTree_Extract+0x1a4> 40008ea0: 80 a0 e0 00 cmp %g3, 0 RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 40008ea4: 10 bf ff 58 b 40008c04 <_RBTree_Extract+0xfc> <== NOT EXECUTED 40008ea8: c4 23 40 00 st %g2, [ %o5 ] <== NOT EXECUTED RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 40008eac: 10 bf ff e2 b 40008e34 <_RBTree_Extract+0x32c> <== NOT EXECUTED 40008eb0: 88 10 00 03 mov %g3, %g4 <== NOT EXECUTED 40008eb4: 22 80 00 21 be,a 40008f38 <_RBTree_Extract+0x430> <== NOT EXECUTED 40008eb8: c6 01 00 00 ld [ %g4 ], %g3 <== NOT EXECUTED 40008ebc: da 00 e0 0c ld [ %g3 + 0xc ], %o5 <== NOT EXECUTED 40008ec0: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED 40008ec4: 22 80 00 1d be,a 40008f38 <_RBTree_Extract+0x430> <== NOT EXECUTED 40008ec8: c6 01 00 00 ld [ %g4 ], %g3 <== NOT EXECUTED 40008ecc: da 00 60 0c ld [ %g1 + 0xc ], %o5 <== NOT EXECUTED 40008ed0: c8 00 40 00 ld [ %g1 ], %g4 <== NOT EXECUTED 40008ed4: da 20 a0 0c st %o5, [ %g2 + 0xc ] <== NOT EXECUTED 40008ed8: c0 20 60 0c clr [ %g1 + 0xc ] <== NOT EXECUTED 40008edc: c0 20 e0 0c clr [ %g3 + 0xc ] <== NOT EXECUTED 40008ee0: c4 01 20 04 ld [ %g4 + 4 ], %g2 <== NOT EXECUTED 40008ee4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40008ee8: 02 80 00 03 be 40008ef4 <_RBTree_Extract+0x3ec> <== NOT EXECUTED 40008eec: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED 40008ef0: c2 20 a0 08 st %g1, [ %g2 + 8 ] <== NOT EXECUTED 40008ef4: c4 00 60 08 ld [ %g1 + 8 ], %g2 <== NOT EXECUTED 40008ef8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40008efc: 02 80 00 2b be 40008fa8 <_RBTree_Extract+0x4a0> <== NOT EXECUTED 40008f00: c4 21 20 08 st %g2, [ %g4 + 8 ] <== NOT EXECUTED 40008f04: c4 00 60 08 ld [ %g1 + 8 ], %g2 <== NOT EXECUTED 40008f08: c6 00 80 00 ld [ %g2 ], %g3 <== NOT EXECUTED 40008f0c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40008f10: 22 80 00 4f be,a 4000904c <_RBTree_Extract+0x544> <== NOT EXECUTED 40008f14: c8 20 80 00 st %g4, [ %g2 ] <== NOT EXECUTED 40008f18: c8 20 a0 04 st %g4, [ %g2 + 4 ] <== NOT EXECUTED 40008f1c: c6 02 00 00 ld [ %o0 ], %g3 <== NOT EXECUTED 40008f20: c2 21 20 04 st %g1, [ %g4 + 4 ] <== NOT EXECUTED 40008f24: c8 20 60 08 st %g4, [ %g1 + 8 ] <== NOT EXECUTED 40008f28: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40008f2c: 12 bf ff 9b bne 40008d98 <_RBTree_Extract+0x290> <== NOT EXECUTED 40008f30: 01 00 00 00 nop <== NOT EXECUTED 40008f34: 30 bf ff 0a b,a 40008b5c <_RBTree_Extract+0x54> <== NOT EXECUTED 40008f38: c0 21 20 0c clr [ %g4 + 0xc ] <== NOT EXECUTED 40008f3c: 9a 10 20 01 mov 1, %o5 <== NOT EXECUTED 40008f40: c6 20 a0 04 st %g3, [ %g2 + 4 ] <== NOT EXECUTED 40008f44: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40008f48: 02 80 00 03 be 40008f54 <_RBTree_Extract+0x44c> <== NOT EXECUTED 40008f4c: da 20 a0 0c st %o5, [ %g2 + 0xc ] <== NOT EXECUTED 40008f50: c4 20 e0 08 st %g2, [ %g3 + 8 ] <== NOT EXECUTED 40008f54: c6 00 a0 08 ld [ %g2 + 8 ], %g3 <== NOT EXECUTED 40008f58: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40008f5c: 02 80 00 40 be 4000905c <_RBTree_Extract+0x554> <== NOT EXECUTED 40008f60: c6 21 20 08 st %g3, [ %g4 + 8 ] <== NOT EXECUTED 40008f64: c6 00 a0 08 ld [ %g2 + 8 ], %g3 <== NOT EXECUTED 40008f68: da 00 c0 00 ld [ %g3 ], %o5 <== NOT EXECUTED 40008f6c: 80 a0 80 0d cmp %g2, %o5 <== NOT EXECUTED 40008f70: 22 80 00 03 be,a 40008f7c <_RBTree_Extract+0x474> <== NOT EXECUTED 40008f74: c8 20 c0 00 st %g4, [ %g3 ] <== NOT EXECUTED 40008f78: c8 20 e0 04 st %g4, [ %g3 + 4 ] <== NOT EXECUTED 40008f7c: c4 21 00 00 st %g2, [ %g4 ] <== NOT EXECUTED 40008f80: c8 20 a0 08 st %g4, [ %g2 + 8 ] <== NOT EXECUTED 40008f84: c8 00 40 00 ld [ %g1 ], %g4 <== NOT EXECUTED 40008f88: c4 00 60 0c ld [ %g1 + 0xc ], %g2 <== NOT EXECUTED 40008f8c: c4 21 20 0c st %g2, [ %g4 + 0xc ] <== NOT EXECUTED 40008f90: c6 01 00 00 ld [ %g4 ], %g3 <== NOT EXECUTED 40008f94: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40008f98: 02 bf ff d2 be 40008ee0 <_RBTree_Extract+0x3d8> <== NOT EXECUTED 40008f9c: c0 20 60 0c clr [ %g1 + 0xc ] <== NOT EXECUTED 40008fa0: 10 bf ff d0 b 40008ee0 <_RBTree_Extract+0x3d8> <== NOT EXECUTED 40008fa4: c0 20 e0 0c clr [ %g3 + 0xc ] <== NOT EXECUTED 40008fa8: c8 22 00 00 st %g4, [ %o0 ] <== NOT EXECUTED 40008fac: 86 10 00 04 mov %g4, %g3 <== NOT EXECUTED 40008fb0: c2 21 20 04 st %g1, [ %g4 + 4 ] <== NOT EXECUTED 40008fb4: 10 bf ff dd b 40008f28 <_RBTree_Extract+0x420> <== NOT EXECUTED 40008fb8: c8 20 60 08 st %g4, [ %g1 + 8 ] <== NOT EXECUTED 40008fbc: 80 a1 20 00 cmp %g4, 0 40008fc0: 22 80 00 07 be,a 40008fdc <_RBTree_Extract+0x4d4> 40008fc4: c8 00 e0 04 ld [ %g3 + 4 ], %g4 40008fc8: da 01 20 0c ld [ %g4 + 0xc ], %o5 40008fcc: 80 a3 60 00 cmp %o5, 0 40008fd0: 32 bf ff 59 bne,a 40008d34 <_RBTree_Extract+0x22c> <== ALWAYS TAKEN 40008fd4: c6 00 60 0c ld [ %g1 + 0xc ], %g3 40008fd8: c8 00 e0 04 ld [ %g3 + 4 ], %g4 <== NOT EXECUTED 40008fdc: c0 20 e0 0c clr [ %g3 + 0xc ] 40008fe0: 9a 10 20 01 mov 1, %o5 40008fe4: c8 20 80 00 st %g4, [ %g2 ] 40008fe8: 80 a1 20 00 cmp %g4, 0 40008fec: 02 80 00 03 be 40008ff8 <_RBTree_Extract+0x4f0> <== ALWAYS TAKEN 40008ff0: da 20 a0 0c st %o5, [ %g2 + 0xc ] 40008ff4: c4 21 20 08 st %g2, [ %g4 + 8 ] <== NOT EXECUTED 40008ff8: c8 00 a0 08 ld [ %g2 + 8 ], %g4 40008ffc: 80 a1 20 00 cmp %g4, 0 40009000: 02 80 00 22 be 40009088 <_RBTree_Extract+0x580> <== NEVER TAKEN 40009004: c8 20 e0 08 st %g4, [ %g3 + 8 ] 40009008: c8 00 a0 08 ld [ %g2 + 8 ], %g4 4000900c: da 01 00 00 ld [ %g4 ], %o5 40009010: 80 a0 80 0d cmp %g2, %o5 40009014: 22 80 00 03 be,a 40009020 <_RBTree_Extract+0x518> <== NEVER TAKEN 40009018: c6 21 00 00 st %g3, [ %g4 ] <== NOT EXECUTED 4000901c: c6 21 20 04 st %g3, [ %g4 + 4 ] 40009020: c4 20 e0 04 st %g2, [ %g3 + 4 ] 40009024: c6 20 a0 08 st %g3, [ %g2 + 8 ] 40009028: da 00 60 04 ld [ %g1 + 4 ], %o5 4000902c: c4 00 60 0c ld [ %g1 + 0xc ], %g2 40009030: c4 23 60 0c st %g2, [ %o5 + 0xc ] 40009034: c8 03 60 04 ld [ %o5 + 4 ], %g4 40009038: 80 a1 20 00 cmp %g4, 0 4000903c: 02 bf ff 42 be 40008d44 <_RBTree_Extract+0x23c> <== NEVER TAKEN 40009040: c0 20 60 0c clr [ %g1 + 0xc ] 40009044: 10 bf ff 40 b 40008d44 <_RBTree_Extract+0x23c> 40009048: c0 21 20 0c clr [ %g4 + 0xc ] 4000904c: c6 02 00 00 ld [ %o0 ], %g3 <== NOT EXECUTED 40009050: c2 21 20 04 st %g1, [ %g4 + 4 ] <== NOT EXECUTED 40009054: 10 bf ff b5 b 40008f28 <_RBTree_Extract+0x420> <== NOT EXECUTED 40009058: c8 20 60 08 st %g4, [ %g1 + 8 ] <== NOT EXECUTED 4000905c: 10 bf ff c8 b 40008f7c <_RBTree_Extract+0x474> <== NOT EXECUTED 40009060: c8 22 00 00 st %g4, [ %o0 ] <== NOT EXECUTED 40009064: da 22 00 00 st %o5, [ %o0 ] 40009068: 86 10 00 0d mov %o5, %g3 4000906c: c2 23 40 00 st %g1, [ %o5 ] 40009070: 10 bf ff 47 b 40008d8c <_RBTree_Extract+0x284> 40009074: da 20 60 08 st %o5, [ %g1 + 8 ] 40009078: c6 02 00 00 ld [ %o0 ], %g3 <== NOT EXECUTED 4000907c: c2 23 40 00 st %g1, [ %o5 ] <== NOT EXECUTED 40009080: 10 bf ff 43 b 40008d8c <_RBTree_Extract+0x284> <== NOT EXECUTED 40009084: da 20 60 08 st %o5, [ %g1 + 8 ] <== NOT EXECUTED 40009088: 10 bf ff e6 b 40009020 <_RBTree_Extract+0x518> <== NOT EXECUTED 4000908c: c6 22 00 00 st %g3, [ %o0 ] <== NOT EXECUTED =============================================================================== 40009090 <_RBTree_Insert_color>: #include "config.h" #endif #include RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline ) 40009090: 98 10 20 01 mov 1, %o4 40009094: c2 02 60 08 ld [ %o1 + 8 ], %g1 40009098: 80 a0 60 00 cmp %g1, 0 4000909c: 22 80 00 2f be,a 40009158 <_RBTree_Insert_color+0xc8> 400090a0: c2 02 00 00 ld [ %o0 ], %g1 400090a4: c4 00 60 0c ld [ %g1 + 0xc ], %g2 400090a8: 80 a0 a0 01 cmp %g2, 1 400090ac: 32 80 00 2b bne,a 40009158 <_RBTree_Insert_color+0xc8> 400090b0: c2 02 00 00 ld [ %o0 ], %g1 400090b4: c6 00 60 08 ld [ %g1 + 8 ], %g3 400090b8: c8 00 c0 00 ld [ %g3 ], %g4 400090bc: 80 a0 40 04 cmp %g1, %g4 400090c0: 02 80 00 28 be 40009160 <_RBTree_Insert_color+0xd0> 400090c4: 84 10 00 03 mov %g3, %g2 400090c8: 80 a1 20 00 cmp %g4, 0 400090cc: 22 80 00 07 be,a 400090e8 <_RBTree_Insert_color+0x58> 400090d0: c8 00 40 00 ld [ %g1 ], %g4 400090d4: da 01 20 0c ld [ %g4 + 0xc ], %o5 400090d8: 80 a3 60 01 cmp %o5, 1 400090dc: 22 80 00 58 be,a 4000923c <_RBTree_Insert_color+0x1ac> <== ALWAYS TAKEN 400090e0: c0 21 20 0c clr [ %g4 + 0xc ] 400090e4: c8 00 40 00 ld [ %g1 ], %g4 <== NOT EXECUTED 400090e8: 80 a2 40 04 cmp %o1, %g4 400090ec: 22 80 00 3c be,a 400091dc <_RBTree_Insert_color+0x14c> 400090f0: c8 02 60 04 ld [ %o1 + 4 ], %g4 400090f4: c6 00 a0 04 ld [ %g2 + 4 ], %g3 400090f8: c0 20 60 0c clr [ %g1 + 0xc ] 400090fc: c2 00 c0 00 ld [ %g3 ], %g1 40009100: c2 20 a0 04 st %g1, [ %g2 + 4 ] 40009104: 80 a0 60 00 cmp %g1, 0 40009108: 02 80 00 03 be 40009114 <_RBTree_Insert_color+0x84> <== ALWAYS TAKEN 4000910c: d8 20 a0 0c st %o4, [ %g2 + 0xc ] 40009110: c4 20 60 08 st %g2, [ %g1 + 8 ] <== NOT EXECUTED 40009114: c2 00 a0 08 ld [ %g2 + 8 ], %g1 40009118: 80 a0 60 00 cmp %g1, 0 4000911c: 02 80 00 44 be 4000922c <_RBTree_Insert_color+0x19c> <== ALWAYS TAKEN 40009120: c2 20 e0 08 st %g1, [ %g3 + 8 ] 40009124: c2 00 a0 08 ld [ %g2 + 8 ], %g1 <== NOT EXECUTED 40009128: c8 00 40 00 ld [ %g1 ], %g4 <== NOT EXECUTED 4000912c: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED 40009130: 22 80 00 47 be,a 4000924c <_RBTree_Insert_color+0x1bc> <== NOT EXECUTED 40009134: c6 20 40 00 st %g3, [ %g1 ] <== NOT EXECUTED 40009138: c6 20 60 04 st %g3, [ %g1 + 4 ] <== NOT EXECUTED 4000913c: c4 20 c0 00 st %g2, [ %g3 ] <== NOT EXECUTED 40009140: c6 20 a0 08 st %g3, [ %g2 + 8 ] <== NOT EXECUTED 40009144: c2 02 60 08 ld [ %o1 + 8 ], %g1 40009148: 80 a0 60 00 cmp %g1, 0 4000914c: 32 bf ff d7 bne,a 400090a8 <_RBTree_Insert_color+0x18> <== ALWAYS TAKEN 40009150: c4 00 60 0c ld [ %g1 + 0xc ], %g2 40009154: 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 ); } 40009158: 81 c3 e0 08 retl 4000915c: c0 20 60 0c clr [ %g1 + 0xc ] RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline ) 40009160: c8 00 e0 04 ld [ %g3 + 4 ], %g4 40009164: 80 a1 20 00 cmp %g4, 0 40009168: 22 80 00 07 be,a 40009184 <_RBTree_Insert_color+0xf4> <== ALWAYS TAKEN 4000916c: da 00 60 04 ld [ %g1 + 4 ], %o5 40009170: da 01 20 0c ld [ %g4 + 0xc ], %o5 <== NOT EXECUTED 40009174: 80 a3 60 01 cmp %o5, 1 <== NOT EXECUTED 40009178: 22 80 00 31 be,a 4000923c <_RBTree_Insert_color+0x1ac> <== NOT EXECUTED 4000917c: c0 21 20 0c clr [ %g4 + 0xc ] <== NOT EXECUTED 40009180: da 00 60 04 ld [ %g1 + 4 ], %o5 <== NOT EXECUTED 40009184: 80 a3 40 09 cmp %o5, %o1 40009188: 02 80 00 3a be 40009270 <_RBTree_Insert_color+0x1e0> 4000918c: 88 10 00 01 mov %g1, %g4 40009190: c0 20 60 0c clr [ %g1 + 0xc ] 40009194: 80 a3 60 00 cmp %o5, 0 40009198: d8 20 a0 0c st %o4, [ %g2 + 0xc ] 4000919c: 02 80 00 03 be 400091a8 <_RBTree_Insert_color+0x118> <== ALWAYS TAKEN 400091a0: da 20 80 00 st %o5, [ %g2 ] 400091a4: c4 23 60 08 st %g2, [ %o5 + 8 ] <== NOT EXECUTED 400091a8: c2 00 a0 08 ld [ %g2 + 8 ], %g1 400091ac: 80 a0 60 00 cmp %g1, 0 400091b0: 02 80 00 2c be 40009260 <_RBTree_Insert_color+0x1d0> 400091b4: c2 21 20 08 st %g1, [ %g4 + 8 ] 400091b8: c2 00 a0 08 ld [ %g2 + 8 ], %g1 400091bc: c6 00 40 00 ld [ %g1 ], %g3 400091c0: 80 a0 80 03 cmp %g2, %g3 400091c4: 22 80 00 4a be,a 400092ec <_RBTree_Insert_color+0x25c> <== NEVER TAKEN 400091c8: c8 20 40 00 st %g4, [ %g1 ] <== NOT EXECUTED 400091cc: c8 20 60 04 st %g4, [ %g1 + 4 ] 400091d0: c4 21 20 04 st %g2, [ %g4 + 4 ] 400091d4: 10 bf ff b0 b 40009094 <_RBTree_Insert_color+0x4> 400091d8: c8 20 a0 08 st %g4, [ %g2 + 8 ] 400091dc: 80 a1 20 00 cmp %g4, 0 400091e0: 02 80 00 3b be 400092cc <_RBTree_Insert_color+0x23c> <== ALWAYS TAKEN 400091e4: c8 20 40 00 st %g4, [ %g1 ] 400091e8: c2 21 20 08 st %g1, [ %g4 + 8 ] <== NOT EXECUTED 400091ec: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED 400091f0: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 400091f4: 02 80 00 19 be 40009258 <_RBTree_Insert_color+0x1c8> <== NOT EXECUTED 400091f8: c6 22 60 08 st %g3, [ %o1 + 8 ] <== NOT EXECUTED 400091fc: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED 40009200: c8 00 c0 00 ld [ %g3 ], %g4 <== NOT EXECUTED 40009204: 80 a0 40 04 cmp %g1, %g4 <== NOT EXECUTED 40009208: 22 80 00 03 be,a 40009214 <_RBTree_Insert_color+0x184> <== NOT EXECUTED 4000920c: d2 20 c0 00 st %o1, [ %g3 ] <== NOT EXECUTED 40009210: d2 20 e0 04 st %o1, [ %g3 + 4 ] <== NOT EXECUTED 40009214: 86 10 00 09 mov %o1, %g3 40009218: c2 22 60 04 st %g1, [ %o1 + 4 ] 4000921c: d2 20 60 08 st %o1, [ %g1 + 8 ] 40009220: 92 10 00 01 mov %g1, %o1 40009224: 10 bf ff b4 b 400090f4 <_RBTree_Insert_color+0x64> 40009228: 82 10 00 03 mov %g3, %g1 4000922c: c6 22 00 00 st %g3, [ %o0 ] 40009230: c4 20 c0 00 st %g2, [ %g3 ] 40009234: 10 bf ff c4 b 40009144 <_RBTree_Insert_color+0xb4> 40009238: c6 20 a0 08 st %g3, [ %g2 + 8 ] 4000923c: 92 10 00 03 mov %g3, %o1 40009240: c0 20 60 0c clr [ %g1 + 0xc ] 40009244: 10 bf ff 94 b 40009094 <_RBTree_Insert_color+0x4> 40009248: da 20 e0 0c st %o5, [ %g3 + 0xc ] 4000924c: c4 20 c0 00 st %g2, [ %g3 ] <== NOT EXECUTED 40009250: 10 bf ff bd b 40009144 <_RBTree_Insert_color+0xb4> <== NOT EXECUTED 40009254: c6 20 a0 08 st %g3, [ %g2 + 8 ] <== NOT EXECUTED 40009258: 10 bf ff ef b 40009214 <_RBTree_Insert_color+0x184> <== NOT EXECUTED 4000925c: d2 22 00 00 st %o1, [ %o0 ] <== NOT EXECUTED 40009260: c8 22 00 00 st %g4, [ %o0 ] 40009264: c4 21 20 04 st %g2, [ %g4 + 4 ] 40009268: 10 bf ff 8b b 40009094 <_RBTree_Insert_color+0x4> 4000926c: c8 20 a0 08 st %g4, [ %g2 + 8 ] 40009270: c8 02 40 00 ld [ %o1 ], %g4 40009274: 80 a1 20 00 cmp %g4, 0 40009278: 02 80 00 04 be 40009288 <_RBTree_Insert_color+0x1f8> <== ALWAYS TAKEN 4000927c: c8 20 60 04 st %g4, [ %g1 + 4 ] 40009280: c2 21 20 08 st %g1, [ %g4 + 8 ] <== NOT EXECUTED 40009284: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED 40009288: 80 a0 e0 00 cmp %g3, 0 4000928c: 02 80 00 1b be 400092f8 <_RBTree_Insert_color+0x268> <== NEVER TAKEN 40009290: c6 22 60 08 st %g3, [ %o1 + 8 ] 40009294: c6 00 60 08 ld [ %g1 + 8 ], %g3 40009298: c8 00 c0 00 ld [ %g3 ], %g4 4000929c: 80 a0 40 04 cmp %g1, %g4 400092a0: 22 80 00 03 be,a 400092ac <_RBTree_Insert_color+0x21c> <== ALWAYS TAKEN 400092a4: d2 20 c0 00 st %o1, [ %g3 ] 400092a8: d2 20 e0 04 st %o1, [ %g3 + 4 ] <== NOT EXECUTED 400092ac: 86 10 00 09 mov %o1, %g3 400092b0: c2 22 40 00 st %g1, [ %o1 ] 400092b4: c8 00 80 00 ld [ %g2 ], %g4 400092b8: da 01 20 04 ld [ %g4 + 4 ], %o5 400092bc: d2 20 60 08 st %o1, [ %g1 + 8 ] 400092c0: 92 10 00 01 mov %g1, %o1 400092c4: 10 bf ff b3 b 40009190 <_RBTree_Insert_color+0x100> 400092c8: 82 10 00 03 mov %g3, %g1 400092cc: c6 22 60 08 st %g3, [ %o1 + 8 ] 400092d0: c6 00 60 08 ld [ %g1 + 8 ], %g3 400092d4: c8 00 c0 00 ld [ %g3 ], %g4 400092d8: 80 a0 40 04 cmp %g1, %g4 400092dc: 32 bf ff ce bne,a 40009214 <_RBTree_Insert_color+0x184> <== ALWAYS TAKEN 400092e0: d2 20 e0 04 st %o1, [ %g3 + 4 ] 400092e4: 10 bf ff cc b 40009214 <_RBTree_Insert_color+0x184> <== NOT EXECUTED 400092e8: d2 20 c0 00 st %o1, [ %g3 ] <== NOT EXECUTED 400092ec: c4 21 20 04 st %g2, [ %g4 + 4 ] <== NOT EXECUTED 400092f0: 10 bf ff 69 b 40009094 <_RBTree_Insert_color+0x4> <== NOT EXECUTED 400092f4: c8 20 a0 08 st %g4, [ %g2 + 8 ] <== NOT EXECUTED 400092f8: 10 bf ff ed b 400092ac <_RBTree_Insert_color+0x21c> <== NOT EXECUTED 400092fc: d2 22 00 00 st %o1, [ %o0 ] <== NOT EXECUTED =============================================================================== 4000d9a0 <_RBTree_Minimum>: #endif #include #include RB_GENERATE_MINMAX( RBTree_Control, RBTree_Node, Node, static ) 4000d9a0: d0 02 00 00 ld [ %o0 ], %o0 4000d9a4: 80 a2 20 00 cmp %o0, 0 4000d9a8: 32 80 00 04 bne,a 4000d9b8 <_RBTree_Minimum+0x18> <== ALWAYS TAKEN 4000d9ac: c2 02 00 00 ld [ %o0 ], %g1 4000d9b0: 30 80 00 07 b,a 4000d9cc <_RBTree_Minimum+0x2c> <== NOT EXECUTED 4000d9b4: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 4000d9b8: 80 a0 60 00 cmp %g1, 0 4000d9bc: 32 bf ff fe bne,a 4000d9b4 <_RBTree_Minimum+0x14> <== NEVER TAKEN 4000d9c0: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED 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 ) ); } 4000d9c4: 81 c3 e0 08 retl 4000d9c8: 01 00 00 00 nop 4000d9cc: 81 c3 e0 08 retl <== NOT EXECUTED 4000d9d0: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 400063ac <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 400063ac: 9d e3 bf 98 save %sp, -104, %sp rtems_task_entry entry_point; /* * Move information into local variables */ user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table; 400063b0: 03 10 00 43 sethi %hi(0x40010c00), %g1 400063b4: 82 10 62 04 or %g1, 0x204, %g1 ! 40010e04 400063b8: fa 00 60 28 ld [ %g1 + 0x28 ], %i5 maximum = Configuration_RTEMS_API.number_of_initialization_tasks; /* * Verify that we have a set of user tasks to iterate */ if ( !user_tasks ) 400063bc: 80 a7 60 00 cmp %i5, 0 400063c0: 02 80 00 21 be 40006444 <_RTEMS_tasks_Initialize_user_tasks_body+0x98> <== NEVER TAKEN 400063c4: 01 00 00 00 nop maximum = Configuration_RTEMS_API.number_of_initialization_tasks; 400063c8: f4 00 60 24 ld [ %g1 + 0x24 ], %i2 return; /* * Now iterate over the initialization tasks and create/start them. */ for ( index=0 ; index < maximum ; index++ ) { 400063cc: 80 a6 a0 00 cmp %i2, 0 400063d0: 02 80 00 1d be 40006444 <_RTEMS_tasks_Initialize_user_tasks_body+0x98> <== NEVER TAKEN 400063d4: b8 10 20 00 clr %i4 user_tasks[ index ].argument ); _Assert( rtems_is_status_successful( return_value ) ); (void) return_value; if ( _Thread_Global_constructor == 0 ) { 400063d8: 37 10 00 4a sethi %hi(0x40012800), %i3 return_value = rtems_task_create( 400063dc: d8 07 60 0c ld [ %i5 + 0xc ], %o4 400063e0: d6 07 60 14 ld [ %i5 + 0x14 ], %o3 400063e4: d4 07 60 04 ld [ %i5 + 4 ], %o2 400063e8: d2 07 60 08 ld [ %i5 + 8 ], %o1 400063ec: d0 07 40 00 ld [ %i5 ], %o0 400063f0: 7f ff ff 4c call 40006120 400063f4: 9a 07 bf fc add %fp, -4, %o5 if ( !rtems_is_status_successful( return_value ) ) { 400063f8: 80 a2 20 00 cmp %o0, 0 400063fc: 12 80 00 14 bne 4000644c <_RTEMS_tasks_Initialize_user_tasks_body+0xa0> <== NEVER TAKEN 40006400: 01 00 00 00 nop entry_point = user_tasks[ index ].entry_point; 40006404: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 if ( entry_point == NULL ) { 40006408: 80 a2 60 00 cmp %o1, 0 4000640c: 02 80 00 12 be 40006454 <_RTEMS_tasks_Initialize_user_tasks_body+0xa8> <== NEVER TAKEN 40006410: 01 00 00 00 nop return_value = rtems_task_start( 40006414: d4 07 60 18 ld [ %i5 + 0x18 ], %o2 40006418: 40 00 00 24 call 400064a8 4000641c: d0 07 bf fc ld [ %fp + -4 ], %o0 if ( _Thread_Global_constructor == 0 ) { 40006420: c2 06 e2 58 ld [ %i3 + 0x258 ], %g1 40006424: 80 a0 60 00 cmp %g1, 0 40006428: 12 80 00 04 bne 40006438 <_RTEMS_tasks_Initialize_user_tasks_body+0x8c> <== NEVER TAKEN 4000642c: b8 07 20 01 inc %i4 _Thread_Global_constructor = id; 40006430: c2 07 bf fc ld [ %fp + -4 ], %g1 40006434: c2 26 e2 58 st %g1, [ %i3 + 0x258 ] for ( index=0 ; index < maximum ; index++ ) { 40006438: 80 a6 80 1c cmp %i2, %i4 4000643c: 12 bf ff e8 bne 400063dc <_RTEMS_tasks_Initialize_user_tasks_body+0x30> <== NEVER TAKEN 40006440: ba 07 60 1c add %i5, 0x1c, %i5 } } } 40006444: 81 c7 e0 08 ret 40006448: 81 e8 00 00 restore _Internal_error( INTERNAL_ERROR_RTEMS_INIT_TASK_CREATE_FAILED ); 4000644c: 40 00 02 c7 call 40006f68 <_Internal_error> <== NOT EXECUTED 40006450: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED _Internal_error( INTERNAL_ERROR_RTEMS_INIT_TASK_ENTRY_IS_NULL ); 40006454: 40 00 02 c5 call 40006f68 <_Internal_error> <== NOT EXECUTED 40006458: 90 10 20 1a mov 0x1a, %o0 <== NOT EXECUTED 4000645c: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 4005822c <_Rate_monotonic_Get_status>: bool _Rate_monotonic_Get_status( const Rate_monotonic_Control *the_period, Timestamp_Control *wall_since_last_period, Timestamp_Control *cpu_since_last_period ) { 4005822c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED 40058230: 7f ff 0d 60 call 4001b7b0 <_Timecounter_Sbinuptime> <== NOT EXECUTED 40058234: fa 06 20 54 ld [ %i0 + 0x54 ], %i5 <== NOT EXECUTED *_result = *_end - *_start; 40058238: c4 1e 20 60 ldd [ %i0 + 0x60 ], %g2 <== NOT EXECUTED 4005823c: 9a a2 40 03 subcc %o1, %g3, %o5 <== NOT EXECUTED 40058240: 98 62 00 02 subx %o0, %g2, %o4 <== NOT EXECUTED 40058244: 92 10 00 0d mov %o5, %o1 <== NOT EXECUTED 40058248: 90 10 00 0c mov %o4, %o0 <== NOT EXECUTED 4005824c: d0 3e 40 00 std %o0, [ %i1 ] <== NOT EXECUTED ); /* * Determine cpu usage since period initiated. */ _Thread_Get_CPU_time_used( owning_thread, &used ); 40058250: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 40058254: 7f ff b3 90 call 40045094 <_Thread_Get_CPU_time_used> <== NOT EXECUTED 40058258: 92 07 bf f8 add %fp, -8, %o1 <== NOT EXECUTED 4005825c: c4 1e 20 58 ldd [ %i0 + 0x58 ], %g2 <== NOT EXECUTED 40058260: f8 1f bf f8 ldd [ %fp + -8 ], %i4 <== NOT EXECUTED /* * The cpu usage info was reset while executing. Can't * determine a status. */ if ( _Timestamp_Less_than( &used, &the_period->cpu_usage_period_initiated ) ) 40058264: 80 a0 80 1c cmp %g2, %i4 <== NOT EXECUTED 40058268: 14 80 00 0e bg 400582a0 <_Rate_monotonic_Get_status+0x74> <== NOT EXECUTED 4005826c: b0 10 20 00 clr %i0 <== NOT EXECUTED 40058270: 02 80 00 09 be 40058294 <_Rate_monotonic_Get_status+0x68> <== NOT EXECUTED 40058274: 80 a0 c0 1d cmp %g3, %i5 <== NOT EXECUTED 40058278: 9a a7 40 03 subcc %i5, %g3, %o5 <== NOT EXECUTED &the_period->cpu_usage_period_initiated, &used, cpu_since_last_period ); return true; 4005827c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED 40058280: 98 67 00 02 subx %i4, %g2, %o4 <== NOT EXECUTED } 40058284: b0 0e 20 01 and %i0, 1, %i0 <== NOT EXECUTED 40058288: d8 3e 80 00 std %o4, [ %i2 ] <== NOT EXECUTED 4005828c: 81 c7 e0 08 ret <== NOT EXECUTED 40058290: 81 e8 00 00 restore <== NOT EXECUTED if ( _Timestamp_Less_than( &used, &the_period->cpu_usage_period_initiated ) ) 40058294: 08 bf ff fa bleu 4005827c <_Rate_monotonic_Get_status+0x50> <== NOT EXECUTED 40058298: 9a a7 40 03 subcc %i5, %g3, %o5 <== NOT EXECUTED return false; 4005829c: b0 10 20 00 clr %i0 <== NOT EXECUTED } 400582a0: b0 0e 20 01 and %i0, 1, %i0 <== NOT EXECUTED 400582a4: 81 c7 e0 08 ret <== NOT EXECUTED 400582a8: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40009358 <_Scheduler_default_Cancel_job>: { (void) scheduler; (void) the_thread; (void) priority_node; (void) queue_context; } 40009358: 81 c3 e0 08 retl <== NOT EXECUTED 4000935c: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40009350 <_Scheduler_default_Release_job>: (void) scheduler; (void) the_thread; (void) priority_node; (void) deadline; (void) queue_context; } 40009350: 81 c3 e0 08 retl <== NOT EXECUTED 40009354: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40009384 <_Scheduler_default_Tick>: void _Scheduler_default_Tick( const Scheduler_Control *scheduler, Thread_Control *executing ) { 40009384: 9d e3 bf a0 save %sp, -96, %sp /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 40009388: c2 0e 60 89 ldub [ %i1 + 0x89 ], %g1 4000938c: 80 a0 60 00 cmp %g1, 0 40009390: 02 80 00 24 be 40009420 <_Scheduler_default_Tick+0x9c> 40009394: 01 00 00 00 nop return; if ( !_States_Is_ready( executing->current_state ) ) 40009398: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 4000939c: 80 a0 60 00 cmp %g1, 0 400093a0: 12 80 00 20 bne 40009420 <_Scheduler_default_Tick+0x9c> <== NEVER TAKEN 400093a4: 01 00 00 00 nop /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 400093a8: c2 06 60 90 ld [ %i1 + 0x90 ], %g1 400093ac: 80 a0 60 01 cmp %g1, 1 400093b0: 0a 80 00 0e bcs 400093e8 <_Scheduler_default_Tick+0x64> <== ALWAYS TAKEN 400093b4: 80 a0 60 02 cmp %g1, 2 400093b8: 08 80 00 0e bleu 400093f0 <_Scheduler_default_Tick+0x6c> <== NOT EXECUTED 400093bc: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 400093c0: 12 80 00 18 bne 40009420 <_Scheduler_default_Tick+0x9c> <== NOT EXECUTED 400093c4: 01 00 00 00 nop <== NOT EXECUTED } break; #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 400093c8: c2 06 60 8c ld [ %i1 + 0x8c ], %g1 <== NOT EXECUTED 400093cc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400093d0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400093d4: 12 80 00 05 bne 400093e8 <_Scheduler_default_Tick+0x64> <== NOT EXECUTED 400093d8: c2 26 60 8c st %g1, [ %i1 + 0x8c ] <== NOT EXECUTED (*executing->budget_callout)( executing ); 400093dc: c2 06 60 94 ld [ %i1 + 0x94 ], %g1 <== NOT EXECUTED 400093e0: 9f c0 40 00 call %g1 <== NOT EXECUTED 400093e4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED break; #endif } } 400093e8: 81 c7 e0 08 ret 400093ec: 81 e8 00 00 restore if ( (int)(--executing->cpu_time_budget) <= 0 ) { 400093f0: c2 06 60 8c ld [ %i1 + 0x8c ], %g1 <== NOT EXECUTED 400093f4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400093f8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400093fc: 14 bf ff fb bg 400093e8 <_Scheduler_default_Tick+0x64> <== NOT EXECUTED 40009400: c2 26 60 8c st %g1, [ %i1 + 0x8c ] <== NOT EXECUTED _Thread_Yield( executing ); 40009404: 40 00 09 0c call 4000b834 <_Thread_Yield> <== NOT EXECUTED 40009408: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED rtems_configuration_get_ticks_per_timeslice(); 4000940c: 03 10 00 3f sethi %hi(0x4000fc00), %g1 <== NOT EXECUTED executing->cpu_time_budget = 40009410: c2 00 62 ac ld [ %g1 + 0x2ac ], %g1 ! 4000feac <== NOT EXECUTED 40009414: c2 26 60 8c st %g1, [ %i1 + 0x8c ] <== NOT EXECUTED 40009418: 81 c7 e0 08 ret <== NOT EXECUTED 4000941c: 81 e8 00 00 restore <== NOT EXECUTED 40009420: 81 c7 e0 08 ret 40009424: 81 e8 00 00 restore =============================================================================== 400094f4 <_Scheduler_priority_Block>: void _Scheduler_priority_Block( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 400094f4: 9d e3 bf a0 save %sp, -96, %sp Chain_Control *ready_chain = ready_queue->ready_chain; 400094f8: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1 if ( _Chain_Has_only_one_node( ready_chain ) ) { 400094fc: c6 00 40 00 ld [ %g1 ], %g3 40009500: c4 00 60 08 ld [ %g1 + 8 ], %g2 40009504: 80 a0 c0 02 cmp %g3, %g2 40009508: 22 80 00 31 be,a 400095cc <_Scheduler_priority_Block+0xd8> 4000950c: c6 06 a0 40 ld [ %i2 + 0x40 ], %g3 next = the_node->next; 40009510: c4 06 40 00 ld [ %i1 ], %g2 previous = the_node->previous; 40009514: c2 06 60 04 ld [ %i1 + 4 ], %g1 next->previous = previous; 40009518: c2 20 a0 04 st %g1, [ %g2 + 4 ] previous->next = next; 4000951c: c4 20 40 00 st %g2, [ %g1 ] RTEMS_INLINE_ROUTINE bool _Thread_Is_executing ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Executing ); 40009520: 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 ) ) { 40009524: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1 40009528: 80 a6 40 01 cmp %i1, %g1 4000952c: 02 80 00 07 be 40009548 <_Scheduler_priority_Block+0x54> <== ALWAYS TAKEN 40009530: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3 40009534: 80 a6 40 1b cmp %i1, %i3 <== NOT EXECUTED 40009538: 22 80 00 05 be,a 4000954c <_Scheduler_priority_Block+0x58> <== NOT EXECUTED 4000953c: f4 06 00 00 ld [ %i0 ], %i2 <== NOT EXECUTED the_thread, node, _Scheduler_priority_Extract_body, _Scheduler_priority_Schedule_body ); } 40009540: 81 c7 e0 08 ret <== NOT EXECUTED 40009544: 81 e8 00 00 restore <== NOT EXECUTED 40009548: f4 06 00 00 ld [ %i0 ], %i2 bit_number = (unsigned int) __builtin_clz( value ) 4000954c: 40 00 15 f7 call 4000ed28 <__clzsi2> 40009550: d0 16 80 00 lduh [ %i2 ], %o0 40009554: ba 02 3f f0 add %o0, -16, %i5 minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 40009558: 83 2f 60 01 sll %i5, 1, %g1 return (_Priority_Bits_index( major ) << 4) + 4000955c: bb 2f 60 04 sll %i5, 4, %i5 minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 40009560: 82 06 80 01 add %i2, %g1, %g1 bit_number = (unsigned int) __builtin_clz( value ) 40009564: 40 00 15 f1 call 4000ed28 <__clzsi2> 40009568: d0 10 60 02 lduh [ %g1 + 2 ], %o0 Chain_Node *first = _Chain_First( &ready_queues[ index ] ); 4000956c: 90 02 00 1d add %o0, %i5, %o0 40009570: 90 02 3f f0 add %o0, -16, %o0 return _Chain_Immutable_head( the_chain )->next; 40009574: bb 2a 20 01 sll %o0, 1, %i5 40009578: 90 07 40 08 add %i5, %o0, %o0 4000957c: 91 2a 20 02 sll %o0, 2, %o0 40009580: b4 06 80 08 add %i2, %o0, %i2 40009584: 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 ) ) { 40009588: 80 a7 40 1b cmp %i5, %i3 4000958c: 02 80 00 0e be 400095c4 <_Scheduler_priority_Block+0xd0> <== NEVER TAKEN 40009590: 01 00 00 00 nop *time = _Timecounter_Sbinuptime(); 40009594: 7f ff fa 72 call 40007f5c <_Timecounter_Sbinuptime> 40009598: e0 1f 20 28 ldd [ %i4 + 0x28 ], %l0 4000959c: d0 3f 20 28 std %o0, [ %i4 + 0x28 ] const Timestamp_Control *_start, const Timestamp_Control *_end, Timestamp_Control *_result ) { *_result = *_end - *_start; 400095a0: b2 a2 40 11 subcc %o1, %l1, %i1 *_time += *_add; 400095a4: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4 *_result = *_end - *_start; 400095a8: b0 62 00 10 subx %o0, %l0, %i0 *_time += *_add; 400095ac: 86 83 40 19 addcc %o5, %i1, %g3 400095b0: 84 43 00 18 addx %o4, %i0, %g2 400095b4: 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; 400095b8: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 400095bc: fa 21 a0 24 st %i5, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 400095c0: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] 400095c4: 81 c7 e0 08 ret 400095c8: 81 e8 00 00 restore *bit_map_info->minor &= bit_map_info->block_minor; 400095cc: c4 10 c0 00 lduh [ %g3 ], %g2 400095d0: f8 16 a0 4a lduh [ %i2 + 0x4a ], %i4 400095d4: c8 06 00 00 ld [ %i0 ], %g4 return &the_chain->Tail.Node; 400095d8: ba 00 60 04 add %g1, 4, %i5 head->previous = NULL; 400095dc: c0 20 60 04 clr [ %g1 + 4 ] 400095e0: 84 08 80 1c and %g2, %i4, %g2 head->next = tail; 400095e4: fa 20 40 00 st %i5, [ %g1 ] if ( *bit_map_info->minor == 0 ) 400095e8: 80 a0 a0 00 cmp %g2, 0 tail->previous = head; 400095ec: c2 20 60 08 st %g1, [ %g1 + 8 ] 400095f0: 12 bf ff cc bne 40009520 <_Scheduler_priority_Block+0x2c> <== NEVER TAKEN 400095f4: c4 30 c0 00 sth %g2, [ %g3 ] bit_map->major_bit_map &= bit_map_info->block_major; 400095f8: c2 11 00 00 lduh [ %g4 ], %g1 400095fc: c4 16 a0 48 lduh [ %i2 + 0x48 ], %g2 40009600: 82 08 40 02 and %g1, %g2, %g1 40009604: 10 bf ff c7 b 40009520 <_Scheduler_priority_Block+0x2c> 40009608: c2 31 00 00 sth %g1, [ %g4 ] =============================================================================== 400097f4 <_Scheduler_priority_Schedule>: void _Scheduler_priority_Schedule( const Scheduler_Control *scheduler, Thread_Control *the_thread ) { 400097f4: 9d e3 bf a0 save %sp, -96, %sp 400097f8: f8 06 00 00 ld [ %i0 ], %i4 bit_number = (unsigned int) __builtin_clz( value ) 400097fc: 40 00 15 4b call 4000ed28 <__clzsi2> 40009800: d0 17 00 00 lduh [ %i4 ], %o0 40009804: ba 02 3f f0 add %o0, -16, %i5 minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 40009808: 83 2f 60 01 sll %i5, 1, %g1 return (_Priority_Bits_index( major ) << 4) + 4000980c: bb 2f 60 04 sll %i5, 4, %i5 minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 40009810: 82 07 00 01 add %i4, %g1, %g1 bit_number = (unsigned int) __builtin_clz( value ) 40009814: 40 00 15 45 call 4000ed28 <__clzsi2> 40009818: d0 10 60 02 lduh [ %g1 + 2 ], %o0 4000981c: 90 02 00 1d add %o0, %i5, %o0 40009820: 90 02 3f f0 add %o0, -16, %o0 return _Chain_Immutable_head( the_chain )->next; 40009824: bb 2a 20 01 sll %o0, 1, %i5 Thread_Control *heir = _Thread_Heir; 40009828: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3 4000982c: 90 07 40 08 add %i5, %o0, %o0 40009830: 91 2a 20 02 sll %o0, 2, %o0 40009834: b8 07 00 08 add %i4, %o0, %i4 40009838: fa 07 20 24 ld [ %i4 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000983c: 80 a7 40 1b cmp %i5, %i3 40009840: 02 80 00 06 be 40009858 <_Scheduler_priority_Schedule+0x64> <== ALWAYS TAKEN 40009844: b4 10 00 06 mov %g6, %i2 40009848: c2 0e e0 89 ldub [ %i3 + 0x89 ], %g1 <== NOT EXECUTED 4000984c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009850: 12 80 00 04 bne 40009860 <_Scheduler_priority_Schedule+0x6c> <== NOT EXECUTED 40009854: 01 00 00 00 nop <== NOT EXECUTED _Scheduler_priority_Schedule_body( scheduler, the_thread, false ); } 40009858: 81 c7 e0 08 ret 4000985c: 81 e8 00 00 restore 40009860: 7f ff f9 bf call 40007f5c <_Timecounter_Sbinuptime> <== NOT EXECUTED 40009864: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 <== NOT EXECUTED 40009868: d0 3e a0 28 std %o0, [ %i2 + 0x28 ] <== NOT EXECUTED *_result = *_end - *_start; 4000986c: b2 a2 40 11 subcc %o1, %l1, %i1 <== NOT EXECUTED *_time += *_add; 40009870: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4 <== NOT EXECUTED *_result = *_end - *_start; 40009874: b0 62 00 10 subx %o0, %l0, %i0 <== NOT EXECUTED *_time += *_add; 40009878: 86 83 40 19 addcc %o5, %i1, %g3 <== NOT EXECUTED 4000987c: 84 43 00 18 addx %o4, %i0, %g2 <== NOT EXECUTED 40009880: c4 3e e0 98 std %g2, [ %i3 + 0x98 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 40009884: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = new_heir; 40009888: fa 21 a0 24 st %i5, [ %g6 + 0x24 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 4000988c: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] <== NOT EXECUTED 40009890: 81 c7 e0 08 ret <== NOT EXECUTED 40009894: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40009898 <_Scheduler_priority_Unblock>: void _Scheduler_priority_Unblock ( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 40009898: 9d e3 bf a0 save %sp, -96, %sp 4000989c: f6 06 a0 34 ld [ %i2 + 0x34 ], %i3 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 ) { 400098a0: c2 06 a0 38 ld [ %i2 + 0x38 ], %g1 unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority ); 400098a4: 87 36 e0 01 srl %i3, 1, %g3 if ( unmapped_priority != the_node->Ready_queue.current_priority ) { 400098a8: 80 a0 40 03 cmp %g1, %g3 400098ac: 02 80 00 4a be 400099d4 <_Scheduler_priority_Unblock+0x13c> <== ALWAYS TAKEN 400098b0: fa 06 00 00 ld [ %i0 ], %i5 ready_queue->ready_chain = &ready_queues[ new_priority ]; 400098b4: b9 28 e0 01 sll %g3, 1, %i4 <== NOT EXECUTED 400098b8: b8 07 00 03 add %i4, %g3, %i4 <== NOT EXECUTED 400098bc: b9 2f 20 02 sll %i4, 2, %i4 <== NOT EXECUTED _Scheduler_priority_Ready_queue_update( 400098c0: 84 07 60 24 add %i5, 0x24, %g2 <== NOT EXECUTED 400098c4: 84 00 80 1c add %g2, %i4, %g2 <== NOT EXECUTED return the_priority % 16; 400098c8: b8 08 e0 0f and %g3, 0xf, %i4 <== NOT EXECUTED return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 400098cc: 09 00 00 20 sethi %hi(0x8000), %g4 <== NOT EXECUTED return the_priority / 16; 400098d0: 83 36 e0 05 srl %i3, 5, %g1 <== NOT EXECUTED ready_queue->current_priority = new_priority; 400098d4: c6 26 a0 38 st %g3, [ %i2 + 0x38 ] <== NOT EXECUTED return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 400098d8: b1 31 00 01 srl %g4, %g1, %i0 <== NOT EXECUTED 400098dc: 87 31 00 1c srl %g4, %i4, %g3 <== NOT EXECUTED bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 400098e0: 82 00 60 01 inc %g1 <== NOT EXECUTED bit_map_info->block_major = (Priority_bit_map_Word) ~mask; 400098e4: 9e 38 00 18 xnor %g0, %i0, %o7 <== NOT EXECUTED bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 400098e8: 83 28 60 01 sll %g1, 1, %g1 <== NOT EXECUTED bit_map_info->block_minor = (Priority_bit_map_Word) ~mask; 400098ec: b8 38 00 03 xnor %g0, %g3, %i4 <== NOT EXECUTED bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 400098f0: 82 07 40 01 add %i5, %g1, %g1 <== NOT EXECUTED ready_queue->ready_chain = &ready_queues[ new_priority ]; 400098f4: c4 26 a0 3c st %g2, [ %i2 + 0x3c ] <== NOT EXECUTED return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 400098f8: 88 10 00 03 mov %g3, %g4 <== NOT EXECUTED bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 400098fc: c2 26 a0 40 st %g1, [ %i2 + 0x40 ] <== NOT EXECUTED bit_map_info->ready_major = mask; 40009900: f0 36 a0 44 sth %i0, [ %i2 + 0x44 ] <== NOT EXECUTED bit_map_info->block_major = (Priority_bit_map_Word) ~mask; 40009904: de 36 a0 48 sth %o7, [ %i2 + 0x48 ] <== NOT EXECUTED bit_map_info->ready_minor = mask; 40009908: c6 36 a0 46 sth %g3, [ %i2 + 0x46 ] <== NOT EXECUTED bit_map_info->block_minor = (Priority_bit_map_Word) ~mask; 4000990c: f8 36 a0 4a sth %i4, [ %i2 + 0x4a ] <== NOT EXECUTED return &the_chain->Tail.Node; 40009910: b8 00 a0 04 add %g2, 4, %i4 old_last = tail->previous; 40009914: c6 00 a0 08 ld [ %g2 + 8 ], %g3 the_node->next = tail; 40009918: f8 26 40 00 st %i4, [ %i1 ] tail->previous = the_node; 4000991c: f2 20 a0 08 st %i1, [ %g2 + 8 ] old_last->next = the_node; 40009920: f2 20 c0 00 st %i1, [ %g3 ] *bit_map_info->minor |= bit_map_info->ready_minor; 40009924: c4 10 40 00 lduh [ %g1 ], %g2 the_node->previous = old_last; 40009928: c6 26 60 04 st %g3, [ %i1 + 4 ] 4000992c: 84 10 80 04 or %g2, %g4, %g2 40009930: 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 ) ) { 40009934: f8 01 a0 24 ld [ %g6 + 0x24 ], %i4 bit_map->major_bit_map |= bit_map_info->ready_major; 40009938: c4 16 a0 44 lduh [ %i2 + 0x44 ], %g2 4000993c: c2 17 40 00 lduh [ %i5 ], %g1 40009940: 82 10 40 02 or %g1, %g2, %g1 40009944: c4 07 20 38 ld [ %i4 + 0x38 ], %g2 40009948: c2 37 40 00 sth %g1, [ %i5 ] 4000994c: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1 40009950: 80 a0 60 00 cmp %g1, 0 40009954: 18 80 00 09 bgu 40009978 <_Scheduler_priority_Unblock+0xe0> <== NEVER TAKEN 40009958: b0 10 00 06 mov %g6, %i0 4000995c: 22 80 00 04 be,a 4000996c <_Scheduler_priority_Unblock+0xd4> <== ALWAYS TAKEN 40009960: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 _Scheduler_Update_heir( the_thread, priority == PRIORITY_PSEUDO_ISR ); } } 40009964: 81 c7 e0 08 ret <== NOT EXECUTED 40009968: 81 e8 00 00 restore <== NOT EXECUTED if ( priority < _Thread_Get_priority( _Thread_Heir ) ) { 4000996c: 80 a0 40 1b cmp %g1, %i3 40009970: 08 80 00 17 bleu 400099cc <_Scheduler_priority_Unblock+0x134> 40009974: 01 00 00 00 nop if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40009978: 80 a7 00 19 cmp %i4, %i1 4000997c: 02 bf ff fa be 40009964 <_Scheduler_priority_Unblock+0xcc> <== NEVER TAKEN 40009980: 80 a6 e0 00 cmp %i3, 0 40009984: 02 80 00 06 be 4000999c <_Scheduler_priority_Unblock+0x104> <== NEVER TAKEN 40009988: 01 00 00 00 nop 4000998c: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1 40009990: 80 a0 60 00 cmp %g1, 0 40009994: 02 80 00 0e be 400099cc <_Scheduler_priority_Unblock+0x134> <== NEVER TAKEN 40009998: 01 00 00 00 nop 4000999c: 7f ff f9 70 call 40007f5c <_Timecounter_Sbinuptime> 400099a0: e0 1e 20 28 ldd [ %i0 + 0x28 ], %l0 400099a4: d0 3e 20 28 std %o0, [ %i0 + 0x28 ] *_result = *_end - *_start; 400099a8: b6 a2 40 11 subcc %o1, %l1, %i3 *_time += *_add; 400099ac: d8 1f 20 98 ldd [ %i4 + 0x98 ], %o4 *_result = *_end - *_start; 400099b0: b4 62 00 10 subx %o0, %l0, %i2 *_time += *_add; 400099b4: 86 83 40 1b addcc %o5, %i3, %g3 400099b8: 84 43 00 1a addx %o4, %i2, %g2 400099bc: c4 3f 20 98 std %g2, [ %i4 + 0x98 ] _Thread_Dispatch_necessary = true; 400099c0: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 400099c4: f2 21 a0 24 st %i1, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 400099c8: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] } 400099cc: 81 c7 e0 08 ret 400099d0: 81 e8 00 00 restore 400099d4: c4 06 a0 3c ld [ %i2 + 0x3c ], %g2 400099d8: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1 400099dc: 10 bf ff cd b 40009910 <_Scheduler_priority_Unblock+0x78> 400099e0: c8 16 a0 46 lduh [ %i2 + 0x46 ], %g4 =============================================================================== 4000960c <_Scheduler_priority_Update_priority>: void _Scheduler_priority_Update_priority( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 4000960c: 9d e3 bf a0 save %sp, -96, %sp Scheduler_priority_Context *context; Scheduler_priority_Node *the_node; unsigned int new_priority; unsigned int unmapped_priority; if ( !_Thread_Is_ready( the_thread ) ) { 40009610: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 40009614: 80 a0 60 00 cmp %g1, 0 40009618: 12 80 00 5c bne 40009788 <_Scheduler_priority_Update_priority+0x17c> <== NEVER TAKEN 4000961c: 01 00 00 00 nop /* Nothing to do */ return; } the_node = _Scheduler_priority_Node_downcast( node ); new_priority = (unsigned int) 40009620: 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 ) { 40009624: c2 06 a0 38 ld [ %i2 + 0x38 ], %g1 unmapped_priority = SCHEDULER_PRIORITY_UNMAP( new_priority ); 40009628: 87 36 e0 01 srl %i3, 1, %g3 if ( unmapped_priority == the_node->Ready_queue.current_priority ) { 4000962c: 80 a0 40 03 cmp %g1, %g3 40009630: 02 80 00 56 be 40009788 <_Scheduler_priority_Update_priority+0x17c> <== NEVER TAKEN 40009634: 01 00 00 00 nop Chain_Control *ready_chain = ready_queue->ready_chain; 40009638: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1 if ( _Chain_Has_only_one_node( ready_chain ) ) { 4000963c: c8 00 40 00 ld [ %g1 ], %g4 40009640: c4 00 60 08 ld [ %g1 + 8 ], %g2 40009644: 80 a1 00 02 cmp %g4, %g2 40009648: 02 80 00 52 be 40009790 <_Scheduler_priority_Update_priority+0x184> 4000964c: fa 06 00 00 ld [ %i0 ], %i5 next = the_node->next; 40009650: c4 06 40 00 ld [ %i1 ], %g2 previous = the_node->previous; 40009654: c2 06 60 04 ld [ %i1 + 4 ], %g1 next->previous = previous; 40009658: c2 20 a0 04 st %g1, [ %g2 + 4 ] previous->next = next; 4000965c: c4 20 40 00 st %g2, [ %g1 ] return the_priority / 16; 40009660: 85 36 e0 05 srl %i3, 5, %g2 return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 40009664: 03 00 00 20 sethi %hi(0x8000), %g1 ready_queue->ready_chain = &ready_queues[ new_priority ]; 40009668: 89 28 e0 01 sll %g3, 1, %g4 4000966c: 9f 30 40 02 srl %g1, %g2, %o7 40009670: 88 01 00 03 add %g4, %g3, %g4 return the_priority % 16; 40009674: 96 08 e0 0f and %g3, 0xf, %o3 &the_thread->Object.Node, &the_node->Ready_queue, &context->Bit_map ); _Scheduler_priority_Ready_queue_update( 40009678: 9a 07 60 24 add %i5, 0x24, %o5 return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 4000967c: 83 30 40 0b srl %g1, %o3, %g1 bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 40009680: b8 00 a0 01 add %g2, 1, %i4 40009684: 89 29 20 02 sll %g4, 2, %g4 40009688: b9 2f 20 01 sll %i4, 1, %i4 4000968c: b0 03 40 04 add %o5, %g4, %i0 40009690: b8 07 40 1c add %i5, %i4, %i4 bit_map_info->block_major = (Priority_bit_map_Word) ~mask; 40009694: 98 38 00 0f xnor %g0, %o7, %o4 ready_queue->current_priority = new_priority; 40009698: c6 26 a0 38 st %g3, [ %i2 + 0x38 ] bit_map_info->block_minor = (Priority_bit_map_Word) ~mask; 4000969c: 86 38 00 01 xnor %g0, %g1, %g3 ready_queue->ready_chain = &ready_queues[ new_priority ]; 400096a0: f0 26 a0 3c st %i0, [ %i2 + 0x3c ] unmapped_priority, &context->Bit_map, &context->Ready[ 0 ] ); if ( SCHEDULER_PRIORITY_IS_APPEND( new_priority ) ) { 400096a4: 80 8e e0 01 btst 1, %i3 bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 400096a8: f8 26 a0 40 st %i4, [ %i2 + 0x40 ] bit_map_info->ready_major = mask; 400096ac: de 36 a0 44 sth %o7, [ %i2 + 0x44 ] bit_map_info->block_major = (Priority_bit_map_Word) ~mask; 400096b0: d8 36 a0 48 sth %o4, [ %i2 + 0x48 ] bit_map_info->ready_minor = mask; 400096b4: c2 36 a0 46 sth %g1, [ %i2 + 0x46 ] 400096b8: 02 80 00 46 be 400097d0 <_Scheduler_priority_Update_priority+0x1c4> 400096bc: c6 36 a0 4a sth %g3, [ %i2 + 0x4a ] old_last = tail->previous; 400096c0: c6 06 20 08 ld [ %i0 + 8 ], %g3 return &the_chain->Tail.Node; 400096c4: 88 06 20 04 add %i0, 4, %g4 the_node->next = tail; 400096c8: c8 26 40 00 st %g4, [ %i1 ] 400096cc: 85 28 a0 01 sll %g2, 1, %g2 tail->previous = the_node; 400096d0: f2 26 20 08 st %i1, [ %i0 + 8 ] 400096d4: 84 07 40 02 add %i5, %g2, %g2 old_last->next = the_node; 400096d8: f2 20 c0 00 st %i1, [ %g3 ] *bit_map_info->minor |= bit_map_info->ready_minor; 400096dc: c8 10 a0 02 lduh [ %g2 + 2 ], %g4 the_node->previous = old_last; 400096e0: c6 26 60 04 st %g3, [ %i1 + 4 ] 400096e4: 82 10 40 04 or %g1, %g4, %g1 400096e8: c2 30 a0 02 sth %g1, [ %g2 + 2 ] bit_map->major_bit_map |= bit_map_info->ready_major; 400096ec: c4 16 a0 44 lduh [ %i2 + 0x44 ], %g2 400096f0: c2 17 40 00 lduh [ %i5 ], %g1 400096f4: 82 10 40 02 or %g1, %g2, %g1 400096f8: c2 37 40 00 sth %g1, [ %i5 ] bit_number = (unsigned int) __builtin_clz( value ) 400096fc: 40 00 15 8b call 4000ed28 <__clzsi2> 40009700: d0 17 40 00 lduh [ %i5 ], %o0 40009704: b8 02 3f f0 add %o0, -16, %i4 minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 40009708: 83 2f 20 01 sll %i4, 1, %g1 return (_Priority_Bits_index( major ) << 4) + 4000970c: b9 2f 20 04 sll %i4, 4, %i4 minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 40009710: 82 07 40 01 add %i5, %g1, %g1 bit_number = (unsigned int) __builtin_clz( value ) 40009714: 40 00 15 85 call 4000ed28 <__clzsi2> 40009718: d0 10 60 02 lduh [ %g1 + 2 ], %o0 Chain_Node *first = _Chain_First( &ready_queues[ index ] ); 4000971c: 90 02 00 1c add %o0, %i4, %o0 Thread_Control *heir = _Thread_Heir; 40009720: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3 40009724: 90 02 3f f0 add %o0, -16, %o0 return _Chain_Immutable_head( the_chain )->next; 40009728: b9 2a 20 01 sll %o0, 1, %i4 4000972c: 90 07 00 08 add %i4, %o0, %o0 40009730: 91 2a 20 02 sll %o0, 2, %o0 40009734: ba 07 40 08 add %i5, %o0, %i5 40009738: fa 07 60 24 ld [ %i5 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000973c: 80 a7 40 1b cmp %i5, %i3 40009740: 02 80 00 12 be 40009788 <_Scheduler_priority_Update_priority+0x17c> <== ALWAYS TAKEN 40009744: b4 10 00 06 mov %g6, %i2 40009748: c2 0e e0 89 ldub [ %i3 + 0x89 ], %g1 <== NOT EXECUTED 4000974c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009750: 02 80 00 0e be 40009788 <_Scheduler_priority_Update_priority+0x17c> <== NOT EXECUTED 40009754: 01 00 00 00 nop <== NOT EXECUTED 40009758: 7f ff fa 01 call 40007f5c <_Timecounter_Sbinuptime> <== NOT EXECUTED 4000975c: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 <== NOT EXECUTED 40009760: d0 3e a0 28 std %o0, [ %i2 + 0x28 ] <== NOT EXECUTED *_result = *_end - *_start; 40009764: b2 a2 40 11 subcc %o1, %l1, %i1 <== NOT EXECUTED *_time += *_add; 40009768: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4 <== NOT EXECUTED *_result = *_end - *_start; 4000976c: b0 62 00 10 subx %o0, %l0, %i0 <== NOT EXECUTED *_time += *_add; 40009770: 86 83 40 19 addcc %o5, %i1, %g3 <== NOT EXECUTED 40009774: 84 43 00 18 addx %o4, %i0, %g2 <== NOT EXECUTED 40009778: c4 3e e0 98 std %g2, [ %i3 + 0x98 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 4000977c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = new_heir; 40009780: fa 21 a0 24 st %i5, [ %g6 + 0x24 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 40009784: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] <== NOT EXECUTED &context->Bit_map ); } _Scheduler_priority_Schedule_body( scheduler, the_thread, false ); } 40009788: 81 c7 e0 08 ret 4000978c: 81 e8 00 00 restore *bit_map_info->minor &= bit_map_info->block_minor; 40009790: c8 06 a0 40 ld [ %i2 + 0x40 ], %g4 40009794: c4 11 00 00 lduh [ %g4 ], %g2 40009798: f0 16 a0 4a lduh [ %i2 + 0x4a ], %i0 return &the_chain->Tail.Node; 4000979c: b8 00 60 04 add %g1, 4, %i4 head->previous = NULL; 400097a0: c0 20 60 04 clr [ %g1 + 4 ] 400097a4: 84 08 80 18 and %g2, %i0, %g2 head->next = tail; 400097a8: f8 20 40 00 st %i4, [ %g1 ] if ( *bit_map_info->minor == 0 ) 400097ac: 80 a0 a0 00 cmp %g2, 0 tail->previous = head; 400097b0: c2 20 60 08 st %g1, [ %g1 + 8 ] 400097b4: 12 bf ff ab bne 40009660 <_Scheduler_priority_Update_priority+0x54> <== NEVER TAKEN 400097b8: c4 31 00 00 sth %g2, [ %g4 ] bit_map->major_bit_map &= bit_map_info->block_major; 400097bc: c2 17 40 00 lduh [ %i5 ], %g1 400097c0: c4 16 a0 48 lduh [ %i2 + 0x48 ], %g2 400097c4: 82 08 40 02 and %g1, %g2, %g1 400097c8: 10 bf ff a6 b 40009660 <_Scheduler_priority_Update_priority+0x54> 400097cc: c2 37 40 00 sth %g1, [ %i5 ] the_node->previous = after_node; 400097d0: f0 26 60 04 st %i0, [ %i1 + 4 ] 400097d4: 85 28 a0 01 sll %g2, 1, %g2 before_node = after_node->next; 400097d8: c6 03 40 04 ld [ %o5 + %g4 ], %g3 after_node->next = the_node; 400097dc: f2 23 40 04 st %i1, [ %o5 + %g4 ] 400097e0: 84 07 40 02 add %i5, %g2, %g2 the_node->next = before_node; 400097e4: c6 26 40 00 st %g3, [ %i1 ] *bit_map_info->minor |= bit_map_info->ready_minor; 400097e8: c8 10 a0 02 lduh [ %g2 + 2 ], %g4 before_node->previous = the_node; 400097ec: 10 bf ff be b 400096e4 <_Scheduler_priority_Update_priority+0xd8> 400097f0: f2 20 e0 04 st %i1, [ %g3 + 4 ] =============================================================================== 400099e4 <_Scheduler_priority_Yield>: void _Scheduler_priority_Yield( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 400099e4: 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; 400099e8: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1 <== NOT EXECUTED if ( !_Chain_Has_only_one_node( ready_chain ) ) { 400099ec: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED 400099f0: c4 00 40 00 ld [ %g1 ], %g2 <== NOT EXECUTED 400099f4: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED 400099f8: 02 80 00 0b be 40009a24 <_Scheduler_priority_Yield+0x40> <== NOT EXECUTED 400099fc: 88 00 60 04 add %g1, 4, %g4 <== NOT EXECUTED previous = the_node->previous; 40009a00: c4 06 60 04 ld [ %i1 + 4 ], %g2 <== NOT EXECUTED next = the_node->next; 40009a04: c6 06 40 00 ld [ %i1 ], %g3 <== NOT EXECUTED next->previous = previous; 40009a08: c4 20 e0 04 st %g2, [ %g3 + 4 ] <== NOT EXECUTED previous->next = next; 40009a0c: c6 20 80 00 st %g3, [ %g2 ] <== NOT EXECUTED old_last = tail->previous; 40009a10: c4 00 60 08 ld [ %g1 + 8 ], %g2 <== NOT EXECUTED the_node->next = tail; 40009a14: c8 26 40 00 st %g4, [ %i1 ] <== NOT EXECUTED tail->previous = the_node; 40009a18: f2 20 60 08 st %i1, [ %g1 + 8 ] <== NOT EXECUTED old_last->next = the_node; 40009a1c: f2 20 80 00 st %i1, [ %g2 ] <== NOT EXECUTED the_node->previous = old_last; 40009a20: c4 26 60 04 st %g2, [ %i1 + 4 ] <== NOT EXECUTED 40009a24: f8 06 00 00 ld [ %i0 ], %i4 <== NOT EXECUTED bit_number = (unsigned int) __builtin_clz( value ) 40009a28: 40 00 14 c0 call 4000ed28 <__clzsi2> <== NOT EXECUTED 40009a2c: d0 17 00 00 lduh [ %i4 ], %o0 <== NOT EXECUTED 40009a30: ba 02 3f f0 add %o0, -16, %i5 <== NOT EXECUTED minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 40009a34: 83 2f 60 01 sll %i5, 1, %g1 <== NOT EXECUTED return (_Priority_Bits_index( major ) << 4) + 40009a38: bb 2f 60 04 sll %i5, 4, %i5 <== NOT EXECUTED minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 40009a3c: 82 07 00 01 add %i4, %g1, %g1 <== NOT EXECUTED bit_number = (unsigned int) __builtin_clz( value ) 40009a40: 40 00 14 ba call 4000ed28 <__clzsi2> <== NOT EXECUTED 40009a44: d0 10 60 02 lduh [ %g1 + 2 ], %o0 <== NOT EXECUTED Chain_Node *first = _Chain_First( &ready_queues[ index ] ); 40009a48: 90 02 00 1d add %o0, %i5, %o0 <== NOT EXECUTED 40009a4c: 90 02 3f f0 add %o0, -16, %o0 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 40009a50: bb 2a 20 01 sll %o0, 1, %i5 <== NOT EXECUTED Thread_Control *heir = _Thread_Heir; 40009a54: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3 <== NOT EXECUTED 40009a58: 90 07 40 08 add %i5, %o0, %o0 <== NOT EXECUTED 40009a5c: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED 40009a60: b8 07 00 08 add %i4, %o0, %i4 <== NOT EXECUTED 40009a64: fa 07 20 24 ld [ %i4 + 0x24 ], %i5 <== NOT EXECUTED if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40009a68: 80 a7 40 1b cmp %i5, %i3 <== NOT EXECUTED 40009a6c: 02 80 00 0e be 40009aa4 <_Scheduler_priority_Yield+0xc0> <== NOT EXECUTED 40009a70: b4 10 00 06 mov %g6, %i2 <== NOT EXECUTED 40009a74: 7f ff f9 3a call 40007f5c <_Timecounter_Sbinuptime> <== NOT EXECUTED 40009a78: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 <== NOT EXECUTED 40009a7c: d0 3e a0 28 std %o0, [ %i2 + 0x28 ] <== NOT EXECUTED *_result = *_end - *_start; 40009a80: b2 a2 40 11 subcc %o1, %l1, %i1 <== NOT EXECUTED *_time += *_add; 40009a84: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4 <== NOT EXECUTED *_result = *_end - *_start; 40009a88: b0 62 00 10 subx %o0, %l0, %i0 <== NOT EXECUTED *_time += *_add; 40009a8c: 86 83 40 19 addcc %o5, %i1, %g3 <== NOT EXECUTED 40009a90: 84 43 00 18 addx %o4, %i0, %g2 <== NOT EXECUTED 40009a94: c4 3e e0 98 std %g2, [ %i3 + 0x98 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 40009a98: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = new_heir; 40009a9c: fa 21 a0 24 st %i5, [ %g6 + 0x24 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 40009aa0: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] <== NOT EXECUTED _Chain_Extract_unprotected( &the_thread->Object.Node ); _Chain_Append_unprotected( ready_chain, &the_thread->Object.Node ); } _Scheduler_priority_Schedule_body( scheduler, the_thread, true ); } 40009aa4: 81 c7 e0 08 ret <== NOT EXECUTED 40009aa8: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40012ae0 <_Semaphore_Post_binary>: ); } } void _Semaphore_Post_binary( struct _Semaphore_Control *_sem ) { 40012ae0: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40012ae4: 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; 40012ae8: d0 06 20 08 ld [ %i0 + 8 ], %o0 <== NOT EXECUTED if ( __predict_true( heads == NULL ) ) { 40012aec: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40012af0: 12 80 00 07 bne 40012b0c <_Semaphore_Post_binary+0x2c> <== NOT EXECUTED 40012af4: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED sem->count = 1; 40012af8: c4 26 20 14 st %g2, [ %i0 + 0x14 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40012afc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40012b00: 01 00 00 00 nop <== NOT EXECUTED 40012b04: 81 c7 e0 08 ret <== NOT EXECUTED 40012b08: 81 e8 00 00 restore <== NOT EXECUTED 40012b0c: c2 27 bf dc st %g1, [ %fp + -36 ] <== NOT EXECUTED 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 ); 40012b10: 3b 10 00 bb sethi %hi(0x4002ec00), %i5 <== NOT EXECUTED 40012b14: ba 17 63 e0 or %i5, 0x3e0, %i5 ! 4002efe0 <_Thread_queue_Operations_priority> <== NOT EXECUTED 40012b18: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED 40012b1c: 9f c0 40 00 call %g1 <== NOT EXECUTED 40012b20: 01 00 00 00 nop <== NOT EXECUTED _Thread_queue_Extract_critical( 40012b24: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED 40012b28: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 40012b2c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 40012b30: 40 00 03 fd call 40013b24 <_Thread_queue_Extract_critical> <== NOT EXECUTED 40012b34: 90 06 20 08 add %i0, 8, %o0 <== NOT EXECUTED operations, first, &queue_context ); } } 40012b38: 81 c7 e0 08 ret <== NOT EXECUTED 40012b3c: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40012a9c <_Semaphore_Try_wait>: int _Semaphore_Try_wait( struct _Semaphore_Control *_sem ) { 40012a9c: 86 10 00 08 mov %o0, %g3 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40012aa0: 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; 40012aa4: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 <== NOT EXECUTED if ( __predict_true( count > 0 ) ) { 40012aa8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40012aac: 02 80 00 08 be 40012acc <_Semaphore_Try_wait+0x30> <== NOT EXECUTED 40012ab0: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED sem->count = count - 1; eno = 0; 40012ab4: 90 10 20 00 clr %o0 <== NOT EXECUTED sem->count = count - 1; 40012ab8: c4 20 e0 14 st %g2, [ %g3 + 0x14 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40012abc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40012ac0: 01 00 00 00 nop <== NOT EXECUTED eno = EAGAIN; } _Sem_Queue_release( sem, level, &queue_context ); return eno; } 40012ac4: 81 c3 e0 08 retl <== NOT EXECUTED 40012ac8: 01 00 00 00 nop <== NOT EXECUTED eno = EAGAIN; 40012acc: 90 10 20 0b mov 0xb, %o0 ! b <_TLS_Alignment+0xa> <== NOT EXECUTED 40012ad0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40012ad4: 01 00 00 00 nop <== NOT EXECUTED } 40012ad8: 81 c3 e0 08 retl <== NOT EXECUTED 40012adc: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 400129bc <_Semaphore_Wait>: sizeof( Sem_Control ) == sizeof( struct _Semaphore_Control ), SEMAPHORE_CONTROL_SIZE ); void _Semaphore_Wait( struct _Semaphore_Control *_sem ) { 400129bc: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400129c0: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 400129c4: 86 10 00 01 mov %g1, %g3 <== NOT EXECUTED 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; 400129c8: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED if ( __predict_true( count > 0 ) ) { 400129cc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400129d0: 02 80 00 07 be 400129ec <_Semaphore_Wait+0x30> <== NOT EXECUTED 400129d4: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED sem->count = count - 1; 400129d8: c4 26 20 14 st %g2, [ %i0 + 0x14 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400129dc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400129e0: 01 00 00 00 nop <== NOT EXECUTED 400129e4: 81 c7 e0 08 ret <== NOT EXECUTED 400129e8: 81 e8 00 00 restore <== NOT EXECUTED queue_context->thread_state = thread_state; 400129ec: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED Thread_queue_Context *queue_context ) { Thread_Control *executing; executing = _Thread_Executing; 400129f0: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2 <== NOT EXECUTED 400129f4: c2 27 bf e0 st %g1, [ %fp + -32 ] <== NOT EXECUTED queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra; 400129f8: 03 10 00 4e sethi %hi(0x40013800), %g1 <== NOT EXECUTED 400129fc: 82 10 61 24 or %g1, 0x124, %g1 ! 40013924 <_Thread_queue_Enqueue_do_nothing_extra> <== NOT EXECUTED &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( 40012a00: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED 40012a04: c2 27 bf e4 st %g1, [ %fp + -28 ] <== NOT EXECUTED 40012a08: 13 10 00 bb sethi %hi(0x4002ec00), %o1 <== NOT EXECUTED 40012a0c: c6 27 bf dc st %g3, [ %fp + -36 ] <== NOT EXECUTED 40012a10: 92 12 63 e0 or %o1, 0x3e0, %o1 <== NOT EXECUTED 40012a14: 40 00 03 ce call 4001394c <_Thread_queue_Enqueue> <== NOT EXECUTED 40012a18: 90 06 20 08 add %i0, 8, %o0 <== NOT EXECUTED SEMAPHORE_TQ_OPERATIONS, executing, &queue_context ); } } 40012a1c: 81 c7 e0 08 ret <== NOT EXECUTED 40012a20: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40012a24 <_Semaphore_Wait_timed_ticks>: int _Semaphore_Wait_timed_ticks( struct _Semaphore_Control *_sem, uint32_t ticks ) { 40012a24: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40012a28: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 40012a2c: 86 10 00 01 mov %g1, %g3 <== NOT EXECUTED 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; 40012a30: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED if ( __predict_true( count > 0 ) ) { 40012a34: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40012a38: 02 80 00 07 be 40012a54 <_Semaphore_Wait_timed_ticks+0x30> <== NOT EXECUTED 40012a3c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED sem->count = count - 1; 40012a40: c4 26 20 14 st %g2, [ %i0 + 0x14 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40012a44: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40012a48: 01 00 00 00 nop <== NOT EXECUTED _Sem_Queue_release( sem, level, &queue_context ); return 0; 40012a4c: 81 c7 e0 08 ret <== NOT EXECUTED 40012a50: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED queue_context->thread_state = thread_state; 40012a54: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 40012a58: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5 <== NOT EXECUTED 40012a5c: c2 27 bf e0 st %g1, [ %fp + -32 ] <== NOT EXECUTED queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks; 40012a60: 03 10 00 52 sethi %hi(0x40014800), %g1 <== NOT EXECUTED 40012a64: 82 10 61 44 or %g1, 0x144, %g1 ! 40014944 <_Thread_queue_Add_timeout_ticks> <== NOT EXECUTED &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( 40012a68: 90 06 20 08 add %i0, 8, %o0 <== NOT EXECUTED queue_context->Timeout.ticks = ticks; 40012a6c: f2 27 bf e8 st %i1, [ %fp + -24 ] <== NOT EXECUTED 40012a70: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED 40012a74: c6 27 bf dc st %g3, [ %fp + -36 ] <== NOT EXECUTED 40012a78: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks; 40012a7c: c2 27 bf e4 st %g1, [ %fp + -28 ] <== NOT EXECUTED 40012a80: 13 10 00 bb sethi %hi(0x4002ec00), %o1 <== NOT EXECUTED 40012a84: 40 00 03 b2 call 4001394c <_Thread_queue_Enqueue> <== NOT EXECUTED 40012a88: 92 12 63 e0 or %o1, 0x3e0, %o1 ! 4002efe0 <_Thread_queue_Operations_priority> <== NOT EXECUTED &sem->Queue.Queue, SEMAPHORE_TQ_OPERATIONS, executing, &queue_context ); return STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) ); 40012a8c: f0 07 60 4c ld [ %i5 + 0x4c ], %i0 <== NOT EXECUTED 40012a90: b1 3e 20 08 sra %i0, 8, %i0 <== NOT EXECUTED } } 40012a94: 81 c7 e0 08 ret <== NOT EXECUTED 40012a98: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40019d54 <_Signal_Action_handler>: void _Signal_Action_handler( Thread_Control *executing, Thread_Action *action, ISR_lock_Context *lock_context ) { 40019d54: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED /* * Signal Processing */ api = executing->API_Extensions[ THREAD_API_RTEMS ]; 40019d58: fa 06 21 58 ld [ %i0 + 0x158 ], %i5 <== NOT EXECUTED ASR_Information *asr ) { rtems_signal_set signal_set; signal_set = asr->signals_posted; 40019d5c: f8 07 60 14 ld [ %i5 + 0x14 ], %i4 <== NOT EXECUTED asr->signals_posted = 0; 40019d60: c0 27 60 14 clr [ %i5 + 0x14 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40019d64: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40019d68: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40019d6c: 01 00 00 00 nop <== NOT EXECUTED asr = &api->Signal; signal_set = _ASR_Get_posted_signals( asr ); _Thread_State_release( executing, lock_context ); if ( signal_set == 0 ) { 40019d70: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED 40019d74: 32 80 00 04 bne,a 40019d84 <_Signal_Action_handler+0x30> <== NOT EXECUTED 40019d78: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED (*asr->handler)( signal_set ); asr->nest_level -= 1; rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); } 40019d7c: 81 c7 e0 08 ret <== NOT EXECUTED 40019d80: 81 e8 00 00 restore <== NOT EXECUTED asr->nest_level += 1; 40019d84: 82 00 60 01 inc %g1 <== NOT EXECUTED 40019d88: c2 27 60 1c st %g1, [ %i5 + 0x1c ] <== NOT EXECUTED rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 40019d8c: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED 40019d90: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED 40019d94: 37 00 00 3f sethi %hi(0xfc00), %i3 <== NOT EXECUTED 40019d98: 7f ff d3 35 call 4000ea6c <== NOT EXECUTED 40019d9c: 92 16 e3 ff or %i3, 0x3ff, %o1 ! ffff <== NOT EXECUTED (*asr->handler)( signal_set ); 40019da0: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED 40019da4: 9f c0 40 00 call %g1 <== NOT EXECUTED 40019da8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED asr->nest_level -= 1; 40019dac: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED 40019db0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40019db4: c2 27 60 1c st %g1, [ %i5 + 0x1c ] <== NOT EXECUTED rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 40019db8: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED 40019dbc: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED 40019dc0: 7f ff d3 2b call 4000ea6c <== NOT EXECUTED 40019dc4: 92 16 e3 ff or %i3, 0x3ff, %o1 <== NOT EXECUTED } 40019dc8: 81 c7 e0 08 ret <== NOT EXECUTED 40019dcc: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40010b4c <_Status_Object_name_errors_to_status>: 40010b4c: 00 00 00 00 00 00 00 03 00 00 00 09 00 00 00 04 ................ 40010b5c: 00 00 00 15 35 2e 30 2e 30 2e 36 39 36 62 39 31 ....5.0.0.696b91 40010b6c: 32 31 61 32 62 37 65 63 38 30 34 36 34 64 31 33 21a2b7ec80464d13 40010b7c: 63 37 32 33 65 36 63 37 38 30 61 33 65 35 36 30 c723e6c780a3e560 40010b8c: 38 63 00 00 4e 4f 4e 42 4c 4f 43 4b 00 00 00 00 8c..NONBLOCK.... 40010b9c: 00 00 00 00 41 50 50 45 4e 44 00 00 52 45 41 44 ....APPEND..READ 40010bac: 00 00 00 00 57 52 49 54 45 00 00 00 52 45 41 44 ....WRITE...READ 40010bbc: 2f 57 52 49 54 45 00 00 /WRITE.. =============================================================================== 40083b50 <_TOD_Days_per_month>: 40083b50: 00 00 00 00 00 00 00 1f 00 00 00 1c 00 00 00 1f ................ 40083b60: 00 00 00 1e 00 00 00 1f 00 00 00 1e 00 00 00 1f ................ 40083b70: 00 00 00 1f 00 00 00 1e 00 00 00 1f 00 00 00 1e ................ 40083b80: 00 00 00 1f 00 00 00 00 00 00 00 1f 00 00 00 1d ................ 40083b90: 00 00 00 1f 00 00 00 1e 00 00 00 1f 00 00 00 1e ................ 40083ba0: 00 00 00 1f 00 00 00 1f 00 00 00 1e 00 00 00 1f ................ 40083bb0: 00 00 00 1e 00 00 00 1f 50 65 72 69 6f 64 20 69 ........Period i 40083bc0: 6e 66 6f 72 6d 61 74 69 6f 6e 20 62 79 20 70 65 nformation by pe 40083bd0: 72 69 6f 64 0a 00 00 00 2d 2d 2d 20 43 50 55 20 riod....--- CPU 40083be0: 74 69 6d 65 73 20 61 72 65 20 69 6e 20 73 65 63 times are in sec 40083bf0: 6f 6e 64 73 20 2d 2d 2d 0a 00 00 00 00 00 00 00 onds ---........ 40083c00: 2d 2d 2d 20 57 61 6c 6c 20 74 69 6d 65 73 20 61 --- Wall times a 40083c10: 72 65 20 69 6e 20 73 65 63 6f 6e 64 73 20 2d 2d re in seconds -- 40083c20: 2d 0a 00 00 00 00 00 00 20 20 20 49 44 20 20 20 -....... ID 40083c30: 20 20 4f 57 4e 45 52 20 43 4f 55 4e 54 20 4d 49 OWNER COUNT MI 40083c40: 53 53 45 44 20 20 20 20 20 20 20 20 20 20 43 50 SSED CP 40083c50: 55 20 54 49 4d 45 20 20 20 20 20 20 20 20 20 20 U TIME 40083c60: 20 20 20 20 20 20 20 20 57 41 4c 4c 20 54 49 4d WALL TIM 40083c70: 45 0a 20 20 20 20 20 20 20 20 20 20 20 20 20 20 E. 40083c80: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 40083c90: 20 20 20 20 20 20 4d 49 4e 2f 4d 41 58 2f 41 56 MIN/MAX/AV 40083ca0: 47 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 G 40083cb0: 20 4d 49 4e 2f 4d 41 58 2f 41 56 47 0a 00 00 00 MIN/MAX/AVG.... 40083cc0: 30 78 25 30 38 6c 78 20 25 34 73 20 25 35 6c 64 0x%08lx %4s %5ld 40083cd0: 20 25 36 6c 64 20 00 00 25 6c 6c 64 2e 25 30 36 %6ld ..%lld.%06 40083ce0: 6c 64 2f 25 6c 6c 64 2e 25 30 36 6c 64 2f 25 6c ld/%lld.%06ld/%l 40083cf0: 6c 64 2e 25 30 36 6c 64 20 00 00 00 00 00 00 00 ld.%06ld ....... 40083d00: 25 6c 6c 64 2e 25 30 36 6c 64 2f 25 6c 6c 64 2e %lld.%06ld/%lld. 40083d10: 25 30 36 6c 64 2f 25 6c 6c 64 2e 25 30 36 6c 64 %06ld/%lld.%06ld 40083d20: 0a 00 00 00 00 00 00 00 35 2e 30 2e 30 2e 36 39 ........5.0.0.69 40083d30: 36 62 39 31 32 31 61 32 62 37 65 63 38 30 34 36 6b9121a2b7ec8046 40083d40: 34 64 31 33 63 37 32 33 65 36 63 37 38 30 61 33 4d13c723e6c780a3 40083d50: 65 35 36 30 38 63 00 00 5f 54 4f 44 00 00 00 00 e5608c.._TOD.... 40083d60: 6d 6f 6e 69 74 6f 72 00 25 73 3a 20 69 6c 6c 65 monitor.%s: ille 40083d70: 67 61 6c 20 6e 75 6d 65 72 69 63 20 76 61 6c 75 gal numeric valu 40083d80: 65 00 00 00 00 00 00 00 2c 00 00 00 00 00 00 00 e.......,....... 40083d90: 75 6e 6b 6e 6f 77 6e 20 63 6f 6e 76 65 72 73 69 unknown conversi 40083da0: 6f 6e 20 25 73 00 00 00 25 73 3a 20 69 6c 6c 65 on %s...%s: ille 40083db0: 67 61 6c 20 63 6f 6e 76 65 72 73 69 6f 6e 20 63 gal conversion c 40083dc0: 6f 6d 62 69 6e 61 74 69 6f 6e 00 00 00 00 00 00 ombination...... 40083dd0: 6f 62 73 20 6d 75 73 74 20 62 65 20 62 65 74 77 obs must be betw 40083de0: 65 65 6e 20 31 20 61 6e 64 20 25 6a 64 00 00 00 een 1 and %jd... 40083df0: 69 62 73 20 6d 75 73 74 20 62 65 20 62 65 74 77 ibs must be betw 40083e00: 65 65 6e 20 31 20 61 6e 64 20 25 6a 64 00 00 00 een 1 and %jd... 40083e10: 66 69 6c 65 73 20 6d 75 73 74 20 62 65 20 62 65 files must be be 40083e20: 74 77 65 65 6e 20 31 20 61 6e 64 20 25 6a 64 00 tween 1 and %jd. 40083e30: 63 6f 75 6e 74 20 63 61 6e 6e 6f 74 20 62 65 20 count cannot be 40083e40: 6e 65 67 61 74 69 76 65 00 00 00 00 00 00 00 00 negative........ 40083e50: 63 62 73 20 6d 75 73 74 20 62 65 20 62 65 74 77 cbs must be betw 40083e60: 65 65 6e 20 31 20 61 6e 64 20 25 6a 64 00 00 00 een 1 and %jd... 40083e70: 62 73 20 6d 75 73 74 20 62 65 20 62 65 74 77 65 bs must be betwe 40083e80: 65 6e 20 31 20 61 6e 64 20 25 6a 64 00 00 00 00 en 1 and %jd.... 40083e90: 6e 65 65 64 20 65 78 61 63 74 6c 79 20 6f 6e 65 need exactly one 40083ea0: 20 66 69 6c 6c 20 63 68 61 72 00 00 00 00 00 00 fill char...... 40083eb0: 75 6e 6b 6e 6f 77 6e 20 6f 70 65 72 61 6e 64 20 unknown operand 40083ec0: 25 73 00 00 00 00 00 00 6e 6f 20 76 61 6c 75 65 %s......no value 40083ed0: 20 73 70 65 63 69 66 69 65 64 20 66 6f 72 20 25 specified for % 40083ee0: 73 00 00 00 00 00 00 00 25 73 3a 20 69 6c 6c 65 s.......%s: ille 40083ef0: 67 61 6c 20 61 72 67 75 6d 65 6e 74 20 63 6f 6d gal argument com 40083f00: 62 69 6e 61 74 69 6f 6e 20 6f 72 20 61 6c 72 65 bination or alre 40083f10: 61 64 79 20 73 65 74 00 62 73 20 73 75 70 65 72 ady set.bs super 40083f20: 73 65 64 65 73 20 69 62 73 20 61 6e 64 20 6f 62 sedes ibs and ob 40083f30: 73 00 00 00 00 00 00 00 72 65 63 6f 72 64 20 6f s.......record o 40083f40: 70 65 72 61 74 69 6f 6e 73 20 72 65 71 75 69 72 perations requir 40083f50: 65 20 63 62 73 00 00 00 63 62 73 20 63 61 6e 6e e cbs...cbs cann 40083f60: 6f 74 20 62 65 20 7a 65 72 6f 00 00 00 00 00 00 ot be zero...... 40083f70: 63 62 73 20 6d 65 61 6e 69 6e 67 6c 65 73 73 20 cbs meaningless 40083f80: 69 66 20 6e 6f 74 20 64 6f 69 6e 67 20 72 65 63 if not doing rec 40083f90: 6f 72 64 20 6f 70 65 72 61 74 69 6f 6e 73 00 00 ord operations.. 40083fa0: 73 65 65 6b 20 6f 66 66 73 65 74 73 20 63 61 6e seek offsets can 40083fb0: 6e 6f 74 20 62 65 20 6c 61 72 67 65 72 20 74 68 not be larger th 40083fc0: 61 6e 20 25 6a 64 00 00 61 73 63 69 69 00 00 00 an %jd..ascii... 40083fd0: 65 62 63 64 69 63 00 00 69 62 6d 00 00 00 00 00 ebcdic..ibm..... 40083fe0: 6c 63 61 73 65 00 00 00 6e 6f 65 72 72 6f 72 00 lcase...noerror. 40083ff0: 6e 6f 74 72 75 6e 63 00 6f 6c 64 61 73 63 69 69 notrunc.oldascii ... 40084008: 6f 6c 64 65 62 63 64 69 63 00 00 00 00 00 00 00 oldebcdic....... 40084018: 6f 6c 64 69 62 6d 00 00 6f 73 79 6e 63 00 00 00 oldibm..osync... 40084028: 70 61 72 65 76 65 6e 00 70 61 72 6e 6f 6e 65 00 pareven.parnone. 40084038: 70 61 72 6f 64 64 00 00 70 61 72 73 65 74 00 00 parodd..parset.. 40084048: 73 70 61 72 73 65 00 00 73 77 61 62 00 00 00 00 sparse..swab.... 40084058: 73 79 6e 63 00 00 00 00 75 63 61 73 65 00 00 00 sync....ucase... 40084068: 75 6e 62 6c 6f 63 6b 00 62 73 00 00 00 00 00 00 unblock.bs...... 40084078: 63 62 73 00 00 00 00 00 63 6f 6e 76 00 00 00 00 cbs.....conv.... 40084088: 63 6f 75 6e 74 00 00 00 66 69 6c 6c 63 68 61 72 count...fillchar ... 400840a0: 69 62 73 00 00 00 00 00 69 66 00 00 00 00 00 00 ibs.....if...... 400840b0: 69 73 65 65 6b 00 00 00 6f 62 73 00 00 00 00 00 iseek...obs..... 400840c0: 6f 66 00 00 00 00 00 00 6f 73 65 65 6b 00 00 00 of......oseek... 400840d0: 73 6b 69 70 00 00 00 00 skip.... =============================================================================== 40083b12 <_TOD_Days_since_last_leap_year>: 40083b12: 00 00 01 6e 02 db 04 48 ...n...H =============================================================================== 40083b1a <_TOD_Days_to_date>: 40083b1a: 00 00 00 00 00 1f 00 3b 00 5a 00 78 00 97 00 b5 .......;.Z.x.... 40083b2a: 00 d4 00 f3 01 11 01 30 01 4e 00 00 00 00 00 1f .......0.N...... 40083b3a: 00 3c 00 5b 00 79 00 98 00 b6 00 d5 00 f4 01 12 .<.[.y.......... 40083b4a: 01 31 01 4f 00 00 .1.O.. =============================================================================== 40044504 <_TOD_Set>: void _TOD_Set( const struct timespec *tod, ISR_lock_Context *lock_context ) { 40044504: 9d e3 bf 88 save %sp, -120, %sp _bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL; 40044508: c4 06 20 08 ld [ %i0 + 8 ], %g2 4004450c: 89 28 a0 02 sll %g2, 2, %g4 _bt->sec = _ts->tv_sec; 40044510: f8 1e 00 00 ldd [ %i0 ], %i4 _bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL; 40044514: 83 38 a0 1f sra %g2, 0x1f, %g1 40044518: 07 12 e0 be sethi %hi(0x4b82f800), %g3 4004451c: 86 10 e2 09 or %g3, 0x209, %g3 ! 4b82fa09 40044520: 82 58 40 03 smul %g1, %g3, %g1 40044524: 86 50 80 03 umul %g2, %g3, %g3 40044528: 85 40 00 00 rd %y, %g2 4004452c: 82 00 40 04 add %g1, %g4, %g1 40044530: 84 00 40 02 add %g1, %g2, %g2 _bt->sec = _ts->tv_sec; 40044534: 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 ); 40044538: 92 10 00 19 mov %i1, %o1 _bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL; 4004453c: c4 3f bf f8 std %g2, [ %fp + -8 ] 40044540: 7f ff 5d 54 call 4001ba90 <_Timecounter_Set_clock> 40044544: 90 07 bf f0 add %fp, -16, %o0 ticks = (uint64_t) ts->tv_sec; 40044548: c6 06 00 00 ld [ %i0 ], %g3 <== NOT EXECUTED 4004454c: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED ticks |= (uint32_t) ts->tv_nsec; 40044550: d6 06 20 08 ld [ %i0 + 8 ], %o3 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40044554: 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 ); 40044558: c2 27 bf ec st %g1, [ %fp + -20 ] 4004455c: 11 10 02 40 sethi %hi(0x40090000), %o0 40044560: 90 12 22 80 or %o0, 0x280, %o0 ! 40090280 <_Per_CPU_Information> 40044564: d2 02 20 44 ld [ %o0 + 0x44 ], %o1 first = _Watchdog_Header_first( header ); if ( first != NULL ) { 40044568: 80 a2 60 00 cmp %o1, 0 4004456c: 02 80 00 09 be 40044590 <_TOD_Set+0x8c> <== ALWAYS TAKEN 40044570: 95 30 a0 02 srl %g2, 2, %o2 ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS; 40044574: 87 28 e0 1e sll %g3, 0x1e, %g3 <== NOT EXECUTED 40044578: 85 28 a0 1e sll %g2, 0x1e, %g2 <== NOT EXECUTED _Watchdog_Tickle( 4004457c: 98 07 bf ec add %fp, -20, %o4 <== NOT EXECUTED 40044580: 94 12 80 03 or %o2, %g3, %o2 <== NOT EXECUTED 40044584: 96 12 c0 02 or %o3, %g2, %o3 <== NOT EXECUTED 40044588: 7f ff 6e 9c call 4001fff8 <_Watchdog_Do_tickle> <== NOT EXECUTED 4004458c: 90 02 20 40 add %o0, 0x40, %o0 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40044590: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40044594: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40044598: 01 00 00 00 nop } _ISR_lock_Release_and_ISR_enable( &cpu->Watchdog.Lock, &lock_context ); } _TOD.is_set = true; 4004459c: 03 10 02 40 sethi %hi(0x40090000), %g1 400445a0: 84 10 20 01 mov 1, %g2 400445a4: c4 28 63 e4 stb %g2, [ %g1 + 0x3e4 ] } 400445a8: 81 c7 e0 08 ret 400445ac: 81 e8 00 00 restore =============================================================================== 40043c3c <_TOD_To_seconds>: ) { uint32_t time; uint32_t year_mod_4; time = the_tod->day - 1; 40043c3c: c6 02 20 08 ld [ %o0 + 8 ], %g3 year_mod_4 = the_tod->year & 3; 40043c40: c2 02 00 00 ld [ %o0 ], %g1 time = the_tod->day - 1; 40043c44: 86 00 ff ff add %g3, -1, %g3 if ( year_mod_4 == 0 ) 40043c48: 88 88 60 03 andcc %g1, 3, %g4 40043c4c: 12 80 00 03 bne 40043c58 <_TOD_To_seconds+0x1c> 40043c50: c4 02 20 04 ld [ %o0 + 4 ], %g2 time += _TOD_Days_to_date[ 1 ][ the_tod->month ]; 40043c54: 84 00 a0 0d add %g2, 0xd, %g2 else time += _TOD_Days_to_date[ 0 ][ the_tod->month ]; 40043c58: 85 28 a0 01 sll %g2, 1, %g2 40043c5c: 1b 10 02 0e sethi %hi(0x40083800), %o5 40043c60: 9a 13 63 1a or %o5, 0x31a, %o5 ! 40083b1a <_TOD_Days_to_date> 40043c64: c4 13 40 02 lduh [ %o5 + %g2 ], %g2 40043c68: 86 00 80 03 add %g2, %g3, %g3 time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) * ( (TOD_DAYS_PER_YEAR * 4) + 1); time += _TOD_Days_since_last_leap_year[ year_mod_4 ]; 40043c6c: 1b 10 02 0e sethi %hi(0x40083800), %o5 time *= TOD_SECONDS_PER_DAY; time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute) 40043c70: c4 02 20 0c ld [ %o0 + 0xc ], %g2 time += _TOD_Days_since_last_leap_year[ year_mod_4 ]; 40043c74: 9a 13 63 12 or %o5, 0x312, %o5 40043c78: 89 29 20 01 sll %g4, 1, %g4 time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute) 40043c7c: d8 02 20 10 ld [ %o0 + 0x10 ], %o4 time += _TOD_Days_since_last_leap_year[ year_mod_4 ]; 40043c80: d6 13 40 04 lduh [ %o5 + %g4 ], %o3 * TOD_SECONDS_PER_MINUTE; time += the_tod->second; 40043c84: da 02 20 14 ld [ %o0 + 0x14 ], %o5 time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) * 40043c88: 90 00 78 3c add %g1, -1988, %o0 time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute) 40043c8c: 83 28 a0 04 sll %g2, 4, %g1 40043c90: 82 20 40 02 sub %g1, %g2, %g1 40043c94: 83 28 60 02 sll %g1, 2, %g1 40043c98: 84 00 40 0c add %g1, %o4, %g2 * TOD_SECONDS_PER_MINUTE; 40043c9c: 83 28 a0 04 sll %g2, 4, %g1 40043ca0: 82 20 40 02 sub %g1, %g2, %g1 40043ca4: 83 28 60 02 sll %g1, 2, %g1 time += the_tod->second; 40043ca8: 82 00 40 0d add %g1, %o5, %g1 time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) * 40043cac: 91 32 20 02 srl %o0, 2, %o0 time *= TOD_SECONDS_PER_DAY; 40043cb0: 09 00 00 54 sethi %hi(0x15000), %g4 time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) * 40043cb4: 90 5a 25 b5 smul %o0, 0x5b5, %o0 time *= TOD_SECONDS_PER_DAY; 40043cb8: 88 11 21 80 or %g4, 0x180, %g4 time += _TOD_Days_since_last_leap_year[ year_mod_4 ]; 40043cbc: 90 02 00 0b add %o0, %o3, %o0 40043cc0: 90 02 00 03 add %o0, %g3, %o0 time *= TOD_SECONDS_PER_DAY; 40043cc4: 90 5a 00 04 smul %o0, %g4, %o0 time += the_tod->second; 40043cc8: 90 00 40 08 add %g1, %o0, %o0 /* The year 2100 is not a leap year */ if ( time 40043ccc: 03 34 be 4b sethi %hi(0xd2f92c00), %g1 40043cd0: 82 10 60 6f or %g1, 0x6f, %g1 ! d2f92c6f 40043cd4: 80 a2 00 01 cmp %o0, %g1 40043cd8: 38 80 00 02 bgu,a 40043ce0 <_TOD_To_seconds+0xa4> <== NEVER TAKEN 40043cdc: 90 22 00 04 sub %o0, %g4, %o0 <== NOT EXECUTED >= (TOD_SECONDS_AT_2100_03_01_00_00 - TOD_SECONDS_1970_THROUGH_1988)) { time -= TOD_SECONDS_PER_DAY; } time += TOD_SECONDS_1970_THROUGH_1988; 40043ce0: 03 08 76 b9 sethi %hi(0x21dae400), %g1 40043ce4: 82 10 61 00 or %g1, 0x100, %g1 ! 21dae500 return( time ); } 40043ce8: 81 c3 e0 08 retl 40043cec: 90 02 00 01 add %o0, %g1, %o0 =============================================================================== 40043cf0 <_TOD_Validate>: }; bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 40043cf0: 9d e3 bf a0 save %sp, -96, %sp uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 40043cf4: 80 a6 20 00 cmp %i0, 0 40043cf8: 02 80 00 1f be 40043d74 <_TOD_Validate+0x84> <== NEVER TAKEN 40043cfc: 84 10 20 00 clr %g2 40043d00: c8 06 20 18 ld [ %i0 + 0x18 ], %g4 ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 40043d04: 07 10 01 f1 sethi %hi(0x4007c400), %g3 40043d08: 03 00 03 d0 sethi %hi(0xf4000), %g1 40043d0c: 82 10 62 40 or %g1, 0x240, %g1 ! f4240 40043d10: 81 80 20 00 wr %g0, %y 40043d14: de 00 e2 48 ld [ %g3 + 0x248 ], %o7 40043d18: 01 00 00 00 nop 40043d1c: 01 00 00 00 nop 40043d20: 9e 70 40 0f udiv %g1, %o7, %o7 if ((!the_tod) || 40043d24: 80 a1 00 0f cmp %g4, %o7 40043d28: 3a 80 00 14 bcc,a 40043d78 <_TOD_Validate+0x88> <== NEVER TAKEN 40043d2c: b0 08 a0 01 and %g2, 1, %i0 <== NOT EXECUTED (the_tod->ticks >= ticks_per_second) || 40043d30: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40043d34: 80 a0 60 3b cmp %g1, 0x3b 40043d38: 38 80 00 10 bgu,a 40043d78 <_TOD_Validate+0x88> <== NEVER TAKEN 40043d3c: b0 08 a0 01 and %g2, 1, %i0 <== NOT EXECUTED (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 40043d40: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 40043d44: 80 a0 60 3b cmp %g1, 0x3b 40043d48: 38 80 00 0c bgu,a 40043d78 <_TOD_Validate+0x88> <== NEVER TAKEN 40043d4c: b0 08 a0 01 and %g2, 1, %i0 <== NOT EXECUTED (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 40043d50: c2 06 20 0c ld [ %i0 + 0xc ], %g1 40043d54: 80 a0 60 17 cmp %g1, 0x17 40043d58: 38 80 00 08 bgu,a 40043d78 <_TOD_Validate+0x88> <== NEVER TAKEN 40043d5c: b0 08 a0 01 and %g2, 1, %i0 <== NOT EXECUTED (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 40043d60: c2 06 20 04 ld [ %i0 + 4 ], %g1 40043d64: 86 00 7f ff add %g1, -1, %g3 40043d68: 80 a0 e0 0b cmp %g3, 0xb 40043d6c: 28 80 00 05 bleu,a 40043d80 <_TOD_Validate+0x90> <== ALWAYS TAKEN 40043d70: c6 06 00 00 ld [ %i0 ], %g3 if ( the_tod->day > days_in_month ) return false; return true; } 40043d74: b0 08 a0 01 and %g2, 1, %i0 40043d78: 81 c7 e0 08 ret 40043d7c: 81 e8 00 00 restore (the_tod->month > TOD_MONTHS_PER_YEAR) || 40043d80: 80 a0 e7 c3 cmp %g3, 0x7c3 40043d84: 28 bf ff fd bleu,a 40043d78 <_TOD_Validate+0x88> <== NEVER TAKEN 40043d88: b0 08 a0 01 and %g2, 1, %i0 <== NOT EXECUTED (the_tod->day == 0) ) 40043d8c: c8 06 20 08 ld [ %i0 + 8 ], %g4 (the_tod->year < TOD_BASE_YEAR) || 40043d90: 80 a1 20 00 cmp %g4, 0 40043d94: 02 bf ff f8 be 40043d74 <_TOD_Validate+0x84> <== NEVER TAKEN 40043d98: 80 88 e0 03 btst 3, %g3 if (((the_tod->year % 4) == 0 && (the_tod->year % 100 != 0)) || 40043d9c: 12 80 00 12 bne 40043de4 <_TOD_Validate+0xf4> 40043da0: 05 14 7a e1 sethi %hi(0x51eb8400), %g2 40043da4: 84 10 a1 1f or %g2, 0x11f, %g2 ! 51eb851f 40043da8: 80 50 c0 02 umul %g3, %g2, %g0 40043dac: 85 40 00 00 rd %y, %g2 40043db0: 85 30 a0 05 srl %g2, 5, %g2 40043db4: 84 58 a0 64 smul %g2, 0x64, %g2 40043db8: 80 a0 c0 02 cmp %g3, %g2 40043dbc: 22 80 00 0a be,a 40043de4 <_TOD_Validate+0xf4> <== NEVER TAKEN 40043dc0: 05 14 7a e1 sethi %hi(0x51eb8400), %g2 <== NOT EXECUTED days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 40043dc4: 82 00 60 0d add %g1, 0xd, %g1 40043dc8: 05 10 02 0e sethi %hi(0x40083800), %g2 40043dcc: 83 28 60 02 sll %g1, 2, %g1 40043dd0: 84 10 a3 50 or %g2, 0x350, %g2 40043dd4: c2 00 80 01 ld [ %g2 + %g1 ], %g1 if ( the_tod->day > days_in_month ) 40043dd8: 80 a0 40 04 cmp %g1, %g4 40043ddc: 10 bf ff e6 b 40043d74 <_TOD_Validate+0x84> 40043de0: 84 60 3f ff subx %g0, -1, %g2 (the_tod->year % 400 == 0)) 40043de4: 84 10 a1 1f or %g2, 0x11f, %g2 40043de8: 80 50 c0 02 umul %g3, %g2, %g0 40043dec: 85 40 00 00 rd %y, %g2 40043df0: 85 30 a0 07 srl %g2, 7, %g2 40043df4: 84 58 a1 90 smul %g2, 0x190, %g2 if (((the_tod->year % 4) == 0 && (the_tod->year % 100 != 0)) || 40043df8: 80 a0 c0 02 cmp %g3, %g2 40043dfc: 22 bf ff f3 be,a 40043dc8 <_TOD_Validate+0xd8> <== NEVER TAKEN 40043e00: 82 00 60 0d add %g1, 0xd, %g1 <== NOT EXECUTED days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 40043e04: 83 28 60 02 sll %g1, 2, %g1 40043e08: 05 10 02 0e sethi %hi(0x40083800), %g2 40043e0c: 84 10 a3 50 or %g2, 0x350, %g2 ! 40083b50 <_TOD_Days_per_month> 40043e10: c2 00 80 01 ld [ %g2 + %g1 ], %g1 if ( the_tod->day > days_in_month ) 40043e14: 80 a0 40 04 cmp %g1, %g4 40043e18: 10 bf ff d7 b 40043d74 <_TOD_Validate+0x84> 40043e1c: 84 60 3f ff subx %g0, -1, %g2 =============================================================================== 40006f1c <_Terminate>: void _Terminate( Internal_errors_Source the_source, Internal_errors_t the_error ) { 40006f1c: 9d e3 bf 98 save %sp, -104, %sp Internal_errors_t error ) { User_extensions_Fatal_context ctx = { source, error }; _User_extensions_Iterate( 40006f20: 94 10 20 00 clr %o2 40006f24: 90 07 bf f8 add %fp, -8, %o0 User_extensions_Fatal_context ctx = { source, error }; 40006f28: f0 27 bf f8 st %i0, [ %fp + -8 ] _User_extensions_Iterate( 40006f2c: 13 10 00 2e sethi %hi(0x4000b800), %o1 User_extensions_Fatal_context ctx = { source, error }; 40006f30: f2 27 bf fc st %i1, [ %fp + -4 ] _User_extensions_Iterate( 40006f34: 40 00 12 e0 call 4000bab4 <_User_extensions_Iterate> 40006f38: 92 12 62 64 or %o1, 0x264, %o1 _User_extensions_Fatal( the_source, the_error ); _Internal_errors_What_happened.the_source = the_source; 40006f3c: 03 10 00 49 sethi %hi(0x40012400), %g1 40006f40: 84 10 61 98 or %g1, 0x198, %g2 ! 40012598 <_Internal_errors_What_happened> 40006f44: f0 20 61 98 st %i0, [ %g1 + 0x198 ] 40006f48: 03 10 00 49 sethi %hi(0x40012400), %g1 _Internal_errors_What_happened.the_error = the_error; 40006f4c: f2 20 a0 04 st %i1, [ %g2 + 4 ] 40006f50: 84 10 20 03 mov 3, %g2 _System_state_Set( SYSTEM_STATE_TERMINATED ); _SMP_Request_shutdown(); _CPU_Fatal_halt( the_source, the_error ); 40006f54: 92 10 00 19 mov %i1, %o1 40006f58: 90 10 00 18 mov %i0, %o0 40006f5c: 40 00 21 b2 call 4000f624 <_CPU_Fatal_halt> 40006f60: c4 20 61 a0 st %g2, [ %g1 + 0x1a0 ] 40006f64: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 4000b348 <_Thread_Cancel>: void _Thread_Cancel( Thread_Control *the_thread, Thread_Control *executing, void *exit_value ) { 4000b348: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b34c: 91 d0 20 09 ta 9 <== NOT EXECUTED previous = the_thread->Life.state; 4000b350: c4 06 21 70 ld [ %i0 + 0x170 ], %g2 <== NOT EXECUTED state |= set; 4000b354: 86 10 a0 04 or %g2, 4, %g3 <== NOT EXECUTED the_thread->Life.exit_value = exit_value; 4000b358: f4 26 21 78 st %i2, [ %i0 + 0x178 ] <== NOT EXECUTED if ( 4000b35c: 80 88 a0 09 btst 9, %g2 <== NOT EXECUTED 4000b360: 02 80 00 36 be 4000b438 <_Thread_Cancel+0xf0> <== NOT EXECUTED 4000b364: c6 26 21 70 st %g3, [ %i0 + 0x170 ] <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 4000b368: c4 01 a0 18 ld [ %g6 + 0x18 ], %g2 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000b36c: 84 00 a0 01 inc %g2 <== NOT EXECUTED 4000b370: c4 21 a0 18 st %g2, [ %g6 + 0x18 ] <== NOT EXECUTED ); cpu_self = _Thread_Dispatch_disable_critical( &lock_context ); priority = _Thread_Get_priority( executing ); if ( _States_Is_dormant( the_thread->current_state ) ) { 4000b374: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 <== NOT EXECUTED 4000b378: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000b37c: 06 80 00 1d bl 4000b3f0 <_Thread_Cancel+0xa8> <== NOT EXECUTED 4000b380: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED pending_requests = the_thread->Life.pending_life_change_requests; 4000b384: c4 06 21 74 ld [ %i0 + 0x174 ], %g2 <== NOT EXECUTED 4000b388: c6 06 60 38 ld [ %i1 + 0x38 ], %g3 <== NOT EXECUTED 4000b38c: f4 18 e0 18 ldd [ %g3 + 0x18 ], %i2 <== NOT EXECUTED the_thread->Life.pending_life_change_requests = pending_requests + 1; 4000b390: 86 00 a0 01 add %g2, 1, %g3 <== NOT EXECUTED if ( pending_requests == 0 ) { 4000b394: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000b398: 02 80 00 44 be 4000b4a8 <_Thread_Cancel+0x160> <== NOT EXECUTED 4000b39c: c6 26 21 74 st %g3, [ %i0 + 0x174 ] <== NOT EXECUTED 4000b3a0: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED _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 ); 4000b3a4: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED 4000b3a8: 40 00 0a 80 call 4000dda8 <_Thread_Clear_state_locked> <== NOT EXECUTED 4000b3ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000b3b0: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b3b4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b3b8: 01 00 00 00 nop <== NOT EXECUTED _Thread_State_release( the_thread, &lock_context ); _Thread_Raise_real_priority( the_thread, priority ); 4000b3bc: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4000b3c0: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 4000b3c4: 7f ff fe da call 4000af2c <_Thread_Raise_real_priority> <== NOT EXECUTED 4000b3c8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Remove_life_change_request( the_thread ); 4000b3cc: 7f ff fe c3 call 4000aed8 <_Thread_Remove_life_change_request> <== NOT EXECUTED 4000b3d0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000b3d4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED if ( disable_level == 1 ) { 4000b3d8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000b3dc: 02 80 00 0d be 4000b410 <_Thread_Cancel+0xc8> <== NOT EXECUTED 4000b3e0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000b3e4: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED } _Thread_Dispatch_enable( cpu_self ); } 4000b3e8: 81 c7 e0 08 ret <== NOT EXECUTED 4000b3ec: 81 e8 00 00 restore <== NOT EXECUTED 4000b3f0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b3f4: 01 00 00 00 nop <== NOT EXECUTED _Thread_Make_zombie( the_thread ); 4000b3f8: 7f ff ff 09 call 4000b01c <_Thread_Make_zombie> <== NOT EXECUTED 4000b3fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000b400: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED if ( disable_level == 1 ) { 4000b404: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000b408: 12 bf ff f7 bne 4000b3e4 <_Thread_Cancel+0x9c> <== NOT EXECUTED 4000b40c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b410: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000b414: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2 <== NOT EXECUTED 4000b418: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000b41c: 12 80 00 2f bne 4000b4d8 <_Thread_Cancel+0x190> <== NOT EXECUTED 4000b420: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = 0; 4000b424: c0 27 60 18 clr [ %i5 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b428: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b42c: 01 00 00 00 nop <== NOT EXECUTED 4000b430: 81 c7 e0 08 ret <== NOT EXECUTED 4000b434: 81 e8 00 00 restore <== NOT EXECUTED 4000b438: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED 4000b43c: 7f ff fe e0 call 4000afbc <_Thread_Change_life_locked.part.37> <== NOT EXECUTED 4000b440: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 4000b444: c4 01 a0 18 ld [ %g6 + 0x18 ], %g2 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000b448: 84 00 a0 01 inc %g2 <== NOT EXECUTED 4000b44c: c4 21 a0 18 st %g2, [ %g6 + 0x18 ] <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000b450: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED 4000b454: c6 06 60 38 ld [ %i1 + 0x38 ], %g3 <== NOT EXECUTED if ( _States_Is_dormant( the_thread->current_state ) ) { 4000b458: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 <== NOT EXECUTED 4000b45c: f4 18 e0 18 ldd [ %g3 + 0x18 ], %i2 <== NOT EXECUTED 4000b460: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000b464: 06 bf ff e3 bl 4000b3f0 <_Thread_Cancel+0xa8> <== NOT EXECUTED 4000b468: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED pending_requests = the_thread->Life.pending_life_change_requests; 4000b46c: c4 06 21 74 ld [ %i0 + 0x174 ], %g2 <== NOT EXECUTED the_thread->Life.pending_life_change_requests = pending_requests + 1; 4000b470: 86 00 a0 01 add %g2, 1, %g3 <== NOT EXECUTED if ( pending_requests == 0 ) { 4000b474: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000b478: 02 80 00 12 be 4000b4c0 <_Thread_Cancel+0x178> <== NOT EXECUTED 4000b47c: c6 26 21 74 st %g3, [ %i0 + 0x174 ] <== NOT EXECUTED 4000b480: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b484: 01 00 00 00 nop <== NOT EXECUTED _Thread_queue_Extract_with_proxy( the_thread ); 4000b488: 40 00 0a 6a call 4000de30 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 4000b48c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b490: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000b494: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED 4000b498: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED 4000b49c: 40 00 01 e4 call 4000bc2c <_Watchdog_Remove> <== NOT EXECUTED 4000b4a0: 92 06 20 68 add %i0, 0x68, %o1 <== NOT EXECUTED 4000b4a4: 30 bf ff c3 b,a 4000b3b0 <_Thread_Cancel+0x68> <== NOT EXECUTED 4000b4a8: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED _Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING ); 4000b4ac: 13 00 00 80 sethi %hi(0x20000), %o1 <== NOT EXECUTED 4000b4b0: 40 00 00 65 call 4000b644 <_Thread_Set_state_locked> <== NOT EXECUTED 4000b4b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000b4b8: 10 bf ff ba b 4000b3a0 <_Thread_Cancel+0x58> <== NOT EXECUTED 4000b4bc: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED 4000b4c0: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED 4000b4c4: 13 00 00 80 sethi %hi(0x20000), %o1 <== NOT EXECUTED 4000b4c8: 40 00 00 5f call 4000b644 <_Thread_Set_state_locked> <== NOT EXECUTED 4000b4cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000b4d0: 10 bf ff ec b 4000b480 <_Thread_Cancel+0x138> <== NOT EXECUTED 4000b4d4: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED _Thread_Do_dispatch( cpu_self, level ); 4000b4d8: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED 4000b4dc: 7f ff f9 e5 call 40009c70 <_Thread_Do_dispatch> <== NOT EXECUTED 4000b4e0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 4000b4e4: 10 bf ff d1 b 4000b428 <_Thread_Cancel+0xe0> <== NOT EXECUTED 4000b4e8: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED =============================================================================== 4000b57c <_Thread_Change_life>: Thread_Life_state _Thread_Change_life( Thread_Life_state clear, Thread_Life_state set, Thread_Life_state ignore ) { 4000b57c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b580: 91 d0 20 09 ta 9 <== NOT EXECUTED executing = _Thread_Executing; 4000b584: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0 previous = the_thread->Life.state; 4000b588: fa 02 21 70 ld [ %o0 + 0x170 ], %i5 state &= ~clear; 4000b58c: 84 2f 40 18 andn %i5, %i0, %g2 state |= set; 4000b590: b2 16 40 02 or %i1, %g2, %i1 the_thread->Life.state = state; 4000b594: f2 22 21 70 st %i1, [ %o0 + 0x170 ] state &= ~ignore; 4000b598: b2 2e 40 1a andn %i1, %i2, %i1 if ( 4000b59c: 80 8e 60 09 btst 9, %i1 4000b5a0: 12 80 00 07 bne 4000b5bc <_Thread_Change_life+0x40> 4000b5a4: 80 8e 60 06 btst 6, %i1 && _Thread_Is_life_changing( state ) 4000b5a8: 02 80 00 05 be 4000b5bc <_Thread_Change_life+0x40> <== ALWAYS TAKEN 4000b5ac: 01 00 00 00 nop 4000b5b0: 7f ff fe 83 call 4000afbc <_Thread_Change_life_locked.part.37> <== NOT EXECUTED 4000b5b4: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED 4000b5b8: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 4000b5bc: c4 01 a0 18 ld [ %g6 + 0x18 ], %g2 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000b5c0: 84 00 a0 01 inc %g2 <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000b5c4: 90 10 00 06 mov %g6, %o0 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000b5c8: c4 21 a0 18 st %g2, [ %g6 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b5cc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b5d0: 01 00 00 00 nop uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000b5d4: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 if ( disable_level == 1 ) { 4000b5d8: 80 a0 60 01 cmp %g1, 1 4000b5dc: 02 80 00 06 be 4000b5f4 <_Thread_Change_life+0x78> 4000b5e0: 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; } 4000b5e4: b0 10 00 1d mov %i5, %i0 cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000b5e8: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] 4000b5ec: 81 c7 e0 08 ret 4000b5f0: 81 e8 00 00 restore __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b5f4: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000b5f8: c4 09 a0 1c ldub [ %g6 + 0x1c ], %g2 4000b5fc: 80 a0 a0 00 cmp %g2, 0 4000b600: 12 80 00 07 bne 4000b61c <_Thread_Change_life+0xa0> <== NEVER TAKEN 4000b604: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = 0; 4000b608: c0 21 a0 18 clr [ %g6 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b60c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b610: 01 00 00 00 nop 4000b614: 81 c7 e0 08 ret 4000b618: 91 e8 00 1d restore %g0, %i5, %o0 _Thread_Do_dispatch( cpu_self, level ); 4000b61c: 7f ff f9 95 call 40009c70 <_Thread_Do_dispatch> <== NOT EXECUTED 4000b620: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED 4000b624: 10 bf ff fa b 4000b60c <_Thread_Change_life+0x90> <== NOT EXECUTED 4000b628: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED =============================================================================== 4000ddd8 <_Thread_Clear_state>: States_Control _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 4000ddd8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000dddc: 91 d0 20 09 ta 9 <== NOT EXECUTED previous_state = the_thread->current_state; 4000dde0: fa 06 20 1c ld [ %i0 + 0x1c ], %i5 if ( ( previous_state & state ) != 0 ) { 4000dde4: 80 8e 40 1d btst %i1, %i5 4000dde8: 02 80 00 06 be 4000de00 <_Thread_Clear_state+0x28> <== NEVER TAKEN 4000ddec: 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); 4000ddf0: b2 2f 40 19 andn %i5, %i1, %i1 if ( _States_Is_ready( next_state ) ) { 4000ddf4: 80 a6 60 00 cmp %i1, 0 4000ddf8: 02 80 00 06 be 4000de10 <_Thread_Clear_state+0x38> <== ALWAYS TAKEN 4000ddfc: f2 26 20 1c st %i1, [ %i0 + 0x1c ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000de00: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000de04: 01 00 00 00 nop <== NOT EXECUTED _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; } 4000de08: 81 c7 e0 08 ret <== NOT EXECUTED 4000de0c: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED 4000de10: c2 27 bf fc st %g1, [ %fp + -4 ] 4000de14: 7f ff ff dc call 4000dd84 <_Thread_Clear_state_locked.part.10> 4000de18: 90 10 00 18 mov %i0, %o0 4000de1c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED 4000de20: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000de24: 01 00 00 00 nop 4000de28: 81 c7 e0 08 ret 4000de2c: 91 e8 00 1d restore %g0, %i5, %o0 =============================================================================== 4000dda8 <_Thread_Clear_state_locked>: { 4000dda8: 9d e3 bf a0 save %sp, -96, %sp previous_state = the_thread->current_state; 4000ddac: fa 06 20 1c ld [ %i0 + 0x1c ], %i5 if ( ( previous_state & state ) != 0 ) { 4000ddb0: 80 8f 40 19 btst %i5, %i1 4000ddb4: 02 80 00 07 be 4000ddd0 <_Thread_Clear_state_locked+0x28> <== NEVER TAKEN 4000ddb8: b2 2f 40 19 andn %i5, %i1, %i1 if ( _States_Is_ready( next_state ) ) { 4000ddbc: 80 a6 60 00 cmp %i1, 0 4000ddc0: 12 80 00 04 bne 4000ddd0 <_Thread_Clear_state_locked+0x28> <== NEVER TAKEN 4000ddc4: f2 26 20 1c st %i1, [ %i0 + 0x1c ] 4000ddc8: 7f ff ff ef call 4000dd84 <_Thread_Clear_state_locked.part.10> 4000ddcc: 90 10 00 18 mov %i0, %o0 } 4000ddd0: 81 c7 e0 08 ret 4000ddd4: 91 e8 00 1d restore %g0, %i5, %o0 =============================================================================== 4000b500 <_Thread_Close>: Thread_Control *the_thread, Thread_Control *executing, Thread_Close_context *context ) { context->cancel = the_thread; 4000b500: d0 22 a0 24 st %o0, [ %o2 + 0x24 ] <== NOT EXECUTED queue_context->enqueue_callout = enqueue_callout; 4000b504: 03 10 00 2d sethi %hi(0x4000b400), %g1 <== NOT EXECUTED 4000b508: 82 10 60 ec or %g1, 0xec, %g1 ! 4000b4ec <_Thread_Close_enqueue_callout> <== NOT EXECUTED 4000b50c: c2 22 a0 08 st %g1, [ %o2 + 8 ] <== NOT EXECUTED { 4000b510: 96 10 00 0a mov %o2, %o3 <== NOT EXECUTED executing->Wait.return_argument = NULL; 4000b514: c0 22 60 40 clr [ %o1 + 0x40 ] <== NOT EXECUTED queue_context->thread_state = thread_state; 4000b518: 03 00 00 10 sethi %hi(0x4000), %g1 <== NOT EXECUTED 4000b51c: c2 22 e0 04 st %g1, [ %o3 + 4 ] <== NOT EXECUTED { 4000b520: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED _Thread_queue_Enqueue( 4000b524: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 4000b528: 13 10 00 42 sethi %hi(0x40010800), %o1 <== NOT EXECUTED 4000b52c: 92 12 60 4c or %o1, 0x4c, %o1 ! 4001084c <_Thread_queue_Operations_priority> <== NOT EXECUTED 4000b530: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4000b534: 7f ff fb 72 call 4000a2fc <_Thread_queue_Enqueue> <== NOT EXECUTED 4000b538: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 4001536c <_Thread_Continue>: #include #include void _Thread_Continue( Thread_Control *the_thread, Status_Control status ) { 4001536c: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED queue_context->Priority.update_count = 0; 40015370: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40015374: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 40015378: c2 27 bf dc st %g1, [ %fp + -36 ] 4001537c: 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 ) { 40015380: 80 8f 60 04 btst 4, %i5 40015384: 12 80 00 20 bne 40015404 <_Thread_Continue+0x98> <== NEVER TAKEN 40015388: 92 10 00 18 mov %i0, %o1 ( *the_thread->Wait.operations->extract )( 4001538c: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 40015390: c2 00 60 08 ld [ %g1 + 8 ], %g1 40015394: d0 06 20 54 ld [ %i0 + 0x54 ], %o0 40015398: 9f c0 40 00 call %g1 4001539c: 94 07 bf dc add %fp, -36, %o2 the_thread->Wait.operations = &_Thread_queue_Operations_default; 400153a0: 03 10 00 bc sethi %hi(0x4002f000), %g1 400153a4: 82 10 60 08 or %g1, 8, %g1 ! 4002f008 <_Thread_queue_Operations_default> 400153a8: 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; 400153ac: 03 00 00 3f sethi %hi(0xfc00), %g1 400153b0: 82 10 63 00 or %g1, 0x300, %g1 ! ff00 if ( success ) { 400153b4: c4 06 20 50 ld [ %i0 + 0x50 ], %g2 400153b8: ba 0f 40 01 and %i5, %g1, %i5 the_thread->Wait.queue = NULL; 400153bc: c0 26 20 54 clr [ %i0 + 0x54 ] ready_again = wait_class | THREAD_WAIT_STATE_READY_AGAIN; success = _Thread_Wait_flags_try_change_release( 400153c0: 82 17 60 01 or %i5, 1, %g1 the_thread->Wait.return_code = status; 400153c4: f4 26 20 4c st %i2, [ %i0 + 0x4c ] ready_again = wait_class | THREAD_WAIT_STATE_READY_AGAIN; 400153c8: ba 17 60 04 or %i5, 4, %i5 if ( success ) { 400153cc: 80 a0 40 02 cmp %g1, %g2 400153d0: 02 80 00 0d be 40015404 <_Thread_Continue+0x98> <== NEVER TAKEN 400153d4: fa 26 20 50 st %i5, [ %i0 + 0x50 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400153d8: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400153dc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400153e0: 01 00 00 00 nop } else { unblock = false; } _Thread_Wait_release( the_thread, &queue_context ); _Thread_Priority_update( &queue_context ); 400153e4: 7f ff f6 e2 call 40012f6c <_Thread_Priority_update> 400153e8: 90 07 bf dc add %fp, -36, %o0 _Thread_Clear_state( the_thread, STATES_BLOCKED ); 400153ec: 90 10 00 18 mov %i0, %o0 400153f0: 13 0c 00 57 sethi %hi(0x30015c00), %o1 400153f4: 7f ff f7 0b call 40013020 <_Thread_Clear_state> 400153f8: 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 } } 400153fc: 81 c7 e0 08 ret 40015400: 81 e8 00 00 restore register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40015404: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40015408: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4001540c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Priority_update( &queue_context ); 40015410: 7f ff f6 d7 call 40012f6c <_Thread_Priority_update> <== NOT EXECUTED 40015414: 90 07 bf dc add %fp, -36, %o0 <== NOT EXECUTED } 40015418: 81 c7 e0 08 ret <== NOT EXECUTED 4001541c: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40009b60 <_Thread_Create_idle>: _Scheduler_Start_idle( scheduler, idle, cpu ); _User_extensions_Thread_start( idle ); } void _Thread_Create_idle( void ) { 40009b60: 9d e3 bf 70 save %sp, -144, %sp 40009b64: 03 10 00 49 sethi %hi(0x40012400), %g1 40009b68: 84 10 20 01 mov 1, %g2 return maximum_internal_threads; } RTEMS_INLINE_ROUTINE Thread_Control *_Thread_Internal_allocate( void ) { return (Thread_Control *) 40009b6c: 31 10 00 4a sethi %hi(0x40012800), %i0 40009b70: c4 20 61 a0 st %g2, [ %g1 + 0x1a0 ] 40009b74: 7f ff fa 33 call 40008440 <_Objects_Allocate_unprotected> 40009b78: 90 16 22 10 or %i0, 0x210, %o0 _Stack_Ensure_minimum( rtems_configuration_get_idle_task_stack_size() ), 40009b7c: 37 10 00 3f sethi %hi(0x4000fc00), %i3 40009b80: 03 10 00 43 sethi %hi(0x40010c00), %g1 40009b84: b6 16 e2 94 or %i3, 0x294, %i3 40009b88: c2 00 62 00 ld [ %g1 + 0x200 ], %g1 40009b8c: f4 06 e0 20 ld [ %i3 + 0x20 ], %i2 40009b90: 80 a6 80 01 cmp %i2, %g1 40009b94: 1a 80 00 03 bcc 40009ba0 <_Thread_Create_idle+0x40> <== ALWAYS TAKEN 40009b98: b8 10 00 08 mov %o0, %i4 40009b9c: b4 10 00 01 mov %g1, %i2 <== NOT EXECUTED _Thread_Initialize( 40009ba0: 3b 10 00 3f sethi %hi(0x4000fc00), %i5 40009ba4: ba 17 63 78 or %i5, 0x378, %i5 ! 4000ff78 <_Scheduler_Table> return ( *scheduler->Operations.map_priority )( scheduler, priority ); 40009ba8: d4 07 60 44 ld [ %i5 + 0x44 ], %o2 40009bac: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 40009bb0: d2 07 60 40 ld [ %i5 + 0x40 ], %o1 40009bb4: 9f c0 40 00 call %g1 40009bb8: 90 10 00 1d mov %i5, %o0 40009bbc: d0 3f bf f0 std %o0, [ %fp + -16 ] 40009bc0: 82 07 bf fc add %fp, -4, %g1 40009bc4: c2 23 a0 74 st %g1, [ %sp + 0x74 ] 40009bc8: b2 10 20 01 mov 1, %i1 40009bcc: c2 07 bf f0 ld [ %fp + -16 ], %g1 40009bd0: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 40009bd4: 98 10 00 1a mov %i2, %o4 40009bd8: c2 07 bf f4 ld [ %fp + -12 ], %g1 40009bdc: f2 23 a0 64 st %i1, [ %sp + 0x64 ] 40009be0: 9a 10 20 00 clr %o5 40009be4: c2 23 a0 60 st %g1, [ %sp + 0x60 ] 40009be8: 03 12 51 13 sethi %hi(0x49444c00), %g1 40009bec: c0 23 a0 70 clr [ %sp + 0x70 ] 40009bf0: 82 10 60 45 or %g1, 0x45, %g1 40009bf4: c0 23 a0 6c clr [ %sp + 0x6c ] 40009bf8: 96 10 20 00 clr %o3 40009bfc: c0 23 a0 68 clr [ %sp + 0x68 ] 40009c00: 94 10 00 1d mov %i5, %o2 40009c04: 92 10 00 1c mov %i4, %o1 40009c08: 90 16 22 10 or %i0, 0x210, %o0 40009c0c: 40 00 00 b5 call 40009ee0 <_Thread_Initialize> 40009c10: c2 27 bf fc st %g1, [ %fp + -4 ] idle->Start.Entry.Kinds.Idle.entry = rtems_configuration_get_idle_task(); 40009c14: c4 06 e0 1c ld [ %i3 + 0x1c ], %g2 cpu->executing = idle; 40009c18: 37 10 00 4a sethi %hi(0x40012800), %i3 40009c1c: b6 16 e1 c0 or %i3, 0x1c0, %i3 ! 400129c0 <_Per_CPU_Information> 40009c20: f8 26 e0 20 st %i4, [ %i3 + 0x20 ] idle->Start.Entry.adaptor = _Thread_Entry_adaptor_idle; 40009c24: 03 10 00 27 sethi %hi(0x40009c00), %g1 cpu->heir = 40009c28: f8 26 e0 24 st %i4, [ %i3 + 0x24 ] idle->Start.Entry.adaptor = _Thread_Entry_adaptor_idle; 40009c2c: 82 10 61 bc or %g1, 0x1bc, %g1 idle->is_idle = true; 40009c30: f2 2f 20 88 stb %i1, [ %i4 + 0x88 ] _Thread_Load_environment( idle ); 40009c34: 90 10 00 1c mov %i4, %o0 idle->Start.Entry.adaptor = _Thread_Entry_adaptor_idle; 40009c38: c2 27 20 a0 st %g1, [ %i4 + 0xa0 ] _User_extensions_Iterate( 40009c3c: 33 10 00 2e sethi %hi(0x4000b800), %i1 idle->Start.Entry.Kinds.Idle.entry = rtems_configuration_get_idle_task(); 40009c40: c4 27 20 a4 st %g2, [ %i4 + 0xa4 ] _Thread_Load_environment( idle ); 40009c44: 40 00 01 67 call 4000a1e0 <_Thread_Load_environment> 40009c48: b4 10 20 00 clr %i2 idle->current_state = STATES_READY; 40009c4c: c0 27 20 1c clr [ %i4 + 0x1c ] ( *scheduler->Operations.start_idle )( scheduler, the_thread, cpu ); 40009c50: 94 10 00 1b mov %i3, %o2 40009c54: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 40009c58: 92 10 00 1c mov %i4, %o1 40009c5c: 90 10 00 1d mov %i5, %o0 40009c60: 9f c0 40 00 call %g1 40009c64: b0 10 00 1c mov %i4, %i0 40009c68: 40 00 07 93 call 4000bab4 <_User_extensions_Iterate> 40009c6c: 93 ee 61 d4 restore %i1, 0x1d4, %o1 =============================================================================== 4001d970 <_Thread_Dispatch>: __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4001d970: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4001d974: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED _ISR_Local_disable( level ); cpu_self = _Per_CPU_Get(); if ( cpu_self->dispatch_necessary ) { 4001d978: c4 09 a0 1c ldub [ %g6 + 0x1c ], %g2 <== NOT EXECUTED 4001d97c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001d980: 12 80 00 06 bne 4001d998 <_Thread_Dispatch+0x28> <== NOT EXECUTED 4001d984: 90 10 00 06 mov %g6, %o0 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4001d988: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4001d98c: 01 00 00 00 nop <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = 1; _Thread_Do_dispatch( cpu_self, level ); } else { _ISR_Local_enable( level ); } } 4001d990: 81 c3 e0 08 retl <== NOT EXECUTED 4001d994: 01 00 00 00 nop <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = 1; 4001d998: 82 10 20 01 mov 1, %g1 ! 1 <_TLS_Alignment> <== NOT EXECUTED 4001d99c: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED _Thread_Do_dispatch( cpu_self, level ); 4001d9a0: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4001d9a4: 7f ff ff ab call 4001d850 <_Thread_Do_dispatch> <== NOT EXECUTED 4001d9a8: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 40009d90 <_Thread_Dispatch_direct>: _ISR_Local_enable( level ); } } void _Thread_Dispatch_direct( Per_CPU_Control *cpu_self ) { 40009d90: 9d e3 bf a0 save %sp, -96, %sp ISR_Level level; if ( cpu_self->thread_dispatch_disable_level != 1 ) { 40009d94: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 40009d98: 80 a0 60 01 cmp %g1, 1 40009d9c: 12 80 00 05 bne 40009db0 <_Thread_Dispatch_direct+0x20> <== NEVER TAKEN 40009da0: 01 00 00 00 nop <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40009da4: 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 ); 40009da8: 7f ff ff b2 call 40009c70 <_Thread_Do_dispatch> 40009dac: 93 e8 00 01 restore %g0, %g1, %o1 _Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_DISABLE_LEVEL ); 40009db0: 7f ff f4 6e call 40006f68 <_Internal_error> <== NOT EXECUTED 40009db4: 90 10 20 1e mov 0x1e, %o0 <== NOT EXECUTED 40009db8: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40009c70 <_Thread_Do_dispatch>: _Thread_State_release( executing, &lock_context ); } void _Thread_Do_dispatch( Per_CPU_Control *cpu_self, ISR_Level level ) { 40009c70: 9d e3 bf 98 save %sp, -104, %sp ) { _Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT ); } #endif executing = cpu_self->executing; 40009c74: f6 06 20 20 ld [ %i0 + 0x20 ], %i3 { 40009c78: 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(); 40009c7c: 23 10 00 3f sethi %hi(0x4000fc00), %l1 return _Chain_Immutable_head( the_chain )->next; 40009c80: 33 10 00 43 sethi %hi(0x40010c00), %i1 40009c84: a2 14 62 94 or %l1, 0x294, %l1 40009c88: b2 16 63 c0 or %i1, 0x3c0, %i1 _ISR_Local_enable( level ); _User_extensions_Thread_switch( executing, heir ); _Thread_Save_fp( executing ); _Context_Switch( &executing->Registers, &heir->Registers ); 40009c8c: a0 06 e0 f0 add %i3, 0xf0, %l0 if ( node != tail ) { 40009c90: b4 06 60 04 add %i1, 4, %i2 Per_CPU_Control *cpu_self ) { Thread_Control *heir; heir = cpu_self->heir; 40009c94: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 cpu_self->dispatch_necessary = false; 40009c98: c0 2e 20 1c clrb [ %i0 + 0x1c ] if ( heir == executing ) 40009c9c: 80 a6 c0 1c cmp %i3, %i4 40009ca0: 02 80 00 1f be 40009d1c <_Thread_Do_dispatch+0xac> 40009ca4: f8 26 20 20 st %i4, [ %i0 + 0x20 ] if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) 40009ca8: c4 07 20 90 ld [ %i4 + 0x90 ], %g2 40009cac: 80 a0 a0 01 cmp %g2, 1 40009cb0: 12 80 00 04 bne 40009cc0 <_Thread_Do_dispatch+0x50> 40009cb4: 01 00 00 00 nop heir->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice(); 40009cb8: c4 04 60 18 ld [ %l1 + 0x18 ], %g2 <== NOT EXECUTED 40009cbc: c4 27 20 8c st %g2, [ %i4 + 0x8c ] <== NOT EXECUTED 40009cc0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40009cc4: 01 00 00 00 nop 40009cc8: fa 06 40 00 ld [ %i1 ], %i5 40009ccc: 80 a7 40 1a cmp %i5, %i2 40009cd0: 02 80 00 0b be 40009cfc <_Thread_Do_dispatch+0x8c> 40009cd4: 92 07 20 f0 add %i4, 0xf0, %o1 (*extension->thread_switch)( executing, heir ); 40009cd8: c2 07 60 08 ld [ %i5 + 8 ], %g1 40009cdc: 92 10 00 1c mov %i4, %o1 40009ce0: 9f c0 40 00 call %g1 40009ce4: 90 10 00 1b mov %i3, %o0 40009ce8: fa 07 40 00 ld [ %i5 ], %i5 while ( node != tail ) { 40009cec: 80 a7 40 1a cmp %i5, %i2 40009cf0: 32 bf ff fb bne,a 40009cdc <_Thread_Do_dispatch+0x6c> <== NEVER TAKEN 40009cf4: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED _Context_Switch( &executing->Registers, &heir->Registers ); 40009cf8: 92 07 20 f0 add %i4, 0xf0, %o1 40009cfc: 40 00 16 4f call 4000f638 <_CPU_Context_switch> 40009d00: 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(); 40009d04: b0 10 00 06 mov %g6, %i0 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40009d08: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_Local_disable( level ); } while ( cpu_self->dispatch_necessary ); 40009d0c: c4 09 a0 1c ldub [ %g6 + 0x1c ], %g2 40009d10: 80 a0 a0 00 cmp %g2, 0 40009d14: 32 bf ff e1 bne,a 40009c98 <_Thread_Do_dispatch+0x28> <== NEVER TAKEN 40009d18: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 <== NOT EXECUTED post_switch: _Assert( cpu_self->thread_dispatch_disable_level == 1 ); cpu_self->thread_dispatch_disable_level = 0; 40009d1c: c0 26 20 18 clr [ %i0 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009d20: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40009d24: 01 00 00 00 nop <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40009d28: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( lock_context ); 40009d2c: c2 27 bf fc st %g1, [ %fp + -4 ] 40009d30: d2 06 e0 e0 ld [ %i3 + 0xe0 ], %o1 return &the_chain->Tail.Node; 40009d34: ba 06 e0 e4 add %i3, 0xe4, %i5 if ( !_Chain_Is_empty(the_chain)) 40009d38: 80 a2 40 1d cmp %o1, %i5 40009d3c: 02 80 00 10 be 40009d7c <_Thread_Do_dispatch+0x10c> 40009d40: b8 06 e0 e0 add %i3, 0xe0, %i4 new_first = old_first->next; 40009d44: c2 02 40 00 ld [ %o1 ], %g1 head->next = new_first; 40009d48: c2 26 e0 e0 st %g1, [ %i3 + 0xe0 ] ( *action->handler )( executing, action, &lock_context ); 40009d4c: 94 07 bf fc add %fp, -4, %o2 new_first->previous = head; 40009d50: f8 20 60 04 st %i4, [ %g1 + 4 ] node->next = NULL; 40009d54: c0 22 40 00 clr [ %o1 ] 40009d58: c2 02 60 08 ld [ %o1 + 8 ], %g1 40009d5c: 9f c0 40 00 call %g1 40009d60: 90 10 00 1b mov %i3, %o0 40009d64: 91 d0 20 09 ta 9 <== NOT EXECUTED 40009d68: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 40009d6c: d2 06 e0 e0 ld [ %i3 + 0xe0 ], %o1 <== NOT EXECUTED if ( !_Chain_Is_empty(the_chain)) 40009d70: 80 a7 40 09 cmp %i5, %o1 <== NOT EXECUTED 40009d74: 32 bf ff f5 bne,a 40009d48 <_Thread_Do_dispatch+0xd8> <== NOT EXECUTED 40009d78: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40009d7c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009d80: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40009d84: 01 00 00 00 nop _Profiling_Thread_dispatch_enable( cpu_self, 0 ); _ISR_Local_enable( level ); _Thread_Run_post_switch_actions( executing ); } 40009d88: 81 c7 e0 08 ret 40009d8c: 81 e8 00 00 restore =============================================================================== 40009dd4 <_Thread_Entry_adaptor_numeric>: #endif #include void _Thread_Entry_adaptor_numeric( Thread_Control *executing ) { 40009dd4: 9d e3 bf a0 save %sp, -96, %sp const Thread_Entry_numeric *numeric = &executing->Start.Entry.Kinds.Numeric; ( *numeric->entry )( numeric->argument ); 40009dd8: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 40009ddc: 9f c0 40 00 call %g1 40009de0: d0 06 20 a8 ld [ %i0 + 0xa8 ], %o0 } 40009de4: 81 c7 e0 08 ret <== NOT EXECUTED 40009de8: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000b53c <_Thread_Exit>: void _Thread_Exit( Thread_Control *executing, Thread_Life_state set, void *exit_value ) { 4000b53c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b540: 91 d0 20 09 ta 9 <== NOT EXECUTED state |= set; 4000b544: c4 06 21 70 ld [ %i0 + 0x170 ], %g2 4000b548: b2 16 40 02 or %i1, %g2, %i1 the_thread->Life.exit_value = exit_value; 4000b54c: f4 26 21 78 st %i2, [ %i0 + 0x178 ] && _Thread_Is_life_changing( state ) 4000b550: 80 8e 60 06 btst 6, %i1 4000b554: 02 80 00 06 be 4000b56c <_Thread_Exit+0x30> <== NEVER TAKEN 4000b558: f2 26 21 70 st %i1, [ %i0 + 0x170 ] 4000b55c: c2 27 bf fc st %g1, [ %fp + -4 ] 4000b560: 7f ff fe 97 call 4000afbc <_Thread_Change_life_locked.part.37> 4000b564: 90 10 00 18 mov %i0, %o0 4000b568: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b56c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b570: 01 00 00 00 nop 0, set, THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED ); _Thread_State_release( executing, &lock_context ); } 4000b574: 81 c7 e0 08 ret 4000b578: 81 e8 00 00 restore =============================================================================== 40009dec <_Thread_Get>: ISR_lock_Context *lock_context ) { Objects_Information *information; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 40009dec: 80 a2 20 00 cmp %o0, 0 40009df0: 02 80 00 11 be 40009e34 <_Thread_Get+0x48> 40009df4: 83 32 20 18 srl %o0, 0x18, %g1 40009df8: 82 08 60 07 and %g1, 7, %g1 if ( !the_api || the_api > OBJECTS_APIS_LAST ) 40009dfc: 84 00 7f ff add %g1, -1, %g2 40009e00: 80 a0 a0 02 cmp %g2, 2 40009e04: 18 80 00 10 bgu 40009e44 <_Thread_Get+0x58> <== NEVER TAKEN 40009e08: 83 28 60 02 sll %g1, 2, %g1 return _Objects_Information_table[ the_api ][ 1 ]; 40009e0c: 05 10 00 41 sethi %hi(0x40010400), %g2 40009e10: 84 10 a3 d4 or %g2, 0x3d4, %g2 ! 400107d4 <_Objects_Information_table> 40009e14: c2 00 80 01 ld [ %g2 + %g1 ], %g1 40009e18: 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 ) { 40009e1c: 80 a2 a0 00 cmp %o2, 0 40009e20: 02 80 00 09 be 40009e44 <_Thread_Get+0x58> <== NEVER TAKEN 40009e24: 01 00 00 00 nop return NULL; } return (Thread_Control *) 40009e28: 82 13 c0 00 mov %o7, %g1 40009e2c: 40 00 0e 85 call 4000d840 <_Objects_Get> 40009e30: 9e 10 40 00 mov %g1, %o7 40009e34: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( lock_context ); 40009e38: c2 22 40 00 st %g1, [ %o1 ] return _Thread_Executing; 40009e3c: 81 c3 e0 08 retl 40009e40: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0 _Objects_Get( id, lock_context, information ); } 40009e44: 81 c3 e0 08 retl <== NOT EXECUTED 40009e48: 90 10 20 00 clr %o0 <== NOT EXECUTED =============================================================================== 40045094 <_Thread_Get_CPU_time_used>: void _Thread_Get_CPU_time_used( Thread_Control *the_thread, Timestamp_Control *cpu_time_used ) { 40045094: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40045098: 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 ) ) { 4004509c: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2 <== NOT EXECUTED 400450a0: 80 a6 00 02 cmp %i0, %g2 <== NOT EXECUTED 400450a4: 02 80 00 08 be 400450c4 <_Thread_Get_CPU_time_used+0x30> <== NOT EXECUTED 400450a8: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED 400450ac: 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; 400450b0: c4 3e 40 00 std %g2, [ %i1 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400450b4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400450b8: 01 00 00 00 nop <== NOT EXECUTED _Scheduler_Release_critical( scheduler, &scheduler_lock_context ); _Thread_State_release( the_thread, &state_lock_context ); } 400450bc: 81 c7 e0 08 ret <== NOT EXECUTED 400450c0: 81 e8 00 00 restore <== NOT EXECUTED last = cpu->cpu_usage_timestamp; 400450c4: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 <== NOT EXECUTED *time = _Timecounter_Sbinuptime(); 400450c8: 7f ff 59 ba call 4001b7b0 <_Timecounter_Sbinuptime> <== NOT EXECUTED 400450cc: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED 400450d0: d0 3f 60 28 std %o0, [ %i5 + 0x28 ] <== NOT EXECUTED *_result = *_end - *_start; 400450d4: b6 a2 40 11 subcc %o1, %l1, %i3 <== NOT EXECUTED *_time += *_add; 400450d8: f8 1e 20 98 ldd [ %i0 + 0x98 ], %i4 <== NOT EXECUTED *_result = *_end - *_start; 400450dc: b4 62 00 10 subx %o0, %l0, %i2 <== NOT EXECUTED *_time += *_add; 400450e0: 86 86 c0 1d addcc %i3, %i5, %g3 <== NOT EXECUTED 400450e4: 84 46 80 1c addx %i2, %i4, %g2 <== NOT EXECUTED 400450e8: c4 3e 20 98 std %g2, [ %i0 + 0x98 ] <== NOT EXECUTED 400450ec: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED *cpu_time_used = the_thread->cpu_time_used; 400450f0: c4 3e 40 00 std %g2, [ %i1 ] <== NOT EXECUTED 400450f4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400450f8: 01 00 00 00 nop <== NOT EXECUTED } 400450fc: 81 c7 e0 08 ret <== NOT EXECUTED 40045100: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4001a50c <_Thread_Get_name>: size_t _Thread_Get_name( const Thread_Control *the_thread, char *buffer, size_t buffer_size ) { 4001a50c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED const char *name; name = the_thread->Join_queue.Queue.name; 4001a510: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED { 4001a514: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED if ( name != NULL && name[ 0 ] != '\0' ) { 4001a518: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001a51c: 02 80 00 06 be 4001a534 <_Thread_Get_name+0x28> <== NOT EXECUTED 4001a520: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 4001a524: c4 48 40 00 ldsb [ %g1 ], %g2 <== NOT EXECUTED 4001a528: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001a52c: 12 80 00 09 bne 4001a550 <_Thread_Get_name+0x44> <== NOT EXECUTED 4001a530: b2 10 00 01 mov %g1, %i1 <== NOT EXECUTED return strlcpy( buffer, name, buffer_size ); } else { return _Objects_Name_to_string( 4001a534: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED 4001a538: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED 4001a53c: 92 10 20 00 clr %o1 <== NOT EXECUTED 4001a540: 7f ff ff 5a call 4001a2a8 <_Objects_Name_to_string> <== NOT EXECUTED 4001a544: 90 07 bf fc add %fp, -4, %o0 <== NOT EXECUTED false, buffer, buffer_size ); } } 4001a548: 81 c7 e0 08 ret <== NOT EXECUTED 4001a54c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return strlcpy( buffer, name, buffer_size ); 4001a550: 40 00 15 33 call 4001fa1c <== NOT EXECUTED 4001a554: 91 e8 00 0a restore %g0, %o2, %o0 <== NOT EXECUTED =============================================================================== 40009e4c <_Thread_Handler>: } #endif } void _Thread_Handler( void ) { 40009e4c: 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(); 40009e50: 3f 10 00 27 sethi %hi(0x40009c00), %i7 <== NOT EXECUTED 40009e54: be 17 e2 4c or %i7, 0x24c, %i7 ! 40009e4c <_Thread_Handler> <== NOT EXECUTED executing = _Thread_Executing; 40009e58: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5 <== NOT EXECUTED 40009e5c: 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; 40009e60: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED _ISR_Set_level( level ); 40009e64: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009e68: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40009e6c: 01 00 00 00 nop <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40009e70: 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 ); 40009e74: 7f ff ff 7f call 40009c70 <_Thread_Do_dispatch> 40009e78: 92 10 00 01 mov %g1, %o1 _User_extensions_Iterate( 40009e7c: 94 10 20 00 clr %o2 40009e80: 90 10 00 1d mov %i5, %o0 40009e84: 13 10 00 2e sethi %hi(0x4000b800), %o1 40009e88: 40 00 07 0b call 4000bab4 <_User_extensions_Iterate> 40009e8c: 92 12 62 1c or %o1, 0x21c, %o1 ! 4000ba1c <_User_extensions_Thread_begin_visitor> if ( executing->Object.id == _Thread_Global_constructor ) { 40009e90: 03 10 00 4a sethi %hi(0x40012800), %g1 40009e94: c6 07 60 08 ld [ %i5 + 8 ], %g3 40009e98: c4 00 62 58 ld [ %g1 + 0x258 ], %g2 40009e9c: 80 a0 c0 02 cmp %g3, %g2 40009ea0: 02 80 00 0c be 40009ed0 <_Thread_Handler+0x84> 40009ea4: 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 ); 40009ea8: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 40009eac: 9f c0 40 00 call %g1 40009eb0: 90 10 00 1d mov %i5, %o0 _User_extensions_Iterate( 40009eb4: 90 10 00 1d mov %i5, %o0 40009eb8: 94 10 20 00 clr %o2 40009ebc: 13 10 00 2e sethi %hi(0x4000b800), %o1 40009ec0: 40 00 06 fd call 4000bab4 <_User_extensions_Iterate> 40009ec4: 92 12 62 40 or %o1, 0x240, %o1 ! 4000ba40 <_User_extensions_Thread_exitted_visitor> * able to fit in a (void *). */ _User_extensions_Thread_exitted( executing ); _Internal_error( INTERNAL_ERROR_THREAD_EXITTED ); 40009ec8: 7f ff f4 28 call 40006f68 <_Internal_error> 40009ecc: 90 10 20 05 mov 5, %o0 INIT_NAME(); 40009ed0: 40 00 1b a8 call 40010d70 <_init> 40009ed4: c0 20 62 58 clr [ %g1 + 0x258 ] ( *executing->Start.Entry.adaptor )( executing ); 40009ed8: 10 bf ff f5 b 40009eac <_Thread_Handler+0x60> 40009edc: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 =============================================================================== 40009af8 <_Thread_Handler_initialization>: THREAD_QUEUE_HEADS_SIZE( _Scheduler_Count ) ); } void _Thread_Handler_initialization(void) { 40009af8: 9d e3 bf a0 save %sp, -96, %sp rtems_stack_allocate_init_hook stack_allocate_init_hook = 40009afc: 03 10 00 3f sethi %hi(0x4000fc00), %g1 40009b00: 82 10 62 94 or %g1, 0x294, %g1 ! 4000fe94 #if defined(RTEMS_MULTIPROCESSING) uint32_t maximum_proxies = _Configuration_MP_table->maximum_proxies; #endif if ( rtems_configuration_get_stack_allocate_hook() == NULL || 40009b04: c6 00 60 2c ld [ %g1 + 0x2c ], %g3 40009b08: 80 a0 e0 00 cmp %g3, 0 40009b0c: 02 80 00 12 be 40009b54 <_Thread_Handler_initialization+0x5c> <== NEVER TAKEN 40009b10: c4 00 60 28 ld [ %g1 + 0x28 ], %g2 40009b14: c6 00 60 30 ld [ %g1 + 0x30 ], %g3 40009b18: 80 a0 e0 00 cmp %g3, 0 40009b1c: 02 80 00 0e be 40009b54 <_Thread_Handler_initialization+0x5c> <== NEVER TAKEN 40009b20: 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 ) 40009b24: 22 80 00 05 be,a 40009b38 <_Thread_Handler_initialization+0x40> <== ALWAYS TAKEN 40009b28: 31 10 00 4a sethi %hi(0x40012800), %i0 (*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() ); 40009b2c: 9f c0 80 00 call %g2 <== NOT EXECUTED 40009b30: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED /* * 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( 40009b34: 31 10 00 4a sethi %hi(0x40012800), %i0 <== NOT EXECUTED 40009b38: ba 10 20 08 mov 8, %i5 40009b3c: b8 10 20 00 clr %i4 40009b40: b6 10 20 01 mov 1, %i3 40009b44: b4 10 20 01 mov 1, %i2 40009b48: b2 10 20 01 mov 1, %i1 40009b4c: 7f ff ff d8 call 40009aac <_Thread_Initialize_information> 40009b50: 91 ee 22 10 restore %i0, 0x210, %o0 _Internal_error( INTERNAL_ERROR_BAD_STACK_HOOK ); 40009b54: 7f ff f5 05 call 40006f68 <_Internal_error> <== NOT EXECUTED 40009b58: 90 10 20 0e mov 0xe, %o0 <== NOT EXECUTED 40009b5c: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40009ee0 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 40009ee0: 9d e3 bf 98 save %sp, -104, %sp 40009ee4: c2 07 a0 74 ld [ %fp + 0x74 ], %g1 return false; } } #endif memset( 40009ee8: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 { 40009eec: e8 00 40 00 ld [ %g1 ], %l4 return (uintptr_t) _TLS_BSS_end - (uintptr_t) _TLS_Data_begin; 40009ef0: 03 10 00 43 sethi %hi(0x40010c00), %g1 40009ef4: 82 10 61 b0 or %g1, 0x1b0, %g1 ! 40010db0 <_Linker_set__Sysinit_bsp_work_area_initialize> 40009ef8: e4 07 a0 5c ld [ %fp + 0x5c ], %l2 40009efc: e6 07 a0 60 ld [ %fp + 0x60 ], %l3 40009f00: e2 07 a0 68 ld [ %fp + 0x68 ], %l1 40009f04: ea 0f a0 67 ldub [ %fp + 0x67 ], %l5 memset( 40009f08: 94 02 bf f0 add %o2, -16, %o2 40009f0c: 21 10 00 43 sethi %hi(0x40010c00), %l0 40009f10: 92 10 20 00 clr %o1 40009f14: a0 14 21 b0 or %l0, 0x1b0, %l0 40009f18: 90 06 60 10 add %i1, 0x10, %o0 40009f1c: 40 00 11 b5 call 4000e5f0 40009f20: 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 ) { 40009f24: 03 10 00 3f sethi %hi(0x4000fc00), %g1 40009f28: de 00 62 d4 ld [ %g1 + 0x2d4 ], %o7 ! 4000fed4 <_Thread_Control_add_on_count> 40009f2c: 80 a3 e0 00 cmp %o7, 0 40009f30: 02 80 00 0e be 40009f68 <_Thread_Initialize+0x88> <== NEVER TAKEN 40009f34: 80 a6 e0 00 cmp %i3, 0 40009f38: 03 10 00 3f sethi %hi(0x4000fc00), %g1 40009f3c: 86 10 20 00 clr %g3 40009f40: 82 10 62 d8 or %g1, 0x2d8, %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; 40009f44: c4 00 60 04 ld [ %g1 + 4 ], %g2 *(void **) ( (char *) the_thread + add_on->destination_offset ) = 40009f48: c8 00 40 00 ld [ %g1 ], %g4 (char *) the_thread + add_on->source_offset; 40009f4c: 84 06 40 02 add %i1, %g2, %g2 *(void **) ( (char *) the_thread + add_on->destination_offset ) = 40009f50: c4 26 40 04 st %g2, [ %i1 + %g4 ] for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) { 40009f54: 86 00 e0 01 inc %g3 40009f58: 80 a0 c0 0f cmp %g3, %o7 40009f5c: 12 bf ff fa bne 40009f44 <_Thread_Initialize+0x64> 40009f60: 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 ) { 40009f64: 80 a6 e0 00 cmp %i3, 0 40009f68: 02 80 00 93 be 4000a1b4 <_Thread_Initialize+0x2d4> <== ALWAYS TAKEN 40009f6c: 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; 40009f70: c0 2e 60 c8 clrb [ %i1 + 0xc8 ] <== NOT EXECUTED 40009f74: ac 06 20 3c add %i0, 0x3c, %l6 Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 40009f78: f6 26 60 d0 st %i3, [ %i1 + 0xd0 ] ); scheduler_index = 0; /* Thread-local storage (TLS) area allocation */ if ( tls_size > 0 ) { 40009f7c: 80 a4 20 00 cmp %l0, 0 40009f80: 12 80 00 6a bne 4000a128 <_Thread_Initialize+0x248> <== NEVER TAKEN 40009f84: 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 ) { 40009f88: 80 a7 60 00 cmp %i5, 0 40009f8c: 12 80 00 79 bne 4000a170 <_Thread_Initialize+0x290> 40009f90: b8 10 20 00 clr %i4 fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) goto failed; } the_thread->fp_context = fp_area; 40009f94: f8 26 61 50 st %i4, [ %i1 + 0x150 ] the_thread->Start.fp_context = fp_area; 40009f98: f8 26 60 d4 st %i4, [ %i1 + 0xd4 ] return information->auto_extend ? information->allocation_size : 0; 40009f9c: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1 40009fa0: 80 a0 60 00 cmp %g1, 0 40009fa4: 12 80 00 5f bne 4000a120 <_Thread_Initialize+0x240> 40009fa8: 94 10 20 00 clr %o2 #endif /* * Get thread queue heads */ the_thread->Wait.spare_heads = _Freechain_Get( 40009fac: 96 10 20 48 mov 0x48, %o3 40009fb0: 90 10 00 16 mov %l6, %o0 40009fb4: 13 10 00 30 sethi %hi(0x4000c000), %o1 40009fb8: 7f ff f2 1d call 4000682c <_Freechain_Get> 40009fbc: 92 12 60 18 or %o1, 0x18, %o1 ! 4000c018 <_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 ) { 40009fc0: 80 a2 20 00 cmp %o0, 0 40009fc4: 02 80 00 48 be 4000a0e4 <_Thread_Initialize+0x204> <== NEVER TAKEN 40009fc8: d0 26 60 5c st %o0, [ %i1 + 0x5c ] return &the_chain->Tail.Node; 40009fcc: 82 02 20 34 add %o0, 0x34, %g1 head->previous = NULL; 40009fd0: c0 22 20 34 clr [ %o0 + 0x34 ] return &the_chain->Tail.Node; 40009fd4: 84 02 20 30 add %o0, 0x30, %g2 head->next = tail; 40009fd8: 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 ) { 40009fdc: 80 a4 60 02 cmp %l1, 2 tail->previous = head; 40009fe0: c4 22 20 38 st %g2, [ %o0 + 0x38 ] the_thread->Start.isr_level = isr_level; 40009fe4: c2 07 a0 70 ld [ %fp + 0x70 ], %g1 40009fe8: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ] the_thread->Start.budget_callout = budget_callout; 40009fec: c2 07 a0 6c ld [ %fp + 0x6c ], %g1 40009ff0: 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 ]; 40009ff4: 03 10 00 4a sethi %hi(0x40012800), %g1 40009ff8: 82 10 61 f8 or %g1, 0x1f8, %g1 ! 400129f8 <_Per_CPU_Information+0x38> the_thread->is_fp = is_fp; 40009ffc: fa 2e 60 8a stb %i5, [ %i1 + 0x8a ] 4000a000: 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; 4000a004: 82 10 20 02 mov 2, %g1 the_thread->Start.is_preemptible = is_preemptible; 4000a008: ea 2e 60 ac stb %l5, [ %i1 + 0xac ] the_thread->Start.budget_algorithm = budget_algorithm; 4000a00c: e2 26 60 b0 st %l1, [ %i1 + 0xb0 ] switch ( budget_algorithm ) { 4000a010: 12 80 00 05 bne 4000a024 <_Thread_Initialize+0x144> <== ALWAYS TAKEN 4000a014: 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(); 4000a018: 03 10 00 3f sethi %hi(0x4000fc00), %g1 <== NOT EXECUTED the_thread->cpu_time_budget = 4000a01c: c2 00 62 ac ld [ %g1 + 0x2ac ], %g1 ! 4000feac <== NOT EXECUTED 4000a020: c2 26 60 8c st %g1, [ %i1 + 0x8c ] <== NOT EXECUTED ( *scheduler->Operations.node_initialize )( 4000a024: 96 10 00 12 mov %l2, %o3 4000a028: fa 06 60 38 ld [ %i1 + 0x38 ], %i5 4000a02c: c2 06 a0 24 ld [ %i2 + 0x24 ], %g1 4000a030: 98 10 00 13 mov %l3, %o4 4000a034: 94 10 00 19 mov %i1, %o2 4000a038: 92 10 00 1d mov %i5, %o1 4000a03c: 9f c0 40 00 call %g1 4000a040: 90 10 00 1a mov %i2, %o0 RTEMS_INLINE_ROUTINE void _Priority_Node_initialize( Priority_Node *node, Priority_Control priority ) { node->priority = priority; 4000a044: 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 ); 4000a048: 82 06 60 20 add %i1, 0x20, %g1 node->priority = priority; 4000a04c: 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; 4000a050: 05 20 00 00 sethi %hi(0x80000000), %g2 RB_ROOT( the_rbtree ) = the_node; 4000a054: c2 27 60 20 st %g1, [ %i5 + 0x20 ] return &the_chain->Tail.Node; 4000a058: 86 06 60 e0 add %i1, 0xe0, %g3 4000a05c: c4 26 60 1c st %g2, [ %i1 + 0x1c ] the_thread->Wait.operations = &_Thread_queue_Operations_default; 4000a060: 05 10 00 42 sethi %hi(0x40010800), %g2 4000a064: 84 10 a0 60 or %g2, 0x60, %g2 ! 40010860 <_Thread_queue_Operations_default> information->local_table[ index ] = the_object; 4000a068: c2 16 60 0a lduh [ %i1 + 0xa ], %g1 4000a06c: c4 26 60 58 st %g2, [ %i1 + 0x58 ] 4000a070: 88 06 60 e4 add %i1, 0xe4, %g4 4000a074: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 RB_PARENT( the_node, Node ) = NULL; 4000a078: c0 26 60 28 clr [ %i1 + 0x28 ] 4000a07c: 83 28 60 02 sll %g1, 2, %g1 RB_LEFT( the_node, Node ) = NULL; 4000a080: c0 26 60 20 clr [ %i1 + 0x20 ] _User_extensions_Iterate( 4000a084: 94 10 20 00 clr %o2 RB_RIGHT( the_node, Node ) = NULL; 4000a088: c0 26 60 24 clr [ %i1 + 0x24 ] 4000a08c: 13 10 00 2e sethi %hi(0x4000b800), %o1 RB_COLOR( the_node, Node ) = RB_BLACK; 4000a090: c0 26 60 2c clr [ %i1 + 0x2c ] 4000a094: 92 12 61 74 or %o1, 0x174, %o1 the_thread->Start.initial_priority = priority; 4000a098: e4 3e 60 c0 std %l2, [ %i1 + 0xc0 ] 4000a09c: 90 07 bf f8 add %fp, -8, %o0 RB_INIT( the_rbtree ); 4000a0a0: c0 26 61 60 clr [ %i1 + 0x160 ] head->next = tail; 4000a0a4: c8 26 60 e0 st %g4, [ %i1 + 0xe0 ] head->previous = NULL; 4000a0a8: c0 26 60 e4 clr [ %i1 + 0xe4 ] tail->previous = head; 4000a0ac: c6 26 60 e8 st %g3, [ %i1 + 0xe8 ] the_object->name = name; 4000a0b0: e8 26 60 0c st %l4, [ %i1 + 0xc ] information->local_table[ index ] = the_object; 4000a0b4: f2 20 80 01 st %i1, [ %g2 + %g1 ] User_extensions_Thread_create_context ctx = { created, true }; 4000a0b8: 82 10 20 01 mov 1, %g1 4000a0bc: f2 27 bf f8 st %i1, [ %fp + -8 ] _User_extensions_Iterate( 4000a0c0: 40 00 06 7d call 4000bab4 <_User_extensions_Iterate> 4000a0c4: 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 ) 4000a0c8: f0 0f bf fc ldub [ %fp + -4 ], %i0 4000a0cc: 80 a6 20 00 cmp %i0, 0 4000a0d0: 12 80 00 0f bne 4000a10c <_Thread_Initialize+0x22c> <== ALWAYS TAKEN 4000a0d4: 92 10 00 1d mov %i5, %o1 ( *scheduler->Operations.node_destroy )( scheduler, node ); 4000a0d8: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1 <== NOT EXECUTED 4000a0dc: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000a0e0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 4000a0e4: d0 06 60 dc ld [ %i1 + 0xdc ], %o0 <== NOT EXECUTED if ( scheduler_index > 0 ) { _Scheduler_Node_destroy( scheduler, scheduler_node ); } #endif _Workspace_Free( the_thread->Start.tls_area ); 4000a0e8: 40 00 07 dc call 4000c058 <_Workspace_Free> <== NOT EXECUTED 4000a0ec: b0 10 20 00 clr %i0 <== NOT EXECUTED _Freechain_Put( 4000a0f0: d2 06 60 5c ld [ %i1 + 0x5c ], %o1 <== NOT EXECUTED 4000a0f4: 7f ff f1 ec call 400068a4 <_Freechain_Put> <== NOT EXECUTED 4000a0f8: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED &information->Free_thread_queue_heads, the_thread->Wait.spare_heads ); #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Workspace_Free( fp_area ); 4000a0fc: 40 00 07 d7 call 4000c058 <_Workspace_Free> <== NOT EXECUTED 4000a100: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 4000a104: 40 00 05 81 call 4000b708 <_Thread_Stack_Free> <== NOT EXECUTED 4000a108: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED return false; 4000a10c: 81 c7 e0 08 ret 4000a110: 81 e8 00 00 restore 4000a114: b0 10 20 00 clr %i0 <== NOT EXECUTED } 4000a118: 81 c7 e0 08 ret <== NOT EXECUTED 4000a11c: 81 e8 00 00 restore <== NOT EXECUTED 4000a120: 10 bf ff a3 b 40009fac <_Thread_Initialize+0xcc> 4000a124: d4 16 20 14 lduh [ %i0 + 0x14 ], %o2 return (val + msk) & ~msk; 4000a128: 90 04 20 07 add %l0, 7, %o0 <== NOT EXECUTED 4000a12c: 13 00 00 00 sethi %hi(0), %o1 <== NOT EXECUTED 4000a130: 90 0a 3f f8 and %o0, -8, %o0 <== NOT EXECUTED 4000a134: 92 12 60 01 or %o1, 1, %o1 <== NOT EXECUTED 4000a138: 92 02 60 07 add %o1, 7, %o1 <== NOT EXECUTED 4000a13c: 92 0a 7f f8 and %o1, -8, %o1 <== NOT EXECUTED sizeof(TLS_Thread_control_block) : alignment; 4000a140: 80 a2 60 08 cmp %o1, 8 <== NOT EXECUTED 4000a144: 0a 80 00 12 bcs 4000a18c <_Thread_Initialize+0x2ac> <== NOT EXECUTED 4000a148: 82 10 00 09 mov %o1, %g1 <== NOT EXECUTED allocation_size += _TLS_Get_thread_control_block_area_size( alignment ); 4000a14c: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED _Workspace_Allocate_aligned( tls_alloc, tls_align ); 4000a150: 40 00 07 ba call 4000c038 <_Workspace_Allocate_aligned> <== NOT EXECUTED 4000a154: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED the_thread->Start.tls_area = 4000a158: d0 26 60 dc st %o0, [ %i1 + 0xdc ] <== NOT EXECUTED if ( the_thread->Start.tls_area == NULL ) { 4000a15c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000a160: 12 bf ff 8a bne 40009f88 <_Thread_Initialize+0xa8> <== NOT EXECUTED 4000a164: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED failed: 4000a168: 10 bf ff e0 b 4000a0e8 <_Thread_Initialize+0x208> <== NOT EXECUTED 4000a16c: 90 10 20 00 clr %o0 <== NOT EXECUTED fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 4000a170: 40 00 07 aa call 4000c018 <_Workspace_Allocate> 4000a174: 90 10 20 88 mov 0x88, %o0 if ( !fp_area ) 4000a178: b8 92 20 00 orcc %o0, 0, %i4 4000a17c: 32 bf ff 87 bne,a 40009f98 <_Thread_Initialize+0xb8> <== ALWAYS TAKEN 4000a180: f8 26 61 50 st %i4, [ %i1 + 0x150 ] failed: 4000a184: 10 bf ff d9 b 4000a0e8 <_Thread_Initialize+0x208> <== NOT EXECUTED 4000a188: d0 06 60 dc ld [ %i1 + 0xdc ], %o0 <== NOT EXECUTED sizeof(TLS_Thread_control_block) : alignment; 4000a18c: 82 10 20 08 mov 8, %g1 <== NOT EXECUTED allocation_size += _TLS_Get_thread_control_block_area_size( alignment ); 4000a190: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED _Workspace_Allocate_aligned( tls_alloc, tls_align ); 4000a194: 40 00 07 a9 call 4000c038 <_Workspace_Allocate_aligned> <== NOT EXECUTED 4000a198: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED the_thread->Start.tls_area = 4000a19c: d0 26 60 dc st %o0, [ %i1 + 0xdc ] <== NOT EXECUTED if ( the_thread->Start.tls_area == NULL ) { 4000a1a0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000a1a4: 12 bf ff 79 bne 40009f88 <_Thread_Initialize+0xa8> <== NOT EXECUTED 4000a1a8: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED 4000a1ac: 10 bf ff cf b 4000a0e8 <_Thread_Initialize+0x208> <== NOT EXECUTED 4000a1b0: 90 10 20 00 clr %o0 <== NOT EXECUTED actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 4000a1b4: 40 00 05 45 call 4000b6c8 <_Thread_Stack_Allocate> 4000a1b8: 90 10 00 19 mov %i1, %o0 if ( !actual_stack_size || actual_stack_size < stack_size ) 4000a1bc: 80 a2 20 00 cmp %o0, 0 4000a1c0: 02 bf ff d5 be 4000a114 <_Thread_Initialize+0x234> <== NEVER TAKEN 4000a1c4: 80 a2 00 1c cmp %o0, %i4 4000a1c8: 0a bf ff d3 bcs 4000a114 <_Thread_Initialize+0x234> <== NEVER TAKEN 4000a1cc: 82 10 20 01 mov 1, %g1 stack = the_thread->Start.stack; 4000a1d0: f6 06 60 d8 ld [ %i1 + 0xd8 ], %i3 the_thread->Start.core_allocated_stack = true; 4000a1d4: c2 2e 60 c8 stb %g1, [ %i1 + 0xc8 ] 4000a1d8: 10 bf ff 67 b 40009f74 <_Thread_Initialize+0x94> 4000a1dc: b8 10 00 08 mov %o0, %i4 =============================================================================== 400136f8 <_Thread_Iterate>: void _Thread_Iterate( Thread_Visitor visitor, void *arg ) { 400136f8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 400136fc: 37 10 00 bb sethi %hi(0x4002ec00), %i3 <== NOT EXECUTED 40013700: b6 16 e3 5c or %i3, 0x35c, %i3 ! 4002ef5c <_Objects_Information_table> <== NOT EXECUTED 40013704: 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 ]; 40013708: c2 06 e0 04 ld [ %i3 + 4 ], %g1 <== NOT EXECUTED 4001370c: f8 00 60 04 ld [ %g1 + 4 ], %i4 <== NOT EXECUTED if ( information == NULL ) { 40013710: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED 40013714: 22 80 00 1d be,a 40013788 <_Thread_Iterate+0x90> <== NOT EXECUTED 40013718: b6 06 e0 04 add %i3, 4, %i3 <== NOT EXECUTED continue; } for ( i = 1 ; i <= information->maximum ; ++i ) { 4001371c: c4 17 20 10 lduh [ %i4 + 0x10 ], %g2 <== NOT EXECUTED 40013720: 82 90 a0 00 orcc %g2, 0, %g1 <== NOT EXECUTED 40013724: 02 80 00 18 be 40013784 <_Thread_Iterate+0x8c> <== NOT EXECUTED 40013728: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED Thread_Control *the_thread; the_thread = (Thread_Control *) information->local_table[ i ]; 4001372c: 10 80 00 09 b 40013750 <_Thread_Iterate+0x58> <== NOT EXECUTED 40013730: c6 07 20 1c ld [ %i4 + 0x1c ], %g3 <== NOT EXECUTED for ( i = 1 ; i <= information->maximum ; ++i ) { 40013734: ba 07 60 01 inc %i5 <== NOT EXECUTED 40013738: 83 28 a0 10 sll %g2, 0x10, %g1 <== NOT EXECUTED 4001373c: 87 2f 60 10 sll %i5, 0x10, %g3 <== NOT EXECUTED 40013740: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 40013744: 38 80 00 11 bgu,a 40013788 <_Thread_Iterate+0x90> <== NOT EXECUTED 40013748: b6 06 e0 04 add %i3, 4, %i3 <== NOT EXECUTED the_thread = (Thread_Control *) information->local_table[ i ]; 4001374c: c6 07 20 1c ld [ %i4 + 0x1c ], %g3 <== NOT EXECUTED 40013750: 83 2f 60 10 sll %i5, 0x10, %g1 <== NOT EXECUTED 40013754: 83 30 60 0e srl %g1, 0xe, %g1 <== NOT EXECUTED 40013758: d0 00 c0 01 ld [ %g3 + %g1 ], %o0 <== NOT EXECUTED if ( the_thread != NULL ) { 4001375c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40013760: 22 bf ff f6 be,a 40013738 <_Thread_Iterate+0x40> <== NOT EXECUTED 40013764: ba 07 60 01 inc %i5 <== NOT EXECUTED bool done; done = (* visitor )( the_thread, arg ); 40013768: 9f c6 00 00 call %i0 <== NOT EXECUTED 4001376c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED if ( done ) { 40013770: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40013774: 22 bf ff f0 be,a 40013734 <_Thread_Iterate+0x3c> <== NOT EXECUTED 40013778: c4 17 20 10 lduh [ %i4 + 0x10 ], %g2 <== NOT EXECUTED return; } } } } } 4001377c: 81 c7 e0 08 ret <== NOT EXECUTED 40013780: 81 e8 00 00 restore <== NOT EXECUTED 40013784: b6 06 e0 04 add %i3, 4, %i3 <== NOT EXECUTED for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; ++api_index ) { 40013788: 80 a6 80 1b cmp %i2, %i3 <== NOT EXECUTED 4001378c: 32 bf ff e0 bne,a 4001370c <_Thread_Iterate+0x14> <== NOT EXECUTED 40013790: c2 06 e0 04 ld [ %i3 + 4 ], %g1 <== NOT EXECUTED } 40013794: 81 c7 e0 08 ret <== NOT EXECUTED 40013798: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000b228 <_Thread_Kill_zombies>: { 4000b228: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b22c: 91 d0 20 09 ta 9 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 4000b230: 05 10 00 43 sethi %hi(0x40010c00), %g2 4000b234: fa 00 a3 cc ld [ %g2 + 0x3cc ], %i5 ! 40010fcc <_Thread_Zombies> 4000b238: b8 10 a3 cc or %g2, 0x3cc, %i4 if ( !_Chain_Is_empty(the_chain)) 4000b23c: b0 07 20 04 add %i4, 4, %i0 4000b240: 80 a7 40 18 cmp %i5, %i0 4000b244: 02 80 00 3d be 4000b338 <_Thread_Kill_zombies+0x110> 4000b248: 33 10 00 2e sethi %hi(0x4000b800), %i1 new_first = old_first->next; 4000b24c: c6 07 40 00 ld [ %i5 ], %g3 <== NOT EXECUTED head->next = new_first; 4000b250: c6 20 a3 cc st %g3, [ %g2 + 0x3cc ] <== NOT EXECUTED new_first->previous = head; 4000b254: f8 20 e0 04 st %i4, [ %g3 + 4 ] <== NOT EXECUTED 4000b258: 35 10 00 3f sethi %hi(0x4000fc00), %i2 <== NOT EXECUTED _User_extensions_Iterate( 4000b25c: b2 16 61 b0 or %i1, 0x1b0, %i1 <== NOT EXECUTED 4000b260: b4 16 a3 78 or %i2, 0x378, %i2 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b264: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b268: 01 00 00 00 nop Thread_Information *information = (Thread_Information *) 4000b26c: 7f ff f5 a1 call 400088f0 <_Objects_Get_information_id> 4000b270: d0 07 60 08 ld [ %i5 + 8 ], %o0 4000b274: 94 10 20 01 mov 1, %o2 4000b278: b6 10 00 08 mov %o0, %i3 4000b27c: 92 10 00 19 mov %i1, %o1 4000b280: 40 00 02 0d call 4000bab4 <_User_extensions_Iterate> 4000b284: 90 10 00 1d mov %i5, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b288: 91 d0 20 09 ta 9 <== NOT EXECUTED iter = the_thread->last_user_extensions_iterator; 4000b28c: c4 07 61 88 ld [ %i5 + 0x188 ], %g2 while ( iter != NULL ) { 4000b290: 80 a0 a0 00 cmp %g2, 0 4000b294: 02 80 00 0a be 4000b2bc <_Thread_Kill_zombies+0x94> <== ALWAYS TAKEN 4000b298: 01 00 00 00 nop next = the_node->next; 4000b29c: c8 00 80 00 ld [ %g2 ], %g4 <== NOT EXECUTED previous = the_node->previous; 4000b2a0: c6 00 a0 04 ld [ %g2 + 4 ], %g3 <== NOT EXECUTED next->previous = previous; 4000b2a4: c6 21 20 04 st %g3, [ %g4 + 4 ] <== NOT EXECUTED previous->next = next; 4000b2a8: c8 20 c0 00 st %g4, [ %g3 ] <== NOT EXECUTED iter = iter->previous; 4000b2ac: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 <== NOT EXECUTED while ( iter != NULL ) { 4000b2b0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000b2b4: 32 bf ff fb bne,a 4000b2a0 <_Thread_Kill_zombies+0x78> <== NOT EXECUTED 4000b2b8: c8 00 80 00 ld [ %g2 ], %g4 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b2bc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b2c0: 01 00 00 00 nop 4000b2c4: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1 4000b2c8: d2 07 60 38 ld [ %i5 + 0x38 ], %o1 4000b2cc: 9f c0 40 00 call %g1 4000b2d0: 90 10 00 1a mov %i2, %o0 _Workspace_Free( the_thread->Start.fp_context ); 4000b2d4: 40 00 03 61 call 4000c058 <_Workspace_Free> 4000b2d8: d0 07 60 d4 ld [ %i5 + 0xd4 ], %o0 _Freechain_Put( 4000b2dc: d2 07 60 5c ld [ %i5 + 0x5c ], %o1 4000b2e0: 7f ff ed 71 call 400068a4 <_Freechain_Put> 4000b2e4: 90 06 e0 3c add %i3, 0x3c, %o0 _Thread_Stack_Free( the_thread ); 4000b2e8: 40 00 01 08 call 4000b708 <_Thread_Stack_Free> 4000b2ec: 90 10 00 1d mov %i5, %o0 _Workspace_Free( the_thread->Start.tls_area ); 4000b2f0: 40 00 03 5a call 4000c058 <_Workspace_Free> 4000b2f4: d0 07 60 dc ld [ %i5 + 0xdc ], %o0 _Context_Destroy( the_thread, &the_thread->Registers ); 4000b2f8: c4 01 a0 04 ld [ %g6 + 4 ], %g2 4000b2fc: 80 a0 80 1d cmp %g2, %i5 4000b300: 22 80 00 02 be,a 4000b308 <_Thread_Kill_zombies+0xe0> <== NEVER TAKEN 4000b304: c0 21 a0 04 clr [ %g6 + 4 ] <== NOT EXECUTED _Objects_Free( &information->Objects, &the_thread->Object ); 4000b308: 92 10 00 1d mov %i5, %o1 4000b30c: 7f ff f5 4d call 40008840 <_Objects_Free> 4000b310: 90 10 00 1b mov %i3, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b314: 91 d0 20 09 ta 9 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 4000b318: fa 07 00 00 ld [ %i4 ], %i5 if ( !_Chain_Is_empty(the_chain)) 4000b31c: 80 a7 40 18 cmp %i5, %i0 4000b320: 02 80 00 06 be 4000b338 <_Thread_Kill_zombies+0x110> 4000b324: 01 00 00 00 nop new_first = old_first->next; 4000b328: c4 07 40 00 ld [ %i5 ], %g2 head->next = new_first; 4000b32c: c4 27 00 00 st %g2, [ %i4 ] new_first->previous = head; 4000b330: 10 bf ff cd b 4000b264 <_Thread_Kill_zombies+0x3c> 4000b334: f8 20 a0 04 st %i4, [ %g2 + 4 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b338: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b33c: 01 00 00 00 nop } 4000b340: 81 c7 e0 08 ret 4000b344: 81 e8 00 00 restore =============================================================================== 40012f28 <_Thread_Priority_add>: Thread_Control *the_thread, Priority_Node *priority_node, Thread_queue_Context *queue_context ) { _Thread_Priority_apply( 40012f28: 98 10 20 00 clr %o4 <== NOT EXECUTED 40012f2c: 96 10 20 00 clr %o3 <== NOT EXECUTED 40012f30: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 40012f34: 7f ff ff e7 call 40012ed0 <_Thread_Priority_apply> <== NOT EXECUTED 40012f38: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 4000dc6c <_Thread_Priority_perform_actions>: void _Thread_Priority_perform_actions( Thread_Control *start_of_path, Thread_queue_Context *queue_context ) { 4000dc6c: 9d e3 bf a0 save %sp, -96, %sp 4000dc70: f8 06 60 14 ld [ %i1 + 0x14 ], %i4 4000dc74: 10 80 00 03 b 4000dc80 <_Thread_Priority_perform_actions+0x14> 4000dc78: 90 10 00 18 mov %i0, %o0 queue_context->Priority.update_count = update_count; 4000dc7c: f8 26 60 14 st %i4, [ %i1 + 0x14 ] <== NOT EXECUTED while ( true ) { Thread_queue_Queue *queue; queue = the_thread->Wait.queue; _Thread_Priority_do_perform_actions( 4000dc80: 98 10 00 19 mov %i1, %o4 queue = the_thread->Wait.queue; 4000dc84: fa 02 20 54 ld [ %o0 + 0x54 ], %i5 _Thread_Priority_do_perform_actions( 4000dc88: d4 02 20 58 ld [ %o0 + 0x58 ], %o2 4000dc8c: 96 10 20 00 clr %o3 4000dc90: 7f ff ff 51 call 4000d9d4 <_Thread_Priority_do_perform_actions.isra.14> 4000dc94: 92 10 00 1d mov %i5, %o1 the_thread->Wait.operations, false, queue_context ); if ( _Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) { 4000dc98: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 4000dc9c: 80 a0 60 00 cmp %g1, 0 4000dca0: 32 bf ff f7 bne,a 4000dc7c <_Thread_Priority_perform_actions+0x10> <== NEVER TAKEN 4000dca4: d0 07 60 04 ld [ %i5 + 4 ], %o0 <== NOT EXECUTED _Thread_queue_Context_restore_priority_updates( queue_context, update_count ); } } 4000dca8: 81 c7 e0 08 ret 4000dcac: 81 e8 00 00 restore =============================================================================== 40012f3c <_Thread_Priority_remove>: Thread_Control *the_thread, Priority_Node *priority_node, Thread_queue_Context *queue_context ) { _Thread_Priority_apply( 40012f3c: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED 40012f40: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED 40012f44: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 40012f48: 7f ff ff e2 call 40012ed0 <_Thread_Priority_apply> <== NOT EXECUTED 40012f4c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 4000dd24 <_Thread_Priority_update>: replacement_node ); } void _Thread_Priority_update( Thread_queue_Context *queue_context ) { 4000dd24: 9d e3 bf 98 save %sp, -104, %sp size_t i; size_t n; n = queue_context->Priority.update_count; 4000dd28: fa 06 20 14 ld [ %i0 + 0x14 ], %i5 /* * 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 ) { 4000dd2c: 80 a7 60 00 cmp %i5, 0 4000dd30: 02 80 00 13 be 4000dd7c <_Thread_Priority_update+0x58> 4000dd34: 39 10 00 3f sethi %hi(0x4000fc00), %i4 4000dd38: b8 17 23 78 or %i4, 0x378, %i4 ! 4000ff78 <_Scheduler_Table> <== NOT EXECUTED ( *scheduler->Operations.update_priority )( 4000dd3c: f6 07 20 18 ld [ %i4 + 0x18 ], %i3 <== NOT EXECUTED 4000dd40: bb 2f 60 02 sll %i5, 2, %i5 <== NOT EXECUTED 4000dd44: 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 ]; 4000dd48: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000dd4c: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000dd50: c2 27 bf fc st %g1, [ %fp + -4 ] 4000dd54: d4 02 60 38 ld [ %o1 + 0x38 ], %o2 4000dd58: 9f c6 c0 00 call %i3 4000dd5c: 90 10 00 1c mov %i4, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000dd60: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000dd64: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000dd68: 01 00 00 00 nop 4000dd6c: b0 06 20 04 add %i0, 4, %i0 for ( i = 0; i < n ; ++i ) { 4000dd70: 80 a6 00 1d cmp %i0, %i5 4000dd74: 32 bf ff f6 bne,a 4000dd4c <_Thread_Priority_update+0x28> <== NEVER TAKEN 4000dd78: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 <== NOT EXECUTED _Thread_State_acquire( the_thread, &lock_context ); _Scheduler_Update_priority( the_thread ); _Thread_State_release( the_thread, &lock_context ); } } 4000dd7c: 81 c7 e0 08 ret 4000dd80: 81 e8 00 00 restore =============================================================================== 4000b67c <_Thread_Set_state>: States_Control _Thread_Set_state( Thread_Control *the_thread, States_Control state ) { 4000b67c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED 4000b680: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b684: 91 d0 20 09 ta 9 <== NOT EXECUTED previous_state = the_thread->current_state; 4000b688: f0 06 20 1c ld [ %i0 + 0x1c ], %i0 4000b68c: b2 16 40 18 or %i1, %i0, %i1 if ( _States_Is_ready( previous_state ) ) { 4000b690: 80 a6 20 00 cmp %i0, 0 4000b694: 12 80 00 09 bne 4000b6b8 <_Thread_Set_state+0x3c> <== NEVER TAKEN 4000b698: f2 22 60 1c st %i1, [ %o1 + 0x1c ] 4000b69c: d4 02 60 38 ld [ %o1 + 0x38 ], %o2 4000b6a0: 11 10 00 3f sethi %hi(0x4000fc00), %o0 4000b6a4: 90 12 23 78 or %o0, 0x378, %o0 ! 4000ff78 <_Scheduler_Table> 4000b6a8: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 4000b6ac: 9f c0 80 00 call %g2 4000b6b0: c2 27 bf fc st %g1, [ %fp + -4 ] 4000b6b4: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b6b8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b6bc: 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; } 4000b6c0: 81 c7 e0 08 ret 4000b6c4: 81 e8 00 00 restore =============================================================================== 4000b644 <_Thread_Set_state_locked>: States_Control _Thread_Set_state_locked( Thread_Control *the_thread, States_Control state ) { 4000b644: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 4000b648: 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; 4000b64c: 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); 4000b650: 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 ) ) { 4000b654: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 4000b658: 12 80 00 07 bne 4000b674 <_Thread_Set_state_locked+0x30> <== NOT EXECUTED 4000b65c: f2 22 60 1c st %i1, [ %o1 + 0x1c ] <== NOT EXECUTED ( *scheduler->Operations.block )( 4000b660: 11 10 00 3f sethi %hi(0x4000fc00), %o0 <== NOT EXECUTED 4000b664: 90 12 23 78 or %o0, 0x378, %o0 ! 4000ff78 <_Scheduler_Table> <== NOT EXECUTED 4000b668: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 <== NOT EXECUTED 4000b66c: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000b670: d4 02 60 38 ld [ %o1 + 0x38 ], %o2 <== NOT EXECUTED _Scheduler_Block( the_thread ); } return previous_state; } 4000b674: 81 c7 e0 08 ret <== NOT EXECUTED 4000b678: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000b708 <_Thread_Stack_Free>: #include void _Thread_Stack_Free( Thread_Control *the_thread ) { 4000b708: 9d e3 bf a0 save %sp, -96, %sp #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 ) 4000b70c: c2 0e 20 c8 ldub [ %i0 + 0xc8 ], %g1 4000b710: 80 a0 60 00 cmp %g1, 0 rtems_stack_free_hook stack_free_hook = 4000b714: 03 10 00 3f sethi %hi(0x4000fc00), %g1 if ( !the_thread->Start.core_allocated_stack ) 4000b718: 02 80 00 04 be 4000b728 <_Thread_Stack_Free+0x20> <== NEVER TAKEN 4000b71c: c2 00 62 c4 ld [ %g1 + 0x2c4 ], %g1 ! 4000fec4 * 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 ); 4000b720: 9f c0 40 00 call %g1 4000b724: d0 06 20 d0 ld [ %i0 + 0xd0 ], %o0 } 4000b728: 81 c7 e0 08 ret 4000b72c: 81 e8 00 00 restore =============================================================================== 4000b730 <_Thread_Start>: bool _Thread_Start( Thread_Control *the_thread, const Thread_Entry_information *entry, ISR_lock_Context *lock_context ) { 4000b730: 9d e3 bf 98 save %sp, -104, %sp Per_CPU_Control *cpu_self; _Thread_State_acquire_critical( the_thread, lock_context ); if ( !_States_Is_dormant( the_thread->current_state ) ) { 4000b734: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 4000b738: 80 a0 60 00 cmp %g1, 0 4000b73c: 26 80 00 09 bl,a 4000b760 <_Thread_Start+0x30> <== ALWAYS TAKEN 4000b740: c2 06 40 00 ld [ %i1 ], %g1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000b744: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b748: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b74c: 01 00 00 00 nop <== NOT EXECUTED _Thread_State_release( the_thread, lock_context ); return false; 4000b750: b0 10 20 00 clr %i0 ! 0 <== NOT EXECUTED _User_extensions_Thread_start( the_thread ); _Thread_Dispatch_enable( cpu_self ); return true; } 4000b754: b0 0e 20 01 and %i0, 1, %i0 4000b758: 81 c7 e0 08 ret 4000b75c: 81 e8 00 00 restore the_thread->Start.Entry = *entry; 4000b760: c2 26 20 a0 st %g1, [ %i0 + 0xa0 ] _Thread_Load_environment( the_thread ); 4000b764: 90 10 00 18 mov %i0, %o0 the_thread->Start.Entry = *entry; 4000b768: c2 06 60 04 ld [ %i1 + 4 ], %g1 4000b76c: c2 26 20 a4 st %g1, [ %i0 + 0xa4 ] 4000b770: c2 06 60 08 ld [ %i1 + 8 ], %g1 _Thread_Load_environment( the_thread ); 4000b774: 7f ff fa 9b call 4000a1e0 <_Thread_Load_environment> 4000b778: c2 26 20 a8 st %g1, [ %i0 + 0xa8 ] _Thread_Clear_state_locked( the_thread, STATES_ALL_SET ); 4000b77c: 92 10 3f ff mov -1, %o1 4000b780: 40 00 09 8a call 4000dda8 <_Thread_Clear_state_locked> 4000b784: 90 10 00 18 mov %i0, %o0 disable_level = cpu_self->thread_dispatch_disable_level; 4000b788: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000b78c: 82 00 60 01 inc %g1 <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000b790: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000b794: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED 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 _User_extensions_Iterate( 4000b7a4: 94 10 20 00 clr %o2 ! 0 4000b7a8: 90 10 00 18 mov %i0, %o0 4000b7ac: 13 10 00 2e sethi %hi(0x4000b800), %o1 4000b7b0: 40 00 00 c1 call 4000bab4 <_User_extensions_Iterate> 4000b7b4: 92 12 61 d4 or %o1, 0x1d4, %o1 ! 4000b9d4 <_User_extensions_Thread_start_visitor> uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000b7b8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 if ( disable_level == 1 ) { 4000b7bc: 80 a0 60 01 cmp %g1, 1 4000b7c0: 02 80 00 07 be 4000b7dc <_Thread_Start+0xac> 4000b7c4: 82 00 7f ff add %g1, -1, %g1 return true; 4000b7c8: b0 10 20 01 mov 1, %i0 cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000b7cc: c2 27 60 18 st %g1, [ %i5 + 0x18 ] } 4000b7d0: b0 0e 20 01 and %i0, 1, %i0 4000b7d4: 81 c7 e0 08 ret 4000b7d8: 81 e8 00 00 restore __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b7dc: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000b7e0: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2 4000b7e4: 80 a0 a0 00 cmp %g2, 0 4000b7e8: 12 80 00 07 bne 4000b804 <_Thread_Start+0xd4> 4000b7ec: 92 10 00 01 mov %g1, %o1 cpu_self->thread_dispatch_disable_level = 0; 4000b7f0: c0 27 60 18 clr [ %i5 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b7f4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b7f8: 01 00 00 00 nop return true; 4000b7fc: 10 bf ff d6 b 4000b754 <_Thread_Start+0x24> 4000b800: b0 10 20 01 mov 1, %i0 ! 1 <_TLS_Alignment> _Thread_Do_dispatch( cpu_self, level ); 4000b804: c2 27 bf fc st %g1, [ %fp + -4 ] 4000b808: 7f ff f9 1a call 40009c70 <_Thread_Do_dispatch> 4000b80c: 90 10 00 1d mov %i5, %o0 4000b810: 10 bf ff f9 b 4000b7f4 <_Thread_Start+0xc4> 4000b814: c2 07 bf fc ld [ %fp + -4 ], %g1 =============================================================================== 4000b818 <_Thread_Start_multitasking>: #include #include void _Thread_Start_multitasking( void ) { 4000b818: 9d e3 bf a0 save %sp, -96, %sp heir = cpu_self->heir; 4000b81c: c4 01 a0 24 ld [ %g6 + 0x24 ], %g2 cpu_self->dispatch_necessary = false; 4000b820: c0 29 a0 1c clrb [ %g6 + 0x1c ] _CPU_Context_Set_is_executing( &trash, true ); _CPU_Context_switch( &trash, &heir->Registers ); RTEMS_UNREACHABLE(); } #else _CPU_Context_Restart_self( &heir->Registers ); 4000b824: 90 00 a0 f0 add %g2, 0xf0, %o0 4000b828: 40 00 0f c7 call 4000f744 <_CPU_Context_restore> 4000b82c: c4 21 a0 20 st %g2, [ %g6 + 0x20 ] 4000b830: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 4000b834 <_Thread_Yield>: #include #include void _Thread_Yield( Thread_Control *executing ) { 4000b834: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b838: 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 ) ) { 4000b83c: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 <== NOT EXECUTED 4000b840: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000b844: 12 80 00 09 bne 4000b868 <_Thread_Yield+0x34> <== NOT EXECUTED 4000b848: 11 10 00 3f sethi %hi(0x4000fc00), %o0 <== NOT EXECUTED ( *scheduler->Operations.yield )( 4000b84c: d4 06 20 38 ld [ %i0 + 0x38 ], %o2 <== NOT EXECUTED 4000b850: 90 12 23 78 or %o0, 0x378, %o0 <== NOT EXECUTED 4000b854: c4 02 20 0c ld [ %o0 + 0xc ], %g2 <== NOT EXECUTED 4000b858: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED 4000b85c: 9f c0 80 00 call %g2 <== NOT EXECUTED 4000b860: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4000b864: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b868: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b86c: 01 00 00 00 nop <== NOT EXECUTED _Scheduler_Yield( executing ); } _Thread_State_release( executing, &lock_context ); } 4000b870: 81 c7 e0 08 ret <== NOT EXECUTED 4000b874: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 400149d8 <_Thread_queue_Add_timeout_realtime_timespec>: Thread_queue_Queue *queue, Thread_Control *the_thread, Per_CPU_Control *cpu_self, Thread_queue_Context *queue_context ) { 400149d8: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED struct timespec now; _Timecounter_Getnanotime( &now ); 400149dc: 7f ff f1 43 call 40010ee8 <_Timecounter_Getnanotime> <== NOT EXECUTED 400149e0: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED _Thread_queue_Add_timeout_timespec( 400149e4: d2 06 e0 0c ld [ %i3 + 0xc ], %o1 <== NOT EXECUTED 400149e8: 98 07 bf f8 add %fp, -8, %o4 <== NOT EXECUTED 400149ec: 96 07 bf f0 add %fp, -16, %o3 <== NOT EXECUTED 400149f0: 94 06 a0 40 add %i2, 0x40, %o2 <== NOT EXECUTED 400149f4: 7f ff ff 99 call 40014858 <_Thread_queue_Add_timeout_timespec.isra.5> <== NOT EXECUTED 400149f8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED cpu_self, queue_context, &cpu_self->Watchdog.Header[ PER_CPU_WATCHDOG_REALTIME ], &now ); } 400149fc: 81 c7 e0 08 ret <== NOT EXECUTED 40014a00: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40014944 <_Thread_queue_Add_timeout_ticks>: { 40014944: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED ticks = queue_context->Timeout.ticks; 40014948: c4 06 e0 0c ld [ %i3 + 0xc ], %g2 <== NOT EXECUTED if ( ticks != WATCHDOG_NO_TIMEOUT ) { 4001494c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40014950: 12 80 00 04 bne 40014960 <_Thread_queue_Add_timeout_ticks+0x1c> <== NOT EXECUTED 40014954: 01 00 00 00 nop <== NOT EXECUTED } 40014958: 81 c7 e0 08 ret <== NOT EXECUTED 4001495c: 81 e8 00 00 restore <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40014960: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 40014964: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED the_thread->Timer.Watchdog.routine = _Thread_Timeout; 40014968: 07 10 00 55 sethi %hi(0x40015400), %g3 <== NOT EXECUTED expire = ticks + cpu->Watchdog.ticks; 4001496c: d4 1e a0 30 ldd [ %i2 + 0x30 ], %o2 <== NOT EXECUTED &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ]; 40014970: 90 06 a0 38 add %i2, 0x38, %o0 <== NOT EXECUTED the_thread->Timer.Watchdog.routine = _Thread_Timeout; 40014974: 86 10 e0 20 or %g3, 0x20, %g3 <== NOT EXECUTED the_thread->Timer.header = 40014978: d0 26 60 60 st %o0, [ %i1 + 0x60 ] <== NOT EXECUTED _Watchdog_Insert(header, the_watchdog, expire); 4001497c: b6 82 c0 02 addcc %o3, %g2, %i3 <== NOT EXECUTED the_thread->Timer.Watchdog.routine = _Thread_Timeout; 40014980: c6 26 60 78 st %g3, [ %i1 + 0x78 ] <== NOT EXECUTED 40014984: b4 42 a0 00 addx %o2, 0, %i2 <== NOT EXECUTED 40014988: 92 06 60 68 add %i1, 0x68, %o1 <== NOT EXECUTED 4001498c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 40014990: 40 00 03 e4 call 40015920 <_Watchdog_Insert> <== NOT EXECUTED 40014994: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40014998: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4001499c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400149a0: 01 00 00 00 nop <== NOT EXECUTED 400149a4: 81 c7 e0 08 ret <== NOT EXECUTED 400149a8: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000a2ec <_Thread_queue_Deadlock_fatal>: { 4000a2ec: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED _Internal_error( INTERNAL_ERROR_THREAD_QUEUE_DEADLOCK ); 4000a2f0: 7f ff f3 1e call 40006f68 <_Internal_error> <== NOT EXECUTED 4000a2f4: 90 10 20 1c mov 0x1c, %o0 <== NOT EXECUTED 4000a2f8: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 4001392c <_Thread_queue_Deadlock_status>: the_thread->Wait.return_code = STATUS_DEADLOCK; 4001392c: 03 00 00 0b sethi %hi(0x2c00), %g1 <== NOT EXECUTED 40013930: 82 10 61 0e or %g1, 0x10e, %g1 ! 2d0e <== NOT EXECUTED } 40013934: 81 c3 e0 08 retl <== NOT EXECUTED 40013938: c2 22 20 4c st %g1, [ %o0 + 0x4c ] <== NOT EXECUTED =============================================================================== 4000a2fc <_Thread_queue_Enqueue>: { 4000a2fc: 9d e3 bf 98 save %sp, -104, %sp the_thread->Wait.queue = queue; 4000a300: f0 26 a0 54 st %i0, [ %i2 + 0x54 ] 4000a304: 10 80 00 08 b 4000a324 <_Thread_queue_Enqueue+0x28> 4000a308: 82 10 00 18 mov %i0, %g1 if ( owner == the_thread ) { 4000a30c: 22 80 00 44 be,a 4000a41c <_Thread_queue_Enqueue+0x120> <== NEVER TAKEN 4000a310: c0 26 a0 54 clr [ %i2 + 0x54 ] <== NOT EXECUTED queue = owner->Wait.queue; 4000a314: c2 00 60 54 ld [ %g1 + 0x54 ], %g1 } while ( queue != NULL ); 4000a318: 80 a0 60 00 cmp %g1, 0 4000a31c: 22 80 00 07 be,a 4000a338 <_Thread_queue_Enqueue+0x3c> <== ALWAYS TAKEN 4000a320: c0 26 e0 14 clr [ %i3 + 0x14 ] owner = queue->owner; 4000a324: c2 00 60 04 ld [ %g1 + 4 ], %g1 if ( owner == NULL ) { 4000a328: 80 a0 60 00 cmp %g1, 0 4000a32c: 12 bf ff f8 bne 4000a30c <_Thread_queue_Enqueue+0x10> 4000a330: 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; 4000a334: c0 26 e0 14 clr [ %i3 + 0x14 ] ( *operations->enqueue )( queue, the_thread, queue_context ); 4000a338: 94 10 00 1b mov %i3, %o2 the_thread->Wait.operations = operations; 4000a33c: f2 26 a0 58 st %i1, [ %i2 + 0x58 ] 4000a340: 92 10 00 1a mov %i2, %o1 4000a344: c2 06 60 04 ld [ %i1 + 4 ], %g1 4000a348: 9f c0 40 00 call %g1 4000a34c: 90 10 00 18 mov %i0, %o0 the_thread->Wait.flags = flags; 4000a350: 84 10 24 01 mov 0x401, %g2 <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 4000a354: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED the_thread->Wait.return_code = STATUS_SUCCESSFUL; 4000a358: c0 26 a0 4c clr [ %i2 + 0x4c ] <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000a35c: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000a360: c4 26 a0 50 st %g2, [ %i2 + 0x50 ] <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000a364: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000a368: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000a36c: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000a370: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000a374: 01 00 00 00 nop ( *queue_context->enqueue_callout )( 4000a378: c2 06 e0 08 ld [ %i3 + 8 ], %g1 4000a37c: 96 10 00 1b mov %i3, %o3 4000a380: 94 10 00 06 mov %g6, %o2 4000a384: 92 10 00 1a mov %i2, %o1 4000a388: 9f c0 40 00 call %g1 4000a38c: 90 10 00 18 mov %i0, %o0 _Thread_Set_state( the_thread, queue_context->thread_state ); 4000a390: d2 06 e0 04 ld [ %i3 + 4 ], %o1 4000a394: 40 00 04 ba call 4000b67c <_Thread_Set_state> 4000a398: 90 10 00 1a mov %i2, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000a39c: 91 d0 20 09 ta 9 <== NOT EXECUTED bool success = ( the_thread->Wait.flags == expected_flags ); 4000a3a0: c4 06 a0 50 ld [ %i2 + 0x50 ], %g2 if ( success ) { 4000a3a4: 80 a0 a4 01 cmp %g2, 0x401 4000a3a8: 02 80 00 28 be 4000a448 <_Thread_queue_Enqueue+0x14c> <== ALWAYS TAKEN 4000a3ac: 86 10 24 02 mov 0x402, %g3 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000a3b0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000a3b4: 01 00 00 00 nop <== NOT EXECUTED if ( !success ) { 4000a3b8: 80 a0 a4 01 cmp %g2, 0x401 <== NOT EXECUTED 4000a3bc: 12 80 00 07 bne 4000a3d8 <_Thread_queue_Enqueue+0xdc> <== NOT EXECUTED 4000a3c0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Priority_update( queue_context ); 4000a3c4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 4000a3c8: 40 00 0e 57 call 4000dd24 <_Thread_Priority_update> 4000a3cc: b0 10 00 1d mov %i5, %i0 _Thread_Dispatch_direct( cpu_self ); 4000a3d0: 7f ff fe 70 call 40009d90 <_Thread_Dispatch_direct> 4000a3d4: 81 e8 00 00 restore __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000a3d8: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000a3dc: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED 4000a3e0: d0 06 a0 60 ld [ %i2 + 0x60 ], %o0 <== NOT EXECUTED 4000a3e4: 40 00 06 12 call 4000bc2c <_Watchdog_Remove> <== NOT EXECUTED 4000a3e8: 92 06 a0 68 add %i2, 0x68, %o1 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000a3ec: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000a3f0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000a3f4: 01 00 00 00 nop <== NOT EXECUTED _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000a3f8: 13 0c 00 57 sethi %hi(0x30015c00), %o1 <== NOT EXECUTED 4000a3fc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 4000a400: 40 00 0e 76 call 4000ddd8 <_Thread_Clear_state> <== NOT EXECUTED 4000a404: 92 12 63 ff or %o1, 0x3ff, %o1 <== NOT EXECUTED _Thread_Priority_update( queue_context ); 4000a408: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 4000a40c: 40 00 0e 46 call 4000dd24 <_Thread_Priority_update> <== NOT EXECUTED 4000a410: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED _Thread_Dispatch_direct( cpu_self ); 4000a414: 7f ff fe 5f call 40009d90 <_Thread_Dispatch_direct> <== NOT EXECUTED 4000a418: 81 e8 00 00 restore <== NOT EXECUTED the_thread->Wait.operations = &_Thread_queue_Operations_default; 4000a41c: 03 10 00 42 sethi %hi(0x40010800), %g1 <== NOT EXECUTED 4000a420: 82 10 60 60 or %g1, 0x60, %g1 ! 40010860 <_Thread_queue_Operations_default> <== NOT EXECUTED 4000a424: c2 26 a0 58 st %g1, [ %i2 + 0x58 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000a428: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000a42c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000a430: 01 00 00 00 nop <== NOT EXECUTED ( *queue_context->deadlock_callout )( the_thread ); 4000a434: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1 <== NOT EXECUTED 4000a438: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000a43c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED } 4000a440: 81 c7 e0 08 ret <== NOT EXECUTED 4000a444: 81 e8 00 00 restore <== NOT EXECUTED the_thread->Wait.flags = desired_flags; 4000a448: c6 26 a0 50 st %g3, [ %i2 + 0x50 ] <== NOT EXECUTED 4000a44c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000a450: 01 00 00 00 nop if ( !success ) { 4000a454: 80 a0 a4 01 cmp %g2, 0x401 4000a458: 22 bf ff dc be,a 4000a3c8 <_Thread_queue_Enqueue+0xcc> <== ALWAYS TAKEN 4000a45c: 90 10 00 1b mov %i3, %o0 4000a460: 30 bf ff de b,a 4000a3d8 <_Thread_queue_Enqueue+0xdc> <== NOT EXECUTED =============================================================================== 4000a4d4 <_Thread_queue_Extract>: &queue_context->Lock_context.Lock_context ); } void _Thread_queue_Extract( Thread_Control *the_thread ) { 4000a4d4: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED 4000a4d8: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000a4dc: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 4000a4e0: 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; 4000a4e4: d0 06 20 54 ld [ %i0 + 0x54 ], %o0 if ( queue != NULL ) { 4000a4e8: 80 a2 20 00 cmp %o0, 0 4000a4ec: 02 80 00 1c be 4000a55c <_Thread_queue_Extract+0x88> <== ALWAYS TAKEN 4000a4f0: 92 10 00 18 mov %i0, %o1 ( *operations->extract )( queue, the_thread, queue_context ); 4000a4f4: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 <== NOT EXECUTED 4000a4f8: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED 4000a4fc: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000a500: 94 07 bf dc add %fp, -36, %o2 <== NOT EXECUTED if ( success ) { 4000a504: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 <== NOT EXECUTED 4000a508: 80 a0 64 01 cmp %g1, 0x401 <== NOT EXECUTED the_thread->Wait.queue = NULL; 4000a50c: c0 26 20 54 clr [ %i0 + 0x54 ] <== NOT EXECUTED the_thread->Wait.flags = desired_flags; 4000a510: 82 10 24 04 mov 0x404, %g1 <== NOT EXECUTED if ( success ) { 4000a514: 02 80 00 0a be 4000a53c <_Thread_queue_Extract+0x68> <== NOT EXECUTED 4000a518: c2 26 20 50 st %g1, [ %i0 + 0x50 ] <== NOT EXECUTED the_thread->Wait.operations = &_Thread_queue_Operations_default; 4000a51c: 03 10 00 42 sethi %hi(0x40010800), %g1 <== NOT EXECUTED 4000a520: 82 10 60 60 or %g1, 0x60, %g1 ! 40010860 <_Thread_queue_Operations_default> <== NOT EXECUTED 4000a524: c2 26 20 58 st %g1, [ %i0 + 0x58 ] <== NOT EXECUTED 4000a528: 92 07 bf dc add %fp, -36, %o1 <== NOT EXECUTED 4000a52c: 7f ff ff 44 call 4000a23c <_Thread_queue_Unblock_critical.part.33> <== NOT EXECUTED 4000a530: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED &queue_context.Lock_context.Lock_context ); } else { _Thread_Wait_release( the_thread, &queue_context ); } } 4000a534: 81 c7 e0 08 ret <== NOT EXECUTED 4000a538: 81 e8 00 00 restore <== NOT EXECUTED 4000a53c: 03 10 00 42 sethi %hi(0x40010800), %g1 <== NOT EXECUTED 4000a540: 82 10 60 60 or %g1, 0x60, %g1 ! 40010860 <_Thread_queue_Operations_default> <== NOT EXECUTED 4000a544: c2 26 20 58 st %g1, [ %i0 + 0x58 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000a548: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000a54c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000a550: 01 00 00 00 nop <== NOT EXECUTED 4000a554: 81 c7 e0 08 ret <== NOT EXECUTED 4000a558: 81 e8 00 00 restore <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000a55c: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000a560: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000a564: 01 00 00 00 nop 4000a568: 81 c7 e0 08 ret 4000a56c: 81 e8 00 00 restore =============================================================================== 40013b24 <_Thread_queue_Extract_critical>: Thread_queue_Queue *queue, const Thread_queue_Operations *operations, Thread_Control *the_thread, Thread_queue_Context *queue_context ) { 40013b24: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED ( *operations->extract )( queue, the_thread, queue_context ); 40013b28: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED 40013b2c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 40013b30: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 40013b34: 9f c0 40 00 call %g1 <== NOT EXECUTED 40013b38: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( success ) { 40013b3c: c2 06 a0 50 ld [ %i2 + 0x50 ], %g1 <== NOT EXECUTED 40013b40: 80 a0 64 01 cmp %g1, 0x401 <== NOT EXECUTED the_thread->Wait.queue = NULL; 40013b44: c0 26 a0 54 clr [ %i2 + 0x54 ] <== NOT EXECUTED the_thread->Wait.flags = desired_flags; 40013b48: 82 10 24 04 mov 0x404, %g1 <== NOT EXECUTED if ( success ) { 40013b4c: 02 80 00 08 be 40013b6c <_Thread_queue_Extract_critical+0x48> <== NOT EXECUTED 40013b50: c2 26 a0 50 st %g1, [ %i2 + 0x50 ] <== NOT EXECUTED the_thread->Wait.operations = &_Thread_queue_Operations_default; 40013b54: 03 10 00 bc sethi %hi(0x4002f000), %g1 <== NOT EXECUTED 40013b58: 82 10 60 08 or %g1, 8, %g1 ! 4002f008 <_Thread_queue_Operations_default> <== NOT EXECUTED 40013b5c: c2 26 a0 58 st %g1, [ %i2 + 0x58 ] <== NOT EXECUTED 40013b60: b2 10 00 1b mov %i3, %i1 <== NOT EXECUTED 40013b64: 7f ff ff 46 call 4001387c <_Thread_queue_Unblock_critical.part.33> <== NOT EXECUTED 40013b68: 91 e8 00 1a restore %g0, %i2, %o0 <== NOT EXECUTED 40013b6c: 03 10 00 bc sethi %hi(0x4002f000), %g1 <== NOT EXECUTED 40013b70: 82 10 60 08 or %g1, 8, %g1 ! 4002f008 <_Thread_queue_Operations_default> <== NOT EXECUTED 40013b74: c2 26 a0 58 st %g1, [ %i2 + 0x58 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40013b78: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40013b7c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40013b80: 01 00 00 00 nop <== NOT EXECUTED unblock, queue, the_thread, &queue_context->Lock_context.Lock_context ); } 40013b84: 81 c7 e0 08 ret <== NOT EXECUTED 40013b88: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000a464 <_Thread_queue_Extract_locked>: { 4000a464: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED ( *operations->extract )( queue, the_thread, queue_context ); 4000a468: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED 4000a46c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 4000a470: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4000a474: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000a478: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( success ) { 4000a47c: c2 06 a0 50 ld [ %i2 + 0x50 ], %g1 <== NOT EXECUTED 4000a480: 80 a0 64 01 cmp %g1, 0x401 <== NOT EXECUTED 4000a484: 02 80 00 0b be 4000a4b0 <_Thread_queue_Extract_locked+0x4c> <== NOT EXECUTED 4000a488: 82 10 24 04 mov 0x404, %g1 <== NOT EXECUTED unblock = true; 4000a48c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED the_thread->Wait.flags = flags; 4000a490: c2 26 a0 50 st %g1, [ %i2 + 0x50 ] <== NOT EXECUTED return _Thread_queue_Make_ready_again( the_thread ); 4000a494: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED the_thread->Wait.queue = NULL; 4000a498: c0 26 a0 54 clr [ %i2 + 0x54 ] <== NOT EXECUTED the_thread->Wait.operations = &_Thread_queue_Operations_default; 4000a49c: 03 10 00 42 sethi %hi(0x40010800), %g1 <== NOT EXECUTED 4000a4a0: 82 10 60 60 or %g1, 0x60, %g1 ! 40010860 <_Thread_queue_Operations_default> <== NOT EXECUTED 4000a4a4: c2 26 a0 58 st %g1, [ %i2 + 0x58 ] <== NOT EXECUTED } 4000a4a8: 81 c7 e0 08 ret <== NOT EXECUTED 4000a4ac: 81 e8 00 00 restore <== NOT EXECUTED unblock = false; 4000a4b0: b0 10 20 00 clr %i0 <== NOT EXECUTED the_thread->Wait.flags = desired_flags; 4000a4b4: c2 26 a0 50 st %g1, [ %i2 + 0x50 ] <== NOT EXECUTED return _Thread_queue_Make_ready_again( the_thread ); 4000a4b8: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED the_thread->Wait.queue = NULL; 4000a4bc: c0 26 a0 54 clr [ %i2 + 0x54 ] <== NOT EXECUTED the_thread->Wait.operations = &_Thread_queue_Operations_default; 4000a4c0: 03 10 00 42 sethi %hi(0x40010800), %g1 <== NOT EXECUTED 4000a4c4: 82 10 60 60 or %g1, 0x60, %g1 ! 40010860 <_Thread_queue_Operations_default> <== NOT EXECUTED 4000a4c8: c2 26 a0 58 st %g1, [ %i2 + 0x58 ] <== NOT EXECUTED } 4000a4cc: 81 c7 e0 08 ret <== NOT EXECUTED 4000a4d0: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000de3c <_Thread_queue_Flush_critical>: Thread_queue_Queue *queue, const Thread_queue_Operations *operations, Thread_queue_Flush_filter filter, Thread_queue_Context *queue_context ) { 4000de3c: 9d e3 bf 88 save %sp, -120, %sp head->next = tail; 4000de40: a0 07 bf f8 add %fp, -8, %l0 tail->previous = head; 4000de44: 82 07 bf f4 add %fp, -12, %g1 head->previous = NULL; 4000de48: c0 27 bf f8 clr [ %fp + -8 ] 4000de4c: b8 10 00 18 mov %i0, %i4 head->next = tail; 4000de50: e0 27 bf f4 st %l0, [ %fp + -12 ] tail->previous = head; 4000de54: c2 27 bf fc st %g1, [ %fp + -4 ] while ( true ) { Thread_queue_Heads *heads; Thread_Control *first; bool do_unblock; heads = queue->heads; 4000de58: d0 06 00 00 ld [ %i0 ], %o0 owner = queue->owner; 4000de5c: e2 06 20 04 ld [ %i0 + 4 ], %l1 if ( heads == NULL ) { 4000de60: 80 a2 20 00 cmp %o0, 0 4000de64: 12 80 00 16 bne 4000debc <_Thread_queue_Flush_critical+0x80> <== NEVER TAKEN 4000de68: b0 10 20 00 clr %i0 4000de6c: 30 80 00 59 b,a 4000dfd0 <_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( 4000de70: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED 4000de74: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 4000de78: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000de7c: 7f ff f1 7a call 4000a464 <_Thread_queue_Extract_locked> <== NOT EXECUTED 4000de80: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED queue, operations, first, queue_context ); if ( do_unblock ) { 4000de84: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000de88: 22 80 00 0a be,a 4000deb0 <_Thread_queue_Flush_critical+0x74> <== NOT EXECUTED 4000de8c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED 4000de90: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED old_last = tail->previous; 4000de94: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED the_node->next = tail; 4000de98: e0 20 60 08 st %l0, [ %g1 + 8 ] <== NOT EXECUTED Scheduler_Node *scheduler_node; scheduler_node = _Thread_Scheduler_get_home_node( first ); _Chain_Append_unprotected( 4000de9c: 86 00 60 08 add %g1, 8, %g3 <== NOT EXECUTED tail->previous = the_node; 4000dea0: c6 27 bf fc st %g3, [ %fp + -4 ] <== NOT EXECUTED old_last->next = the_node; 4000dea4: c6 20 80 00 st %g3, [ %g2 ] <== NOT EXECUTED the_node->previous = old_last; 4000dea8: c4 20 60 0c st %g2, [ %g1 + 0xc ] <== NOT EXECUTED heads = queue->heads; 4000deac: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED if ( heads == NULL ) { 4000deb0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000deb4: 02 80 00 0b be 4000dee0 <_Thread_queue_Flush_critical+0xa4> <== NOT EXECUTED 4000deb8: b0 06 20 01 inc %i0 <== NOT EXECUTED first = ( *operations->first )( heads ); 4000debc: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 <== NOT EXECUTED 4000dec0: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000dec4: 01 00 00 00 nop <== NOT EXECUTED first = ( *filter )( first, queue, queue_context ); 4000dec8: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 4000decc: 9f c6 80 00 call %i2 <== NOT EXECUTED 4000ded0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED if ( first == NULL ) { 4000ded4: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED 4000ded8: 32 bf ff e6 bne,a 4000de70 <_Thread_queue_Flush_critical+0x34> <== NOT EXECUTED 4000dedc: c0 26 e0 14 clr [ %i3 + 0x14 ] <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 4000dee0: c4 07 bf f4 ld [ %fp + -12 ], %g2 <== NOT EXECUTED } node = _Chain_First( &unblock ); tail = _Chain_Tail( &unblock ); if ( node != tail ) { 4000dee4: 80 a0 80 10 cmp %g2, %l0 <== NOT EXECUTED 4000dee8: 02 80 00 3a be 4000dfd0 <_Thread_queue_Flush_critical+0x194> <== NOT EXECUTED 4000deec: 01 00 00 00 nop <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 4000def0: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000def4: 82 00 60 01 inc %g1 <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000def8: b4 10 00 06 mov %g6, %i2 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000defc: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000df00: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000df04: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000df08: 01 00 00 00 nop <== NOT EXECUTED 4000df0c: 37 0c 00 57 sethi %hi(0x30015c00), %i3 <== NOT EXECUTED 4000df10: b6 16 e3 ff or %i3, 0x3ff, %i3 ! 30015fff <== NOT EXECUTED 4000df14: f8 00 80 00 ld [ %g2 ], %i4 <== NOT EXECUTED 4000df18: fa 00 bf f8 ld [ %g2 + -8 ], %i5 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000df1c: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000df20: c2 27 bf ec st %g1, [ %fp + -20 ] <== NOT EXECUTED 4000df24: d0 07 60 60 ld [ %i5 + 0x60 ], %o0 <== NOT EXECUTED 4000df28: 7f ff f7 41 call 4000bc2c <_Watchdog_Remove> <== NOT EXECUTED 4000df2c: 92 07 60 68 add %i5, 0x68, %o1 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000df30: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000df34: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000df38: 01 00 00 00 nop <== NOT EXECUTED 4000df3c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 4000df40: 7f ff ff a6 call 4000ddd8 <_Thread_Clear_state> <== NOT EXECUTED 4000df44: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 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 ); 4000df48: 80 a7 00 10 cmp %i4, %l0 <== NOT EXECUTED 4000df4c: 12 bf ff f2 bne 4000df14 <_Thread_queue_Flush_critical+0xd8> <== NOT EXECUTED 4000df50: 84 10 00 1c mov %i4, %g2 <== NOT EXECUTED if ( owner != NULL ) { 4000df54: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED 4000df58: 02 80 00 0d be 4000df8c <_Thread_queue_Flush_critical+0x150> <== NOT EXECUTED 4000df5c: 01 00 00 00 nop <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000df60: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000df64: c2 27 bf ec st %g1, [ %fp + -20 ] <== NOT EXECUTED ( *scheduler->Operations.update_priority )( 4000df68: 11 10 00 3f sethi %hi(0x4000fc00), %o0 <== NOT EXECUTED 4000df6c: d4 04 60 38 ld [ %l1 + 0x38 ], %o2 <== NOT EXECUTED 4000df70: 90 12 23 78 or %o0, 0x378, %o0 <== NOT EXECUTED 4000df74: c4 02 20 18 ld [ %o0 + 0x18 ], %g2 <== NOT EXECUTED 4000df78: 9f c0 80 00 call %g2 <== NOT EXECUTED 4000df7c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000df80: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000df84: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000df88: 01 00 00 00 nop <== NOT EXECUTED uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000df8c: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1 <== NOT EXECUTED if ( disable_level == 1 ) { 4000df90: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000df94: 02 80 00 05 be 4000dfa8 <_Thread_queue_Flush_critical+0x16c> <== NOT EXECUTED 4000df98: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000df9c: c2 26 a0 18 st %g1, [ %i2 + 0x18 ] <== NOT EXECUTED 4000dfa0: 81 c7 e0 08 ret <== NOT EXECUTED 4000dfa4: 81 e8 00 00 restore <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000dfa8: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000dfac: c4 0e a0 1c ldub [ %i2 + 0x1c ], %g2 <== NOT EXECUTED 4000dfb0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000dfb4: 12 80 00 0c bne 4000dfe4 <_Thread_queue_Flush_critical+0x1a8> <== NOT EXECUTED 4000dfb8: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = 0; 4000dfbc: c0 26 a0 18 clr [ %i2 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000dfc0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000dfc4: 01 00 00 00 nop <== NOT EXECUTED 4000dfc8: 81 c7 e0 08 ret <== NOT EXECUTED 4000dfcc: 81 e8 00 00 restore <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000dfd0: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000dfd4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000dfd8: 01 00 00 00 nop } else { _Thread_queue_Queue_release( queue, &queue_context->Lock_context.Lock_context ); } return flushed; } 4000dfdc: 81 c7 e0 08 ret 4000dfe0: 81 e8 00 00 restore _Thread_Do_dispatch( cpu_self, level ); 4000dfe4: c2 27 bf ec st %g1, [ %fp + -20 ] <== NOT EXECUTED 4000dfe8: 7f ff ef 22 call 40009c70 <_Thread_Do_dispatch> <== NOT EXECUTED 4000dfec: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 4000dff0: 10 bf ff f4 b 4000dfc0 <_Thread_queue_Flush_critical+0x184> <== NOT EXECUTED 4000dff4: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED =============================================================================== 40013d50 <_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; 40013d50: 03 00 00 05 sethi %hi(0x1400), %g1 <== NOT EXECUTED 40013d54: 82 10 62 07 or %g1, 0x207, %g1 ! 1607 <== NOT EXECUTED (void) queue; (void) queue_context; return the_thread; } 40013d58: 81 c3 e0 08 retl <== NOT EXECUTED 40013d5c: c2 22 20 4c st %g1, [ %o0 + 0x4c ] <== NOT EXECUTED =============================================================================== 400137f8 <_Thread_queue_Object_initialize>: queue->name = name; 400137f8: 03 10 00 bb sethi %hi(0x4002ec00), %g1 <== NOT EXECUTED queue->heads = NULL; 400137fc: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED queue->name = name; 40013800: 82 10 63 c8 or %g1, 0x3c8, %g1 <== NOT EXECUTED queue->owner = NULL; 40013804: 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 ); } 40013808: 81 c3 e0 08 retl <== NOT EXECUTED 4001380c: c2 22 20 08 st %g1, [ %o0 + 8 ] <== NOT EXECUTED =============================================================================== 4002efc8 <_Thread_queue_Object_name>: 4002efc8: 00 00 00 00 .... =============================================================================== 4002eff4 <_Thread_queue_Operations_FIFO>: 4002eff4: 40 01 3f 1c 40 01 3f fc 40 01 41 e0 40 01 41 48 @.?.@.?.@.A.@.AH 4002f004: 40 01 40 18 @.@. =============================================================================== 40010860 <_Thread_queue_Operations_default>: 40010860: 40 00 a6 98 00 00 00 00 40 00 a6 a0 00 00 00 00 @.......@....... ... 40010878: 0a 0a 2a 2a 2a 20 42 45 47 49 4e 20 4f 46 20 54 ..*** BEGIN OF T 40010888: 45 53 54 20 25 73 20 2a 2a 2a 0a 2a 2a 2a 20 54 EST %s ***.*** T 40010898: 45 53 54 20 56 45 52 53 49 4f 4e 3a 20 25 73 0a EST VERSION: %s. 400108a8: 2a 2a 2a 20 54 45 53 54 20 53 54 41 54 45 3a 20 *** TEST STATE: 400108b8: 25 73 0a 2a 2a 2a 20 54 45 53 54 20 42 55 49 4c %s.*** TEST BUIL 400108c8: 44 3a 20 52 54 45 4d 53 5f 4e 45 54 57 4f 52 4b D: RTEMS_NETWORK 400108d8: 49 4e 47 20 52 54 45 4d 53 5f 50 4f 53 49 58 5f ING RTEMS_POSIX_ 400108e8: 41 50 49 0a 2a 2a 2a 20 54 45 53 54 20 54 4f 4f API.*** TEST TOO 400108f8: 4c 53 3a 20 37 2e 33 2e 30 20 32 30 31 38 30 31 LS: 7.3.0 201801 40010908: 32 35 20 28 52 54 45 4d 53 20 35 2c 20 52 53 42 25 (RTEMS 5, RSB 40010918: 20 34 62 33 65 30 66 38 65 33 64 36 39 39 38 62 4b3e0f8e3d6998b 40010928: 38 34 61 32 35 30 33 64 64 32 65 31 31 35 37 38 84a2503dd2e11578 40010938: 39 38 39 62 31 36 37 32 62 2c 20 4e 65 77 6c 69 989b1672b, Newli 40010948: 62 20 33 2e 30 2e 30 29 0a 00 00 00 00 00 00 00 b 3.0.0)........ 40010958: 0a 2a 2a 2a 20 45 4e 44 20 4f 46 20 54 45 53 54 .*** END OF TEST 40010968: 20 25 73 20 2a 2a 2a 0a 0a 00 00 00 00 00 00 00 %s ***......... 40010978: 45 58 50 45 43 54 45 44 2d 50 41 53 53 00 00 00 EXPECTED-PASS... 40010988: 45 58 50 45 43 54 45 44 2d 46 41 49 4c 00 00 00 EXPECTED-FAIL... 40010998: 55 53 45 52 5f 49 4e 50 55 54 00 00 00 00 00 00 USER_INPUT...... 400109a8: 49 4e 44 45 54 45 52 4d 49 4e 41 54 45 00 00 00 INDETERMINATE... 400109b8: 42 45 4e 43 48 4d 41 52 4b 00 00 00 BENCHMARK... =============================================================================== 4001084c <_Thread_queue_Operations_priority>: 4001084c: 40 00 aa 64 40 00 a7 58 40 00 a8 54 40 00 a7 f8 @..d@..X@..T@... 4001085c: 40 00 a7 90 @... =============================================================================== 40010838 <_Thread_queue_Operations_priority_inherit>: 40010838: 40 00 ab a4 40 00 a7 74 40 00 a8 9c 40 00 ac b0 @...@..t@...@... 40010848: 40 00 a7 90 @... =============================================================================== 40013810 <_Thread_queue_Queue_get_name_and_id>: const Thread_queue_Queue *queue, char *buffer, size_t buffer_size, Objects_Id *id ) { 40013810: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED const char *name; name = queue->name; 40013814: c4 06 20 08 ld [ %i0 + 8 ], %g2 <== NOT EXECUTED if ( name == _Thread_queue_Object_name ) { 40013818: 03 10 00 bb sethi %hi(0x4002ec00), %g1 <== NOT EXECUTED 4001381c: 82 10 63 c8 or %g1, 0x3c8, %g1 ! 4002efc8 <_Thread_queue_Object_name> <== NOT EXECUTED 40013820: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 40013824: 02 80 00 0c be 40013854 <_Thread_queue_Queue_get_name_and_id+0x44> <== NOT EXECUTED 40013828: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED false, buffer, buffer_size ); } else { if ( name == NULL ) { 4001382c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40013830: 02 80 00 05 be 40013844 <_Thread_queue_Queue_get_name_and_id+0x34> <== NOT EXECUTED 40013834: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED name = _Thread_queue_Object_name; } *id = 0; return strlcpy( buffer, name, buffer_size ); 40013838: b2 10 00 02 mov %g2, %i1 <== NOT EXECUTED 4001383c: 40 00 30 78 call 4001fa1c <== NOT EXECUTED 40013840: 91 e8 00 0a restore %g0, %o2, %o0 <== NOT EXECUTED name = _Thread_queue_Object_name; 40013844: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED return strlcpy( buffer, name, buffer_size ); 40013848: b0 10 00 0a mov %o2, %i0 <== NOT EXECUTED 4001384c: 40 00 30 74 call 4001fa1c <== NOT EXECUTED 40013850: 93 e8 00 02 restore %g0, %g2, %o1 <== NOT EXECUTED *id = queue_object->Object.id; 40013854: c4 06 3f f8 ld [ %i0 + -8 ], %g2 <== NOT EXECUTED 40013858: c4 26 c0 00 st %g2, [ %i3 ] <== NOT EXECUTED return _Objects_Name_to_string( 4001385c: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 40013860: c2 06 3f fc ld [ %i0 + -4 ], %g1 <== NOT EXECUTED 40013864: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED 40013868: 92 10 20 00 clr %o1 <== NOT EXECUTED 4001386c: 40 00 1a 8f call 4001a2a8 <_Objects_Name_to_string> <== NOT EXECUTED 40013870: 90 07 bf fc add %fp, -4, %o0 <== NOT EXECUTED } } 40013874: 81 c7 e0 08 ret <== NOT EXECUTED 40013878: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED =============================================================================== 4000a570 <_Thread_queue_Surrender>: Thread_queue_Heads *heads, Thread_Control *previous_owner, Thread_queue_Context *queue_context, const Thread_queue_Operations *operations ) { 4000a570: 9d e3 bf 98 save %sp, -104, %sp 4000a574: c0 26 e0 14 clr [ %i3 + 0x14 ] Per_CPU_Control *cpu_self; _Assert( heads != NULL ); _Thread_queue_Context_clear_priority_updates( queue_context ); new_owner = ( *operations->surrender )( 4000a578: 96 10 00 1b mov %i3, %o3 4000a57c: c2 07 20 0c ld [ %i4 + 0xc ], %g1 4000a580: 94 10 00 1a mov %i2, %o2 4000a584: 92 10 00 19 mov %i1, %o1 4000a588: 9f c0 40 00 call %g1 4000a58c: 90 10 00 18 mov %i0, %o0 queue, heads, previous_owner, queue_context ); queue->owner = new_owner; 4000a590: d0 26 20 04 st %o0, [ %i0 + 4 ] if ( success ) { 4000a594: c2 02 20 50 ld [ %o0 + 0x50 ], %g1 4000a598: 80 a0 64 01 cmp %g1, 0x401 4000a59c: 02 80 00 1c be 4000a60c <_Thread_queue_Surrender+0x9c> <== NEVER TAKEN 4000a5a0: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED the_thread->Wait.flags = flags; 4000a5a4: 82 10 24 04 mov 0x404, %g1 <== NOT EXECUTED 4000a5a8: c2 22 20 50 st %g1, [ %o0 + 0x50 ] <== NOT EXECUTED unblock = true; 4000a5ac: b4 10 20 01 mov 1, %i2 <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 4000a5b0: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED the_thread->Wait.queue = NULL; 4000a5b4: c0 27 60 54 clr [ %i5 + 0x54 ] <== NOT EXECUTED the_thread->Wait.operations = &_Thread_queue_Operations_default; 4000a5b8: 05 10 00 42 sethi %hi(0x40010800), %g2 <== NOT EXECUTED 4000a5bc: 84 10 a0 60 or %g2, 0x60, %g2 ! 40010860 <_Thread_queue_Operations_default> <== NOT EXECUTED 4000a5c0: c4 27 60 58 st %g2, [ %i5 + 0x58 ] <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000a5c4: 82 00 60 01 inc %g1 <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000a5c8: b8 10 00 06 mov %g6, %i4 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000a5cc: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000a5d0: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000a5d4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000a5d8: 01 00 00 00 nop _Thread_queue_Queue_release( queue, &queue_context->Lock_context.Lock_context ); _Thread_Priority_update( queue_context ); 4000a5dc: 40 00 0d d2 call 4000dd24 <_Thread_Priority_update> 4000a5e0: 90 10 00 1b mov %i3, %o0 if ( unblock ) { 4000a5e4: 80 8e a0 ff btst 0xff, %i2 4000a5e8: 12 80 00 0d bne 4000a61c <_Thread_queue_Surrender+0xac> <== ALWAYS TAKEN 4000a5ec: 01 00 00 00 nop uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000a5f0: c2 07 20 18 ld [ %i4 + 0x18 ], %g1 <== NOT EXECUTED if ( disable_level == 1 ) { 4000a5f4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000a5f8: 02 80 00 19 be 4000a65c <_Thread_queue_Surrender+0xec> <== NOT EXECUTED 4000a5fc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000a600: c2 27 20 18 st %g1, [ %i4 + 0x18 ] <== NOT EXECUTED _Thread_Remove_timer_and_unblock( new_owner, queue ); } _Thread_Dispatch_enable( cpu_self ); } 4000a604: 81 c7 e0 08 ret <== NOT EXECUTED 4000a608: 81 e8 00 00 restore <== NOT EXECUTED the_thread->Wait.flags = desired_flags; 4000a60c: 82 10 24 04 mov 0x404, %g1 <== NOT EXECUTED unblock = false; 4000a610: b4 10 20 00 clr %i2 <== NOT EXECUTED 4000a614: 10 bf ff e7 b 4000a5b0 <_Thread_queue_Surrender+0x40> <== NOT EXECUTED 4000a618: c2 22 20 50 st %g1, [ %o0 + 0x50 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000a61c: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000a620: c2 27 bf fc st %g1, [ %fp + -4 ] 4000a624: d0 07 60 60 ld [ %i5 + 0x60 ], %o0 4000a628: 40 00 05 81 call 4000bc2c <_Watchdog_Remove> 4000a62c: 92 07 60 68 add %i5, 0x68, %o1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000a630: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000a634: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000a638: 01 00 00 00 nop _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000a63c: 13 0c 00 57 sethi %hi(0x30015c00), %o1 4000a640: 90 10 00 1d mov %i5, %o0 4000a644: 40 00 0d e5 call 4000ddd8 <_Thread_Clear_state> 4000a648: 92 12 63 ff or %o1, 0x3ff, %o1 uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000a64c: c2 07 20 18 ld [ %i4 + 0x18 ], %g1 if ( disable_level == 1 ) { 4000a650: 80 a0 60 01 cmp %g1, 1 4000a654: 12 bf ff eb bne 4000a600 <_Thread_queue_Surrender+0x90> <== NEVER TAKEN 4000a658: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000a65c: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000a660: c4 0f 20 1c ldub [ %i4 + 0x1c ], %g2 4000a664: 80 a0 a0 00 cmp %g2, 0 4000a668: 32 80 00 07 bne,a 4000a684 <_Thread_queue_Surrender+0x114> <== ALWAYS TAKEN 4000a66c: 92 10 00 01 mov %g1, %o1 cpu_self->thread_dispatch_disable_level = 0; 4000a670: c0 27 20 18 clr [ %i4 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000a674: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000a678: 01 00 00 00 nop 4000a67c: 81 c7 e0 08 ret 4000a680: 81 e8 00 00 restore _Thread_Do_dispatch( cpu_self, level ); 4000a684: c2 27 bf fc st %g1, [ %fp + -4 ] 4000a688: 7f ff fd 7a call 40009c70 <_Thread_Do_dispatch> 4000a68c: 90 10 00 1c mov %i4, %o0 4000a690: 10 bf ff f9 b 4000a674 <_Thread_queue_Surrender+0x104> 4000a694: c2 07 bf fc ld [ %fp + -4 ], %g1 =============================================================================== 40007ff0 <_Timecounter_Bintime>: { 40007ff0: 9d e3 bf a0 save %sp, -96, %sp 40007ff4: 33 10 00 43 sethi %hi(0x40010c00), %i1 40007ff8: b2 16 63 10 or %i1, 0x310, %i1 ! 40010f10 th = timehands; 40007ffc: fa 06 40 00 ld [ %i1 ], %i5 40008000: f4 07 60 70 ld [ %i5 + 0x70 ], %i2 *bt = th->th_bintime; 40008004: c4 1f 60 30 ldd [ %i5 + 0x30 ], %g2 40008008: c4 3e 00 00 std %g2, [ %i0 ] 4000800c: c4 1f 60 38 ldd [ %i5 + 0x38 ], %g2 40008010: f6 07 40 00 ld [ %i5 ], %i3 40008014: c4 3e 20 08 std %g2, [ %i0 + 8 ] return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40008018: 90 10 00 1b mov %i3, %o0 4000801c: c2 06 c0 00 ld [ %i3 ], %g1 bintime_addx(bt, th->th_scale * tc_delta(th)); 40008020: f8 07 60 10 ld [ %i5 + 0x10 ], %i4 return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40008024: 9f c0 40 00 call %g1 40008028: e0 07 60 14 ld [ %i5 + 0x14 ], %l0 4000802c: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 40008030: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 40008034: f6 06 e0 08 ld [ %i3 + 8 ], %i3 40008038: 90 22 00 01 sub %o0, %g1, %o0 4000803c: 90 0a 00 1b and %o0, %i3, %o0 bintime_addx(bt, th->th_scale * tc_delta(th)); 40008040: b8 5f 00 08 smul %i4, %o0, %i4 40008044: 92 52 00 10 umul %o0, %l0, %o1 40008048: 91 40 00 00 rd %y, %o0 4000804c: 90 07 00 08 add %i4, %o0, %o0 40008050: 9a 82 40 03 addcc %o1, %g3, %o5 40008054: 98 c2 00 02 addxcc %o0, %g2, %o4 40008058: 0a 80 00 12 bcs 400080a0 <_Timecounter_Bintime+0xb0> <== NEVER TAKEN 4000805c: 88 10 20 00 clr %g4 if (_u > _bt->frac) 40008060: 80 a1 20 00 cmp %g4, 0 40008064: 02 80 00 06 be 4000807c <_Timecounter_Bintime+0x8c> <== ALWAYS TAKEN 40008068: d8 3e 20 08 std %o4, [ %i0 + 8 ] _bt->sec++; 4000806c: c4 1e 00 00 ldd [ %i0 ], %g2 <== NOT EXECUTED 40008070: 9a 80 e0 01 addcc %g3, 1, %o5 <== NOT EXECUTED 40008074: 98 40 a0 00 addx %g2, 0, %o4 <== NOT EXECUTED 40008078: d8 3e 00 00 std %o4, [ %i0 ] <== NOT EXECUTED } while (gen == 0 || gen != th->th_generation); 4000807c: 80 a6 a0 00 cmp %i2, 0 40008080: 02 bf ff df be 40007ffc <_Timecounter_Bintime+0xc> <== NEVER TAKEN 40008084: 01 00 00 00 nop 40008088: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 4000808c: 80 a0 40 1a cmp %g1, %i2 40008090: 12 bf ff db bne 40007ffc <_Timecounter_Bintime+0xc> <== NEVER TAKEN 40008094: 01 00 00 00 nop } 40008098: 81 c7 e0 08 ret 4000809c: 81 e8 00 00 restore 400080a0: 10 bf ff f0 b 40008060 <_Timecounter_Bintime+0x70> <== NOT EXECUTED 400080a4: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED =============================================================================== 40010be4 <_Timecounter_Binuptime>: { 40010be4: 9d e3 bf a0 save %sp, -96, %sp 40010be8: 33 10 00 c7 sethi %hi(0x40031c00), %i1 40010bec: b2 16 61 c0 or %i1, 0x1c0, %i1 ! 40031dc0 th = timehands; 40010bf0: fa 06 40 00 ld [ %i1 ], %i5 40010bf4: f4 07 60 70 ld [ %i5 + 0x70 ], %i2 *bt = th->th_offset; 40010bf8: c4 1f 60 20 ldd [ %i5 + 0x20 ], %g2 40010bfc: c4 3e 00 00 std %g2, [ %i0 ] 40010c00: c4 1f 60 28 ldd [ %i5 + 0x28 ], %g2 40010c04: f6 07 40 00 ld [ %i5 ], %i3 40010c08: c4 3e 20 08 std %g2, [ %i0 + 8 ] return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40010c0c: 90 10 00 1b mov %i3, %o0 40010c10: c2 06 c0 00 ld [ %i3 ], %g1 bintime_addx(bt, th->th_scale * tc_delta(th)); 40010c14: f8 07 60 10 ld [ %i5 + 0x10 ], %i4 return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40010c18: 9f c0 40 00 call %g1 40010c1c: e0 07 60 14 ld [ %i5 + 0x14 ], %l0 40010c20: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 40010c24: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 40010c28: f6 06 e0 08 ld [ %i3 + 8 ], %i3 40010c2c: 90 22 00 01 sub %o0, %g1, %o0 40010c30: 90 0a 00 1b and %o0, %i3, %o0 bintime_addx(bt, th->th_scale * tc_delta(th)); 40010c34: b8 5f 00 08 smul %i4, %o0, %i4 40010c38: 92 52 00 10 umul %o0, %l0, %o1 40010c3c: 91 40 00 00 rd %y, %o0 40010c40: 90 07 00 08 add %i4, %o0, %o0 40010c44: 9a 82 40 03 addcc %o1, %g3, %o5 40010c48: 98 c2 00 02 addxcc %o0, %g2, %o4 40010c4c: 0a 80 00 12 bcs 40010c94 <_Timecounter_Binuptime+0xb0> <== NEVER TAKEN 40010c50: 88 10 20 00 clr %g4 if (_u > _bt->frac) 40010c54: 80 a1 20 00 cmp %g4, 0 40010c58: 02 80 00 06 be 40010c70 <_Timecounter_Binuptime+0x8c> <== ALWAYS TAKEN 40010c5c: d8 3e 20 08 std %o4, [ %i0 + 8 ] _bt->sec++; 40010c60: c4 1e 00 00 ldd [ %i0 ], %g2 <== NOT EXECUTED 40010c64: 9a 80 e0 01 addcc %g3, 1, %o5 <== NOT EXECUTED 40010c68: 98 40 a0 00 addx %g2, 0, %o4 <== NOT EXECUTED 40010c6c: d8 3e 00 00 std %o4, [ %i0 ] <== NOT EXECUTED } while (gen == 0 || gen != th->th_generation); 40010c70: 80 a6 a0 00 cmp %i2, 0 40010c74: 02 bf ff df be 40010bf0 <_Timecounter_Binuptime+0xc> <== NEVER TAKEN 40010c78: 01 00 00 00 nop 40010c7c: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 40010c80: 80 a0 40 1a cmp %g1, %i2 40010c84: 12 bf ff db bne 40010bf0 <_Timecounter_Binuptime+0xc> <== NEVER TAKEN 40010c88: 01 00 00 00 nop } 40010c8c: 81 c7 e0 08 ret 40010c90: 81 e8 00 00 restore 40010c94: 10 bf ff f0 b 40010c54 <_Timecounter_Binuptime+0x70> <== NOT EXECUTED 40010c98: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED =============================================================================== 40008130 <_Timecounter_Getbintime>: { 40008130: 07 10 00 43 sethi %hi(0x40010c00), %g3 40008134: 86 10 e3 10 or %g3, 0x310, %g3 ! 40010f10 th = timehands; 40008138: c2 00 c0 00 ld [ %g3 ], %g1 4000813c: c4 00 60 70 ld [ %g1 + 0x70 ], %g2 *bt = th->th_bintime; 40008140: d8 18 60 30 ldd [ %g1 + 0x30 ], %o4 40008144: d8 3a 00 00 std %o4, [ %o0 ] 40008148: d8 18 60 38 ldd [ %g1 + 0x38 ], %o4 4000814c: d8 3a 20 08 std %o4, [ %o0 + 8 ] } while (gen == 0 || gen != th->th_generation); 40008150: 80 a0 a0 00 cmp %g2, 0 40008154: 02 bf ff f9 be 40008138 <_Timecounter_Getbintime+0x8> <== NEVER TAKEN 40008158: 01 00 00 00 nop 4000815c: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 40008160: 80 a0 40 02 cmp %g1, %g2 40008164: 12 bf ff f5 bne 40008138 <_Timecounter_Getbintime+0x8> <== NEVER TAKEN 40008168: 01 00 00 00 nop } 4000816c: 81 c3 e0 08 retl 40008170: 01 00 00 00 nop =============================================================================== 40008174 <_Timecounter_Getnanotime>: { 40008174: 07 10 00 43 sethi %hi(0x40010c00), %g3 <== NOT EXECUTED 40008178: 86 10 e3 10 or %g3, 0x310, %g3 ! 40010f10 <== NOT EXECUTED th = timehands; 4000817c: c2 00 c0 00 ld [ %g3 ], %g1 <== NOT EXECUTED 40008180: c4 00 60 70 ld [ %g1 + 0x70 ], %g2 <== NOT EXECUTED *tsp = th->th_nanotime; 40008184: d8 18 60 50 ldd [ %g1 + 0x50 ], %o4 <== NOT EXECUTED 40008188: d8 3a 00 00 std %o4, [ %o0 ] <== NOT EXECUTED 4000818c: d8 18 60 58 ldd [ %g1 + 0x58 ], %o4 <== NOT EXECUTED 40008190: d8 3a 20 08 std %o4, [ %o0 + 8 ] <== NOT EXECUTED } while (gen == 0 || gen != th->th_generation); 40008194: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40008198: 02 bf ff f9 be 4000817c <_Timecounter_Getnanotime+0x8> <== NOT EXECUTED 4000819c: 01 00 00 00 nop <== NOT EXECUTED 400081a0: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 <== NOT EXECUTED 400081a4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 400081a8: 12 bf ff f5 bne 4000817c <_Timecounter_Getnanotime+0x8> <== NOT EXECUTED 400081ac: 01 00 00 00 nop <== NOT EXECUTED } 400081b0: 81 c3 e0 08 retl <== NOT EXECUTED 400081b4: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 400080dc <_Timecounter_Getnanouptime>: { 400080dc: 19 10 00 43 sethi %hi(0x40010c00), %o4 _ts->tv_nsec = ((uint64_t)1000000000 * 400080e0: 1b 0e e6 b2 sethi %hi(0x3b9ac800), %o5 400080e4: 98 13 23 10 or %o4, 0x310, %o4 400080e8: 9a 13 62 00 or %o5, 0x200, %o5 th = timehands; 400080ec: c2 03 00 00 ld [ %o4 ], %g1 400080f0: c8 00 60 70 ld [ %g1 + 0x70 ], %g4 _ts->tv_sec = _bt->sec; 400080f4: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2 400080f8: c4 3a 00 00 std %g2, [ %o0 ] (uint32_t)(_bt->frac >> 32)) >> 32; 400080fc: c4 00 60 28 ld [ %g1 + 0x28 ], %g2 _ts->tv_nsec = ((uint64_t)1000000000 * 40008100: 86 50 80 0d umul %g2, %o5, %g3 40008104: 85 40 00 00 rd %y, %g2 40008108: c4 22 20 08 st %g2, [ %o0 + 8 ] } while (gen == 0 || gen != th->th_generation); 4000810c: 80 a1 20 00 cmp %g4, 0 40008110: 02 bf ff f7 be 400080ec <_Timecounter_Getnanouptime+0x10> <== NEVER TAKEN 40008114: 01 00 00 00 nop 40008118: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 4000811c: 80 a0 40 04 cmp %g1, %g4 40008120: 12 bf ff f3 bne 400080ec <_Timecounter_Getnanouptime+0x10> <== NEVER TAKEN 40008124: 01 00 00 00 nop } 40008128: 81 c3 e0 08 retl 4000812c: 01 00 00 00 nop =============================================================================== 400081b8 <_Timecounter_Install>: { 400081b8: 9d e3 bf 98 save %sp, -104, %sp tc->tc_next = timecounters; 400081bc: 03 10 00 43 sethi %hi(0x40010c00), %g1 400081c0: c4 00 63 08 ld [ %g1 + 0x308 ], %g2 ! 40010f08 400081c4: c4 26 20 28 st %g2, [ %i0 + 0x28 ] (void)tc->tc_get_timecount(tc); 400081c8: 90 10 00 18 mov %i0, %o0 400081cc: c4 06 00 00 ld [ %i0 ], %g2 400081d0: 9f c0 80 00 call %g2 400081d4: f0 20 63 08 st %i0, [ %g1 + 0x308 ] (void)tc->tc_get_timecount(tc); 400081d8: c2 06 00 00 ld [ %i0 ], %g1 400081dc: 9f c0 40 00 call %g1 400081e0: 90 10 00 18 mov %i0, %o0 timecounter = tc; 400081e4: 03 10 00 43 sethi %hi(0x40010c00), %g1 <== NOT EXECUTED 400081e8: f0 20 63 0c st %i0, [ %g1 + 0x30c ] ! 40010f0c <_Timecounter> <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400081ec: 91 d0 20 09 ta 9 <== NOT EXECUTED _Timecounter_Acquire(&lock_context); 400081f0: c2 27 bf fc st %g1, [ %fp + -4 ] _Timecounter_Windup(new_boottimebin, &lock_context); 400081f4: 90 10 20 00 clr %o0 400081f8: 7f ff fe a6 call 40007c90 <_Timecounter_Windup> 400081fc: 92 07 bf fc add %fp, -4, %o1 } 40008200: 81 c7 e0 08 ret 40008204: 81 e8 00 00 restore =============================================================================== 40007f5c <_Timecounter_Sbinuptime>: { 40007f5c: 9d e3 bf a0 save %sp, -96, %sp 40007f60: 33 10 00 43 sethi %hi(0x40010c00), %i1 40007f64: b2 16 63 10 or %i1, 0x310, %i1 ! 40010f10 th = timehands; 40007f68: fa 06 40 00 ld [ %i1 ], %i5 40007f6c: f6 07 60 70 ld [ %i5 + 0x70 ], %i3 RTEMS_COMPILER_MEMORY_BARRIER(); 40007f70: f8 07 40 00 ld [ %i5 ], %i4 return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40007f74: c2 07 00 00 ld [ %i4 ], %g1 40007f78: e2 07 60 24 ld [ %i5 + 0x24 ], %l1 40007f7c: e0 07 60 28 ld [ %i5 + 0x28 ], %l0 sbt += (th->th_scale * tc_delta(th)) >> 32; 40007f80: f4 07 60 10 ld [ %i5 + 0x10 ], %i2 40007f84: e4 07 60 14 ld [ %i5 + 0x14 ], %l2 return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40007f88: 9f c0 40 00 call %g1 40007f8c: 90 10 00 1c mov %i4, %o0 40007f90: c4 07 60 18 ld [ %i5 + 0x18 ], %g2 tc->tc_counter_mask); 40007f94: c2 07 20 08 ld [ %i4 + 8 ], %g1 } while (gen == 0 || gen != th->th_generation); 40007f98: 80 a6 e0 00 cmp %i3, 0 40007f9c: 02 bf ff f3 be 40007f68 <_Timecounter_Sbinuptime+0xc> <== NEVER TAKEN 40007fa0: 01 00 00 00 nop 40007fa4: c6 07 60 70 ld [ %i5 + 0x70 ], %g3 40007fa8: 80 a0 c0 1b cmp %g3, %i3 40007fac: 12 bf ff ef bne 40007f68 <_Timecounter_Sbinuptime+0xc> <== NEVER TAKEN 40007fb0: 84 22 00 02 sub %o0, %g2, %g2 return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40007fb4: 84 08 80 01 and %g2, %g1, %g2 sbt += (th->th_scale * tc_delta(th)) >> 32; 40007fb8: b4 5e 80 02 smul %i2, %g2, %i2 40007fbc: 86 50 80 12 umul %g2, %l2, %g3 40007fc0: 85 40 00 00 rd %y, %g2 return (((sbintime_t)_bt.sec << 32) + (_bt.frac >> 32)); 40007fc4: 9a 10 20 00 clr %o5 40007fc8: ba 06 80 02 add %i2, %g2, %i5 40007fcc: b2 83 40 10 addcc %o5, %l0, %i1 40007fd0: 84 10 20 00 clr %g2 40007fd4: b0 44 40 02 addx %l1, %g2, %i0 40007fd8: b8 10 20 00 clr %i4 } 40007fdc: 86 87 40 19 addcc %i5, %i1, %g3 40007fe0: 84 47 00 18 addx %i4, %i0, %g2 40007fe4: b2 10 00 03 mov %g3, %i1 40007fe8: 81 c7 e0 08 ret 40007fec: 91 e8 00 02 restore %g0, %g2, %o0 =============================================================================== 4001ba90 <_Timecounter_Set_clock>: { 4001ba90: 9d e3 bf 80 save %sp, -128, %sp bt = *_bt; 4001ba94: f8 1e 00 00 ldd [ %i0 ], %i4 4001ba98: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 4001ba9c: f8 3f bf e0 std %i4, [ %fp + -32 ] binuptime(&bt2); 4001baa0: 90 07 bf f0 add %fp, -16, %o0 4001baa4: 7f ff ff 15 call 4001b6f8 <_Timecounter_Binuptime> 4001baa8: c4 3f bf e8 std %g2, [ %fp + -24 ] 4001baac: c4 1f bf f8 ldd [ %fp + -8 ], %g2 4001bab0: f8 1f bf e8 ldd [ %fp + -24 ], %i4 4001bab4: b6 a7 40 03 subcc %i5, %g3, %i3 4001bab8: b4 e7 00 02 subxcc %i4, %g2, %i2 4001babc: 0a 80 00 12 bcs 4001bb04 <_Timecounter_Set_clock+0x74> <== ALWAYS TAKEN 4001bac0: 82 10 20 00 clr %g1 _bt->frac -= _bt2->frac; 4001bac4: f4 3f bf e8 std %i2, [ %fp + -24 ] if (_u < _bt->frac) 4001bac8: 80 a0 60 00 cmp %g1, 0 4001bacc: 02 80 00 05 be 4001bae0 <_Timecounter_Set_clock+0x50> <== NEVER TAKEN 4001bad0: f4 1f bf e0 ldd [ %fp + -32 ], %i2 _bt->sec--; 4001bad4: c4 1f bf e0 ldd [ %fp + -32 ], %g2 4001bad8: b6 80 ff ff addcc %g3, -1, %i3 4001badc: b4 40 bf ff addx %g2, -1, %i2 _bt->sec -= _bt2->sec; 4001bae0: f8 1f bf f0 ldd [ %fp + -16 ], %i4 4001bae4: 86 a6 c0 1d subcc %i3, %i5, %g3 4001bae8: 84 66 80 1c subx %i2, %i4, %g2 _Timecounter_Windup(&bt, lock_context); 4001baec: 92 10 00 19 mov %i1, %o1 4001baf0: c4 3f bf e0 std %g2, [ %fp + -32 ] 4001baf4: 7f ff fe 4e call 4001b42c <_Timecounter_Windup> 4001baf8: 90 07 bf e0 add %fp, -32, %o0 } 4001bafc: 81 c7 e0 08 ret 4001bb00: 81 e8 00 00 restore 4001bb04: 10 bf ff f0 b 4001bac4 <_Timecounter_Set_clock+0x34> 4001bb08: 82 10 20 01 mov 1, %g1 =============================================================================== 40008208 <_Timecounter_Tick>: } } #else /* __rtems__ */ void _Timecounter_Tick(void) { 40008208: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Per_CPU_Control *cpu_self = _Per_CPU_Get(); 4000820c: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED 40008210: 91 d0 20 09 ta 9 <== NOT EXECUTED _Timecounter_Acquire(&lock_context); 40008214: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED _Timecounter_Windup(new_boottimebin, &lock_context); 40008218: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000821c: 7f ff fe 9d call 40007c90 <_Timecounter_Windup> <== NOT EXECUTED 40008220: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED if (_Per_CPU_Is_boot_processor(cpu_self)) { tc_windup(NULL); } _Watchdog_Tick(cpu_self); 40008224: 40 00 0e cc call 4000bd54 <_Watchdog_Tick> <== NOT EXECUTED 40008228: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED } 4000822c: 81 c7 e0 08 ret <== NOT EXECUTED 40008230: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40008234 <_Timecounter_Tick_simple>: void _Timecounter_Tick_simple(uint32_t delta, uint32_t offset, ISR_lock_Context *lock_context) { 40008234: 9d e3 bf a0 save %sp, -96, %sp struct bintime bt; struct timehands *th; uint32_t ogen; th = timehands; 40008238: 03 10 00 43 sethi %hi(0x40010c00), %g1 4000823c: c2 00 63 10 ld [ %g1 + 0x310 ], %g1 ! 40010f10 ogen = th->th_generation; th->th_offset_count = offset; 40008240: f2 20 60 18 st %i1, [ %g1 + 0x18 ] bintime_addx(&th->th_offset, th->th_scale * delta); 40008244: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 40008248: f8 18 60 28 ldd [ %g1 + 0x28 ], %i4 4000824c: c6 00 60 10 ld [ %g1 + 0x10 ], %g3 40008250: 86 58 c0 18 smul %g3, %i0, %g3 ogen = th->th_generation; 40008254: c8 00 60 70 ld [ %g1 + 0x70 ], %g4 bintime_addx(&th->th_offset, th->th_scale * delta); 40008258: b2 50 80 18 umul %g2, %i0, %i1 4000825c: b1 40 00 00 rd %y, %i0 40008260: b0 00 c0 18 add %g3, %i0, %i0 40008264: 96 86 40 1d addcc %i1, %i5, %o3 40008268: 94 c6 00 1c addxcc %i0, %i4, %o2 4000826c: 0a 80 00 30 bcs 4000832c <_Timecounter_Tick_simple+0xf8> 40008270: 84 10 20 00 clr %g2 if (_u > _bt->frac) 40008274: 80 a0 a0 00 cmp %g2, 0 40008278: 12 80 00 28 bne 40008318 <_Timecounter_Tick_simple+0xe4> 4000827c: d4 38 60 28 std %o2, [ %g1 + 0x28 ] 40008280: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4 40008284: c4 18 60 68 ldd [ %g1 + 0x68 ], %g2 40008288: b2 80 c0 0b addcc %g3, %o3, %i1 4000828c: b0 c0 80 0a addxcc %g2, %o2, %i0 _bt->sec++; 40008290: 0a 80 00 29 bcs 40008334 <_Timecounter_Tick_simple+0x100> 40008294: 96 83 60 01 addcc %o5, 1, %o3 bt = th->th_offset; 40008298: 94 10 00 0c mov %o4, %o2 4000829c: 96 10 00 0d mov %o5, %o3 _bt->sec += _bt2->sec; 400082a0: c4 18 60 60 ldd [ %g1 + 0x60 ], %g2 400082a4: 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; 400082a8: f0 38 60 38 std %i0, [ %g1 + 0x38 ] 400082ac: b8 42 80 02 addx %o2, %g2, %i4 _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 400082b0: 15 00 03 d0 sethi %hi(0xf4000), %o2 _ts->tv_nsec = ((uint64_t)1000000000 * 400082b4: 05 0e e6 b2 sethi %hi(0x3b9ac800), %g2 _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 400082b8: 94 12 a2 40 or %o2, 0x240, %o2 _ts->tv_nsec = ((uint64_t)1000000000 * 400082bc: 84 10 a2 00 or %g2, 0x200, %g2 _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 400082c0: 96 56 00 0a umul %i0, %o2, %o3 400082c4: 95 40 00 00 rd %y, %o2 _ts->tv_nsec = ((uint64_t)1000000000 * 400082c8: 86 56 00 02 umul %i0, %g2, %g3 400082cc: 85 40 00 00 rd %y, %g2 400082d0: 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) 400082d4: 88 81 20 01 inccc %g4 _tv->tv_sec = _bt->sec; 400082d8: f8 38 60 40 std %i4, [ %g1 + 0x40 ] _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 400082dc: d4 20 60 48 st %o2, [ %g1 + 0x48 ] _ts->tv_sec = _bt->sec; 400082e0: f8 38 60 50 std %i4, [ %g1 + 0x50 ] 400082e4: 12 80 00 03 bne 400082f0 <_Timecounter_Tick_simple+0xbc> <== ALWAYS TAKEN 400082e8: c4 20 60 58 st %g2, [ %g1 + 0x58 ] ogen = 1; 400082ec: 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; 400082f0: 05 10 00 43 sethi %hi(0x40010c00), %g2 <== NOT EXECUTED 400082f4: f8 38 a3 00 std %i4, [ %g2 + 0x300 ] ! 40010f00 <_Timecounter_Time_second> <== NOT EXECUTED th->th_generation = ogen; 400082f8: c8 20 60 70 st %g4, [ %g1 + 0x70 ] <== NOT EXECUTED time_uptime = th->th_offset.sec; 400082fc: 03 10 00 43 sethi %hi(0x40010c00), %g1 <== NOT EXECUTED 40008300: da 20 62 fc st %o5, [ %g1 + 0x2fc ] ! 40010efc <_Timecounter_Time_uptime> <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40008304: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40008308: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000830c: 01 00 00 00 nop _Timecounter_Release(lock_context); _Watchdog_Tick(_Per_CPU_Get_snapshot()); 40008310: 40 00 0e 91 call 4000bd54 <_Watchdog_Tick> 40008314: 91 e8 00 06 restore %g0, %g6, %o0 _bt->sec++; 40008318: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2 4000831c: 9a 80 e0 01 addcc %g3, 1, %o5 40008320: 98 40 a0 00 addx %g2, 0, %o4 40008324: 10 bf ff d8 b 40008284 <_Timecounter_Tick_simple+0x50> 40008328: d8 38 60 20 std %o4, [ %g1 + 0x20 ] 4000832c: 10 bf ff d2 b 40008274 <_Timecounter_Tick_simple+0x40> 40008330: 84 10 20 01 mov 1, %g2 _bt->sec++; 40008334: 10 bf ff db b 400082a0 <_Timecounter_Tick_simple+0x6c> 40008338: 94 43 20 00 addx %o4, 0, %o2 =============================================================================== 40045110 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 40045110: 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; 40045114: de 06 60 08 ld [ %i1 + 8 ], %o7 <== NOT EXECUTED right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 40045118: c8 06 40 00 ld [ %i1 ], %g4 <== NOT EXECUTED 4004511c: c4 06 60 04 ld [ %i1 + 4 ], %g2 <== NOT EXECUTED 40045120: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 <== NOT EXECUTED right += rhs->tv_nsec; 40045124: b9 3b e0 1f sra %o7, 0x1f, %i4 <== NOT EXECUTED right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 40045128: 82 10 62 00 or %g1, 0x200, %g1 <== NOT EXECUTED 4004512c: 86 50 80 01 umul %g2, %g1, %g3 <== NOT EXECUTED 40045130: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED 40045134: 88 59 00 01 smul %g4, %g1, %g4 <== NOT EXECUTED right += rhs->tv_nsec; 40045138: 96 83 c0 03 addcc %o7, %g3, %o3 <== NOT EXECUTED right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 4004513c: 84 01 00 02 add %g4, %g2, %g2 <== NOT EXECUTED right += rhs->tv_nsec; 40045140: 94 47 00 02 addx %i4, %g2, %o2 <== NOT EXECUTED if ( right == 0 ) { 40045144: 80 92 80 0b orcc %o2, %o3, %g0 <== NOT EXECUTED 40045148: 02 80 00 20 be 400451c8 <_Timespec_Divide+0xb8> <== NOT EXECUTED 4004514c: 11 00 00 61 sethi %hi(0x18400), %o0 <== NOT EXECUTED left += lhs->tv_nsec; 40045150: f2 06 20 08 ld [ %i0 + 8 ], %i1 <== NOT EXECUTED left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 40045154: c8 06 00 00 ld [ %i0 ], %g4 <== NOT EXECUTED 40045158: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED 4004515c: 86 50 80 01 umul %g2, %g1, %g3 <== NOT EXECUTED 40045160: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED 40045164: 88 59 00 01 smul %g4, %g1, %g4 <== NOT EXECUTED left += lhs->tv_nsec; 40045168: b9 3e 60 1f sra %i1, 0x1f, %i4 <== NOT EXECUTED left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 4004516c: 84 01 00 02 add %g4, %g2, %g2 <== NOT EXECUTED left += lhs->tv_nsec; 40045170: b2 86 40 03 addcc %i1, %g3, %i1 <== NOT EXECUTED 40045174: b0 47 00 02 addx %i4, %g2, %i0 <== NOT EXECUTED * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 40045178: 90 12 22 a0 or %o0, 0x2a0, %o0 <== NOT EXECUTED 4004517c: 82 5e 00 08 smul %i0, %o0, %g1 <== NOT EXECUTED 40045180: 92 56 40 08 umul %i1, %o0, %o1 <== NOT EXECUTED 40045184: 91 40 00 00 rd %y, %o0 <== NOT EXECUTED 40045188: 40 00 d2 b8 call 40079c68 <__udivdi3> <== NOT EXECUTED 4004518c: 90 00 40 08 add %g1, %o0, %o0 <== NOT EXECUTED *ival_percentage = answer / 1000; 40045190: 94 10 20 00 clr %o2 <== NOT EXECUTED answer = (left * 100000) / right; 40045194: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED 40045198: ba 10 00 09 mov %o1, %i5 <== NOT EXECUTED *ival_percentage = answer / 1000; 4004519c: 40 00 d2 b3 call 40079c68 <__udivdi3> <== NOT EXECUTED 400451a0: 96 10 23 e8 mov 0x3e8, %o3 <== NOT EXECUTED 400451a4: d2 26 80 00 st %o1, [ %i2 ] <== NOT EXECUTED *fval_percentage = answer % 1000; 400451a8: 94 10 20 00 clr %o2 <== NOT EXECUTED 400451ac: 96 10 23 e8 mov 0x3e8, %o3 <== NOT EXECUTED 400451b0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED 400451b4: 40 00 d3 26 call 40079e4c <__umoddi3> <== NOT EXECUTED 400451b8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 400451bc: d2 26 c0 00 st %o1, [ %i3 ] <== NOT EXECUTED } 400451c0: 81 c7 e0 08 ret <== NOT EXECUTED 400451c4: 81 e8 00 00 restore <== NOT EXECUTED *ival_percentage = 0; 400451c8: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED *fval_percentage = 0; 400451cc: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED return; 400451d0: 81 c7 e0 08 ret <== NOT EXECUTED 400451d4: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 400451d8 <_Timespec_Divide_by_integer>: void _Timespec_Divide_by_integer( const struct timespec *time, uint32_t iterations, struct timespec *result ) { 400451d8: 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; 400451dc: fa 06 20 08 ld [ %i0 + 8 ], %i5 <== NOT EXECUTED t = time->tv_sec; 400451e0: c6 06 00 00 ld [ %i0 ], %g3 <== NOT EXECUTED 400451e4: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED t += time->tv_nsec; 400451e8: 91 3f 60 1f sra %i5, 0x1f, %o0 <== NOT EXECUTED t *= TOD_NANOSECONDS_PER_SECOND; 400451ec: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 <== NOT EXECUTED 400451f0: 82 10 62 00 or %g1, 0x200, %g1 ! 3b9aca00 <== NOT EXECUTED 400451f4: 88 58 c0 01 smul %g3, %g1, %g4 <== NOT EXECUTED 400451f8: 86 50 80 01 umul %g2, %g1, %g3 <== NOT EXECUTED 400451fc: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED /* * Divide to get nanoseconds per iteration */ t /= iterations; 40045200: ba 87 40 03 addcc %i5, %g3, %i5 <== NOT EXECUTED t *= TOD_NANOSECONDS_PER_SECOND; 40045204: 84 01 00 02 add %g4, %g2, %g2 <== NOT EXECUTED t /= iterations; 40045208: 94 10 20 00 clr %o2 <== NOT EXECUTED 4004520c: b8 42 00 02 addx %o0, %g2, %i4 <== NOT EXECUTED 40045210: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED 40045214: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED 40045218: 40 00 d2 94 call 40079c68 <__udivdi3> <== NOT EXECUTED 4004521c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED /* * Put it back in the timespec result */ result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 40045220: 94 10 20 00 clr %o2 <== NOT EXECUTED t /= iterations; 40045224: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED 40045228: ba 10 00 09 mov %o1, %i5 <== NOT EXECUTED result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 4004522c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 <== NOT EXECUTED 40045230: 40 00 d2 8e call 40079c68 <__udivdi3> <== NOT EXECUTED 40045234: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <== NOT EXECUTED 40045238: d0 3e 80 00 std %o0, [ %i2 ] <== NOT EXECUTED result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND; 4004523c: 94 10 20 00 clr %o2 <== NOT EXECUTED 40045240: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 <== NOT EXECUTED 40045244: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED 40045248: 96 12 e2 00 or %o3, 0x200, %o3 <== NOT EXECUTED 4004524c: 40 00 d3 00 call 40079e4c <__umoddi3> <== NOT EXECUTED 40045250: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 40045254: d2 26 a0 08 st %o1, [ %i2 + 8 ] <== NOT EXECUTED } 40045258: 81 c7 e0 08 ret <== NOT EXECUTED 4004525c: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40015480 <_Timespec_Get_as_nanoseconds>: #include uint64_t _Timespec_Get_as_nanoseconds( const struct timespec *time ) { 40015480: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED return ( ((uint64_t) time->tv_sec) * 1000000000ULL ) + time->tv_nsec; 40015484: fa 06 20 08 ld [ %i0 + 8 ], %i5 <== NOT EXECUTED 40015488: c8 06 00 00 ld [ %i0 ], %g4 <== NOT EXECUTED 4001548c: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED 40015490: b1 3f 60 1f sra %i5, 0x1f, %i0 <== NOT EXECUTED 40015494: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 <== NOT EXECUTED 40015498: 82 10 62 00 or %g1, 0x200, %g1 ! 3b9aca00 <== NOT EXECUTED 4001549c: 86 50 80 01 umul %g2, %g1, %g3 <== NOT EXECUTED 400154a0: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED 400154a4: 88 59 00 01 smul %g4, %g1, %g4 <== NOT EXECUTED } 400154a8: 9a 80 c0 1d addcc %g3, %i5, %o5 <== NOT EXECUTED return ( ((uint64_t) time->tv_sec) * 1000000000ULL ) + time->tv_nsec; 400154ac: 84 01 00 02 add %g4, %g2, %g2 <== NOT EXECUTED } 400154b0: b2 10 00 0d mov %o5, %i1 <== NOT EXECUTED 400154b4: 98 40 80 18 addx %g2, %i0, %o4 <== NOT EXECUTED 400154b8: 81 c7 e0 08 ret <== NOT EXECUTED 400154bc: 91 e8 00 0c restore %g0, %o4, %o0 <== NOT EXECUTED =============================================================================== 4002ce3c <_Timespec_Less_than>: bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec < rhs->tv_sec ) 4002ce3c: c4 02 00 00 ld [ %o0 ], %g2 <== NOT EXECUTED 4002ce40: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED 4002ce44: c8 02 20 04 ld [ %o0 + 4 ], %g4 <== NOT EXECUTED 4002ce48: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 4002ce4c: 14 80 00 13 bg 4002ce98 <_Timespec_Less_than+0x5c> <== NOT EXECUTED 4002ce50: c6 02 60 04 ld [ %o1 + 4 ], %g3 <== NOT EXECUTED 4002ce54: 02 80 00 0f be 4002ce90 <_Timespec_Less_than+0x54> <== NOT EXECUTED 4002ce58: 80 a0 c0 04 cmp %g3, %g4 <== NOT EXECUTED return true; if ( lhs->tv_sec > rhs->tv_sec ) 4002ce5c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 4002ce60: 34 80 00 0a bg,a 4002ce88 <_Timespec_Less_than+0x4c> <== NOT EXECUTED 4002ce64: 90 10 20 00 clr %o0 <== NOT EXECUTED 4002ce68: 02 80 00 0f be 4002cea4 <_Timespec_Less_than+0x68> <== NOT EXECUTED 4002ce6c: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED return false; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) 4002ce70: c4 02 20 08 ld [ %o0 + 8 ], %g2 <== NOT EXECUTED 4002ce74: c2 02 60 08 ld [ %o1 + 8 ], %g1 <== NOT EXECUTED 4002ce78: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 4002ce7c: 06 80 00 03 bl 4002ce88 <_Timespec_Less_than+0x4c> <== NOT EXECUTED 4002ce80: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED return false; 4002ce84: 90 10 20 00 clr %o0 <== NOT EXECUTED return true; return false; } 4002ce88: 81 c3 e0 08 retl <== NOT EXECUTED 4002ce8c: 90 0a 20 01 and %o0, 1, %o0 <== NOT EXECUTED if ( lhs->tv_sec < rhs->tv_sec ) 4002ce90: 08 bf ff f4 bleu 4002ce60 <_Timespec_Less_than+0x24> <== NOT EXECUTED 4002ce94: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED return true; 4002ce98: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED } 4002ce9c: 81 c3 e0 08 retl <== NOT EXECUTED 4002cea0: 90 0a 20 01 and %o0, 1, %o0 <== NOT EXECUTED if ( lhs->tv_sec > rhs->tv_sec ) 4002cea4: 28 bf ff f4 bleu,a 4002ce74 <_Timespec_Less_than+0x38> <== NOT EXECUTED 4002cea8: c4 02 20 08 ld [ %o0 + 8 ], %g2 <== NOT EXECUTED return false; 4002ceac: 10 bf ff f7 b 4002ce88 <_Timespec_Less_than+0x4c> <== NOT EXECUTED 4002ceb0: 90 10 20 00 clr %o0 <== NOT EXECUTED =============================================================================== 4002ceb4 <_Timespec_Subtract>: void _Timespec_Subtract( const struct timespec *start, const struct timespec *end, struct timespec *result ) { 4002ceb4: 9d e3 bf a0 save %sp, -96, %sp 4002ceb8: d8 1e 00 00 ldd [ %i0 ], %o4 4002cebc: d4 1e 40 00 ldd [ %i1 ], %o2 4002cec0: ba a2 c0 0d subcc %o3, %o5, %i5 if (end->tv_nsec < start->tv_nsec) { 4002cec4: c2 06 60 08 ld [ %i1 + 8 ], %g1 4002cec8: c4 06 20 08 ld [ %i0 + 8 ], %g2 4002cecc: b8 62 80 0c subx %o2, %o4, %i4 4002ced0: 80 a0 40 02 cmp %g1, %g2 4002ced4: 26 80 00 07 bl,a 4002cef0 <_Timespec_Subtract+0x3c> <== NEVER TAKEN 4002ced8: b2 87 7f ff addcc %i5, -1, %i1 <== NOT EXECUTED 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; 4002cedc: 82 20 40 02 sub %g1, %g2, %g1 result->tv_sec = end->tv_sec - start->tv_sec; 4002cee0: f8 3e 80 00 std %i4, [ %i2 ] result->tv_nsec = end->tv_nsec - start->tv_nsec; 4002cee4: c2 26 a0 08 st %g1, [ %i2 + 8 ] } } 4002cee8: 81 c7 e0 08 ret 4002ceec: 81 e8 00 00 restore (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec; 4002cef0: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED result->tv_sec = end->tv_sec - start->tv_sec - 1; 4002cef4: b0 47 3f ff addx %i4, -1, %i0 <== NOT EXECUTED (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec; 4002cef8: 05 0e e6 b2 sethi %hi(0x3b9ac800), %g2 <== NOT EXECUTED result->tv_sec = end->tv_sec - start->tv_sec - 1; 4002cefc: f0 3e 80 00 std %i0, [ %i2 ] <== NOT EXECUTED (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec; 4002cf00: 84 10 a2 00 or %g2, 0x200, %g2 <== NOT EXECUTED 4002cf04: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED result->tv_nsec = 4002cf08: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED 4002cf0c: 81 c7 e0 08 ret <== NOT EXECUTED 4002cf10: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4001a564 <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 4001a564: 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) ) 4001a568: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED 4001a56c: fa 06 20 04 ld [ %i0 + 4 ], %i5 <== NOT EXECUTED 4001a570: 80 90 40 1d orcc %g1, %i5, %g0 <== NOT EXECUTED 4001a574: 12 80 00 06 bne 4001a58c <_Timespec_To_ticks+0x28> <== NOT EXECUTED 4001a578: 01 00 00 00 nop <== NOT EXECUTED 4001a57c: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED 4001a580: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001a584: 02 80 00 11 be 4001a5c8 <_Timespec_To_ticks+0x64> <== NOT EXECUTED 4001a588: 90 10 20 00 clr %o0 <== NOT EXECUTED /** * 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; 4001a58c: 40 00 04 be call 4001b884 <== NOT EXECUTED 4001a590: 01 00 00 00 nop <== NOT EXECUTED nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick(); ticks += time->tv_nsec / nanoseconds_per_tick; 4001a594: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick(); 4001a598: 05 10 00 b5 sethi %hi(0x4002d400), %g2 <== NOT EXECUTED 4001a59c: c4 00 a0 0c ld [ %g2 + 0xc ], %g2 ! 4002d40c <_Watchdog_Nanoseconds_per_tick> <== NOT EXECUTED ticks += time->tv_nsec / nanoseconds_per_tick; 4001a5a0: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 4001a5a4: 01 00 00 00 nop <== NOT EXECUTED 4001a5a8: 01 00 00 00 nop <== NOT EXECUTED 4001a5ac: 01 00 00 00 nop <== NOT EXECUTED 4001a5b0: b0 70 40 02 udiv %g1, %g2, %i0 <== NOT EXECUTED ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 4001a5b4: 90 5a 00 1d smul %o0, %i5, %o0 <== NOT EXECUTED if ( (time->tv_nsec % nanoseconds_per_tick) != 0 ) 4001a5b8: 84 5e 00 02 smul %i0, %g2, %g2 <== NOT EXECUTED 4001a5bc: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED ticks += 1; 4001a5c0: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 4001a5c4: 90 42 00 18 addx %o0, %i0, %o0 <== NOT EXECUTED return ticks; } 4001a5c8: 81 c7 e0 08 ret <== NOT EXECUTED 4001a5cc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED =============================================================================== 4000b8fc <_User_extensions_Add_set>: __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b8fc: 91 d0 20 09 ta 9 <== NOT EXECUTED old_last = tail->previous; 4000b900: 05 10 00 43 sethi %hi(0x40010c00), %g2 <== NOT EXECUTED 4000b904: 84 10 a3 d8 or %g2, 0x3d8, %g2 ! 40010fd8 <_User_extensions_List> <== NOT EXECUTED 4000b908: c6 00 a0 08 ld [ %g2 + 8 ], %g3 <== NOT EXECUTED the_node->next = tail; 4000b90c: 88 00 a0 04 add %g2, 4, %g4 <== NOT EXECUTED 4000b910: c8 22 00 00 st %g4, [ %o0 ] <== NOT EXECUTED tail->previous = the_node; 4000b914: d0 20 a0 08 st %o0, [ %g2 + 8 ] <== NOT EXECUTED old_last->next = the_node; 4000b918: d0 20 c0 00 st %o0, [ %g3 ] <== NOT EXECUTED the_node->previous = old_last; 4000b91c: c6 22 20 04 st %g3, [ %o0 + 4 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b920: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b924: 01 00 00 00 nop /* * If a switch handler is present, append it to the switch chain. */ if ( the_extension->Callouts.thread_switch != NULL ) { 4000b928: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 4000b92c: 80 a0 60 00 cmp %g1, 0 4000b930: 02 80 00 0f be 4000b96c <_User_extensions_Add_set+0x70> <== ALWAYS TAKEN 4000b934: 01 00 00 00 nop ISR_Level level; the_extension->Switch.thread_switch = 4000b938: c2 22 20 10 st %g1, [ %o0 + 0x10 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b93c: 91 d0 20 09 ta 9 <== NOT EXECUTED old_last = tail->previous; 4000b940: 05 10 00 43 sethi %hi(0x40010c00), %g2 <== NOT EXECUTED 4000b944: 84 10 a3 c0 or %g2, 0x3c0, %g2 ! 40010fc0 <_User_extensions_Switches_list> <== NOT EXECUTED 4000b948: c6 00 a0 08 ld [ %g2 + 8 ], %g3 <== NOT EXECUTED the_node->next = tail; 4000b94c: 88 00 a0 04 add %g2, 4, %g4 <== NOT EXECUTED 4000b950: 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 ); 4000b954: 88 02 20 08 add %o0, 8, %g4 <== NOT EXECUTED tail->previous = the_node; 4000b958: c8 20 a0 08 st %g4, [ %g2 + 8 ] <== NOT EXECUTED old_last->next = the_node; 4000b95c: c8 20 c0 00 st %g4, [ %g3 ] <== NOT EXECUTED the_node->previous = old_last; 4000b960: c6 22 20 0c st %g3, [ %o0 + 0xc ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b964: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000b968: 01 00 00 00 nop <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); _Per_CPU_Release_all( level ); } } 4000b96c: 81 c3 e0 08 retl 4000b970: 01 00 00 00 nop =============================================================================== 4000b878 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 4000b878: 9d e3 bf a0 save %sp, -96, %sp 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(); 4000b87c: 39 10 00 3f sethi %hi(0x4000fc00), %i4 4000b880: b8 17 22 94 or %i4, 0x294, %i4 ! 4000fe94 4000b884: f6 07 20 38 ld [ %i4 + 0x38 ], %i3 initial_extension_switch_controls = _Workspace_Allocate_or_fatal_error( n * sizeof( *initial_extension_switch_controls ) 4000b888: 87 2e e0 01 sll %i3, 1, %g3 4000b88c: 86 00 c0 1b add %g3, %i3, %g3 4000b890: bb 28 e0 02 sll %g3, 2, %i5 initial_extension_switch_controls = _Workspace_Allocate_or_fatal_error( 4000b894: 40 00 01 f7 call 4000c070 <_Workspace_Allocate_or_fatal_error> 4000b898: 90 10 00 1d mov %i5, %o0 ); initial_table = rtems_configuration_get_user_extension_table(); for ( i = 0 ; i < n ; ++i ) { 4000b89c: 80 a6 e0 00 cmp %i3, 0 4000b8a0: 02 80 00 15 be 4000b8f4 <_User_extensions_Handler_initialization+0x7c> <== NEVER TAKEN 4000b8a4: c2 07 20 3c ld [ %i4 + 0x3c ], %g1 old_last = tail->previous; 4000b8a8: 09 10 00 43 sethi %hi(0x40010c00), %g4 4000b8ac: 86 02 00 1d add %o0, %i5, %g3 4000b8b0: 88 11 23 c0 or %g4, 0x3c0, %g4 4000b8b4: 82 00 60 10 add %g1, 0x10, %g1 the_node->next = tail; 4000b8b8: ba 01 20 04 add %g4, 4, %i5 User_extensions_thread_switch_extension callout; callout = initial_table[ i ].thread_switch; 4000b8bc: c4 00 40 00 ld [ %g1 ], %g2 if ( callout != NULL ) { 4000b8c0: 80 a0 a0 00 cmp %g2, 0 4000b8c4: 22 80 00 09 be,a 4000b8e8 <_User_extensions_Handler_initialization+0x70> 4000b8c8: 90 02 20 0c add %o0, 0xc, %o0 User_extensions_Switch_control *c; c = &initial_extension_switch_controls[ i ]; c->thread_switch = callout; 4000b8cc: c4 22 20 08 st %g2, [ %o0 + 8 ] old_last = tail->previous; 4000b8d0: c4 01 20 08 ld [ %g4 + 8 ], %g2 the_node->next = tail; 4000b8d4: fa 22 00 00 st %i5, [ %o0 ] tail->previous = the_node; 4000b8d8: d0 21 20 08 st %o0, [ %g4 + 8 ] old_last->next = the_node; 4000b8dc: d0 20 80 00 st %o0, [ %g2 ] the_node->previous = old_last; 4000b8e0: c4 22 20 04 st %g2, [ %o0 + 4 ] 4000b8e4: 90 02 20 0c add %o0, 0xc, %o0 for ( i = 0 ; i < n ; ++i ) { 4000b8e8: 80 a2 00 03 cmp %o0, %g3 4000b8ec: 12 bf ff f4 bne 4000b8bc <_User_extensions_Handler_initialization+0x44> 4000b8f0: 82 00 60 24 add %g1, 0x24, %g1 _Chain_Initialize_node( &c->Node ); _Chain_Append_unprotected( &_User_extensions_Switches_list, &c->Node ); } } } 4000b8f4: 81 c7 e0 08 ret 4000b8f8: 81 e8 00 00 restore =============================================================================== 4000bab4 <_User_extensions_Iterate>: void _User_extensions_Iterate( void *arg, User_extensions_Visitor visitor, Chain_Iterator_direction direction ) { 4000bab4: 9d e3 bf 88 save %sp, -120, %sp User_extensions_Iterator iter; ISR_lock_Context lock_context; executing = _Thread_Get_executing(); initial_begin = rtems_configuration_get_user_extension_table(); 4000bab8: 03 10 00 3f sethi %hi(0x4000fc00), %g1 4000babc: 82 10 62 94 or %g1, 0x294, %g1 ! 4000fe94 initial_end = initial_begin + rtems_configuration_get_number_of_initial_extensions(); 4000bac0: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 initial_begin = rtems_configuration_get_user_extension_table(); 4000bac4: e0 00 60 3c ld [ %g1 + 0x3c ], %l0 initial_begin + rtems_configuration_get_number_of_initial_extensions(); 4000bac8: bb 28 a0 03 sll %g2, 3, %i5 4000bacc: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4 4000bad0: ba 07 40 02 add %i5, %g2, %i5 if ( direction == CHAIN_ITERATOR_FORWARD ) { 4000bad4: 80 a6 a0 00 cmp %i2, 0 initial_begin + rtems_configuration_get_number_of_initial_extensions(); 4000bad8: bb 2f 60 02 sll %i5, 2, %i5 if ( direction == CHAIN_ITERATOR_FORWARD ) { 4000badc: 12 80 00 50 bne 4000bc1c <_User_extensions_Iterate+0x168> 4000bae0: ba 04 00 1d add %l0, %i5, %i5 initial_current = initial_begin; while ( initial_current != initial_end ) { 4000bae4: 80 a4 00 1d cmp %l0, %i5 4000bae8: 02 80 00 0a be 4000bb10 <_User_extensions_Iterate+0x5c> <== NEVER TAKEN 4000baec: b6 10 00 10 mov %l0, %i3 (*visitor)( executing, arg, initial_current ); 4000baf0: 94 10 00 1b mov %i3, %o2 4000baf4: 92 10 00 18 mov %i0, %o1 4000baf8: 9f c6 40 00 call %i1 4000bafc: 90 10 00 1c mov %i4, %o0 ++initial_current; 4000bb00: b6 06 e0 24 add %i3, 0x24, %i3 while ( initial_current != initial_end ) { 4000bb04: 80 a7 40 1b cmp %i5, %i3 4000bb08: 12 bf ff fb bne 4000baf4 <_User_extensions_Iterate+0x40> 4000bb0c: 94 10 00 1b mov %i3, %o2 } end = _Chain_Immutable_tail( &_User_extensions_List.Active ); 4000bb10: 37 10 00 43 sethi %hi(0x40010c00), %i3 <== NOT EXECUTED 4000bb14: b6 16 e3 dc or %i3, 0x3dc, %i3 ! 40010fdc <_User_extensions_List+0x4> <== NOT EXECUTED 4000bb18: 84 06 ff fc add %i3, -4, %g2 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000bb1c: 91 d0 20 09 ta 9 <== NOT EXECUTED old_last = tail->previous; 4000bb20: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4 tail->previous = the_node; 4000bb24: 86 07 bf ec add %fp, -20, %g3 the_node->next = tail; 4000bb28: 9e 00 a0 10 add %g2, 0x10, %o7 tail->previous = the_node; 4000bb2c: c6 20 a0 14 st %g3, [ %g2 + 0x14 ] &the_iterator->Registry_node ); the_iterator->direction = direction; if ( direction == CHAIN_ITERATOR_FORWARD ) { 4000bb30: 80 a6 a0 00 cmp %i2, 0 the_node->next = tail; 4000bb34: de 27 bf ec st %o7, [ %fp + -20 ] old_last->next = the_node; 4000bb38: c6 21 00 00 st %g3, [ %g4 ] the_node->previous = old_last; 4000bb3c: c8 27 bf f0 st %g4, [ %fp + -16 ] if ( direction == CHAIN_ITERATOR_FORWARD ) { 4000bb40: 02 80 00 03 be 4000bb4c <_User_extensions_Iterate+0x98> 4000bb44: f4 27 bf f4 st %i2, [ %fp + -12 ] the_iterator->position = _Chain_Head( the_chain ); } else { the_iterator->position = _Chain_Tail( the_chain ); 4000bb48: 84 00 a0 04 add %g2, 4, %g2 &_User_extensions_List.Iterators, &iter.Iterator, direction ); if ( executing != NULL ) { 4000bb4c: 80 a7 20 00 cmp %i4, 0 4000bb50: 02 80 00 05 be 4000bb64 <_User_extensions_Iterate+0xb0> 4000bb54: c4 27 bf f8 st %g2, [ %fp + -8 ] iter.previous = executing->last_user_extensions_iterator; 4000bb58: c4 07 21 88 ld [ %i4 + 0x188 ], %g2 4000bb5c: c4 27 bf fc st %g2, [ %fp + -4 ] executing->last_user_extensions_iterator = &iter; 4000bb60: c6 27 21 88 st %g3, [ %i4 + 0x188 ] end = _Chain_Immutable_head( &_User_extensions_List.Active ); 4000bb64: 10 80 00 0f b 4000bba0 <_User_extensions_Iterate+0xec> 4000bb68: 84 10 00 1a mov %i2, %g2 4000bb6c: d4 00 c0 00 ld [ %g3 ], %o2 } while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) { 4000bb70: 80 a6 c0 0a cmp %i3, %o2 4000bb74: 02 80 00 13 be 4000bbc0 <_User_extensions_Iterate+0x10c> 4000bb78: 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; 4000bb7c: d4 27 bf f8 st %o2, [ %fp + -8 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000bb80: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000bb84: 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 ); 4000bb88: 94 02 a0 14 add %o2, 0x14, %o2 4000bb8c: 92 10 00 18 mov %i0, %o1 4000bb90: 9f c6 40 00 call %i1 4000bb94: 90 10 00 1c mov %i4, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000bb98: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable_and_acquire( 4000bb9c: c4 07 bf f4 ld [ %fp + -12 ], %g2 if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) { 4000bba0: 80 a0 a0 00 cmp %g2, 0 4000bba4: 02 bf ff f2 be 4000bb6c <_User_extensions_Iterate+0xb8> 4000bba8: c6 07 bf f8 ld [ %fp + -8 ], %g3 4000bbac: d4 00 e0 04 ld [ %g3 + 4 ], %o2 while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) { 4000bbb0: 80 a6 c0 0a cmp %i3, %o2 4000bbb4: 32 bf ff f3 bne,a 4000bb80 <_User_extensions_Iterate+0xcc> 4000bbb8: d4 27 bf f8 st %o2, [ %fp + -8 ] _User_extensions_Acquire( &lock_context ); } if ( executing != NULL ) { 4000bbbc: 80 a7 20 00 cmp %i4, 0 4000bbc0: 02 80 00 03 be 4000bbcc <_User_extensions_Iterate+0x118> 4000bbc4: c4 07 bf fc ld [ %fp + -4 ], %g2 executing->last_user_extensions_iterator = iter.previous; 4000bbc8: c4 27 21 88 st %g2, [ %i4 + 0x188 ] <== NOT EXECUTED next = the_node->next; 4000bbcc: c6 07 bf ec ld [ %fp + -20 ], %g3 <== NOT EXECUTED previous = the_node->previous; 4000bbd0: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED next->previous = previous; 4000bbd4: c4 20 e0 04 st %g2, [ %g3 + 4 ] <== NOT EXECUTED previous->next = next; 4000bbd8: c6 20 80 00 st %g3, [ %g2 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000bbdc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000bbe0: 01 00 00 00 nop _Chain_Iterator_destroy( &iter.Iterator ); _User_extensions_Release( &lock_context ); if ( direction == CHAIN_ITERATOR_BACKWARD ) { 4000bbe4: 80 a6 a0 01 cmp %i2, 1 4000bbe8: 02 80 00 09 be 4000bc0c <_User_extensions_Iterate+0x158> 4000bbec: 80 a4 00 1d cmp %l0, %i5 while ( initial_current != initial_begin ) { --initial_current; (*visitor)( executing, arg, initial_current ); } } } 4000bbf0: 81 c7 e0 08 ret 4000bbf4: 81 e8 00 00 restore (*visitor)( executing, arg, initial_current ); 4000bbf8: 92 10 00 18 mov %i0, %o1 4000bbfc: 94 10 00 1d mov %i5, %o2 4000bc00: 9f c6 40 00 call %i1 4000bc04: 90 10 00 1c mov %i4, %o0 while ( initial_current != initial_begin ) { 4000bc08: 80 a4 00 1d cmp %l0, %i5 4000bc0c: 12 bf ff fb bne 4000bbf8 <_User_extensions_Iterate+0x144> 4000bc10: ba 07 7f dc add %i5, -36, %i5 } 4000bc14: 81 c7 e0 08 ret 4000bc18: 81 e8 00 00 restore end = _Chain_Immutable_head( &_User_extensions_List.Active ); 4000bc1c: 05 10 00 43 sethi %hi(0x40010c00), %g2 4000bc20: 84 10 a3 d8 or %g2, 0x3d8, %g2 ! 40010fd8 <_User_extensions_List> 4000bc24: 10 bf ff be b 4000bb1c <_User_extensions_Iterate+0x68> 4000bc28: b6 10 00 02 mov %g2, %i3 =============================================================================== 40015874 <_User_extensions_Remove_set>: __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40015874: 91 d0 20 09 ta 9 <== NOT EXECUTED iter_node = _Chain_Head( &the_registry->Iterators ); 40015878: 05 10 00 c7 sethi %hi(0x40031c00), %g2 <== NOT EXECUTED 4001587c: 84 10 a2 b0 or %g2, 0x2b0, %g2 ! 40031eb0 <_User_extensions_List+0xc> <== NOT EXECUTED 40015880: 88 00 a0 04 add %g2, 4, %g4 <== NOT EXECUTED 40015884: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) { 40015888: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED 4001588c: 22 80 00 11 be,a 400158d0 <_User_extensions_Remove_set+0x5c> <== NOT EXECUTED 40015890: c6 02 00 00 ld [ %o0 ], %g3 <== NOT EXECUTED if ( iter->position == the_node_to_extract ) { 40015894: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 <== NOT EXECUTED 40015898: 80 a2 00 03 cmp %o0, %g3 <== NOT EXECUTED 4001589c: 32 bf ff fb bne,a 40015888 <_User_extensions_Remove_set+0x14> <== NOT EXECUTED 400158a0: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED if ( iter->direction == CHAIN_ITERATOR_FORWARD ) { 400158a4: c6 00 a0 08 ld [ %g2 + 8 ], %g3 <== NOT EXECUTED 400158a8: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 400158ac: 32 80 00 1b bne,a 40015918 <_User_extensions_Remove_set+0xa4> <== NOT EXECUTED 400158b0: c6 02 00 00 ld [ %o0 ], %g3 <== NOT EXECUTED 400158b4: c6 02 20 04 ld [ %o0 + 4 ], %g3 <== NOT EXECUTED iter->position = _Chain_Previous( the_node_to_extract ); 400158b8: c6 20 a0 0c st %g3, [ %g2 + 0xc ] <== NOT EXECUTED 400158bc: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) { 400158c0: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED 400158c4: 32 bf ff f5 bne,a 40015898 <_User_extensions_Remove_set+0x24> <== NOT EXECUTED 400158c8: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 <== NOT EXECUTED next = the_node->next; 400158cc: c6 02 00 00 ld [ %o0 ], %g3 <== NOT EXECUTED previous = the_node->previous; 400158d0: c4 02 20 04 ld [ %o0 + 4 ], %g2 <== NOT EXECUTED next->previous = previous; 400158d4: c4 20 e0 04 st %g2, [ %g3 + 4 ] <== NOT EXECUTED previous->next = next; 400158d8: c6 20 80 00 st %g3, [ %g2 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400158dc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400158e0: 01 00 00 00 nop <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) { 400158e4: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 <== NOT EXECUTED 400158e8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400158ec: 02 80 00 09 be 40015910 <_User_extensions_Remove_set+0x9c> <== NOT EXECUTED 400158f0: 01 00 00 00 nop <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400158f4: 91 d0 20 09 ta 9 <== NOT EXECUTED next = the_node->next; 400158f8: c6 02 20 08 ld [ %o0 + 8 ], %g3 <== NOT EXECUTED previous = the_node->previous; 400158fc: c4 02 20 0c ld [ %o0 + 0xc ], %g2 <== NOT EXECUTED next->previous = previous; 40015900: c4 20 e0 04 st %g2, [ %g3 + 4 ] <== NOT EXECUTED previous->next = next; 40015904: c6 20 80 00 st %g3, [ %g2 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40015908: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4001590c: 01 00 00 00 nop <== NOT EXECUTED _Per_CPU_Acquire_all( level ); _Chain_Extract_unprotected( &the_extension->Switch.Node ); _Per_CPU_Release_all( level ); } } 40015910: 81 c3 e0 08 retl <== NOT EXECUTED 40015914: 01 00 00 00 nop <== NOT EXECUTED iter->position = _Chain_Next( the_node_to_extract ); 40015918: 10 bf ff db b 40015884 <_User_extensions_Remove_set+0x10> <== NOT EXECUTED 4001591c: c6 20 a0 0c st %g3, [ %g2 + 0xc ] <== NOT EXECUTED =============================================================================== 4000ba1c <_User_extensions_Thread_begin_visitor>: void _User_extensions_Thread_begin_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 4000ba1c: 9d e3 bf a0 save %sp, -96, %sp User_extensions_thread_begin_extension callout = callouts->thread_begin; 4000ba20: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1 if ( callout != NULL ) { 4000ba24: 80 a0 60 00 cmp %g1, 0 4000ba28: 02 80 00 04 be 4000ba38 <_User_extensions_Thread_begin_visitor+0x1c> <== ALWAYS TAKEN 4000ba2c: 01 00 00 00 nop (*callout)( executing ); 4000ba30: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000ba34: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED } } 4000ba38: 81 c7 e0 08 ret 4000ba3c: 81 e8 00 00 restore =============================================================================== 4000b974 <_User_extensions_Thread_create_visitor>: void _User_extensions_Thread_create_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 4000b974: 9d e3 bf a0 save %sp, -96, %sp User_extensions_thread_create_extension callout = callouts->thread_create; 4000b978: c4 06 80 00 ld [ %i2 ], %g2 if ( callout != NULL ) { 4000b97c: 80 a0 a0 00 cmp %g2, 0 4000b980: 02 80 00 0a be 4000b9a8 <_User_extensions_Thread_create_visitor+0x34> 4000b984: 01 00 00 00 nop User_extensions_Thread_create_context *ctx = arg; ctx->ok = ctx->ok && (*callout)( executing, ctx->created ); 4000b988: d0 0e 60 04 ldub [ %i1 + 4 ], %o0 4000b98c: 80 8a 20 ff btst 0xff, %o0 4000b990: 22 80 00 06 be,a 4000b9a8 <_User_extensions_Thread_create_visitor+0x34> <== NEVER TAKEN 4000b994: d0 2e 60 04 stb %o0, [ %i1 + 4 ] <== NOT EXECUTED 4000b998: d2 06 40 00 ld [ %i1 ], %o1 4000b99c: 9f c0 80 00 call %g2 4000b9a0: 90 10 00 18 mov %i0, %o0 4000b9a4: d0 2e 60 04 stb %o0, [ %i1 + 4 ] } } 4000b9a8: 81 c7 e0 08 ret 4000b9ac: 81 e8 00 00 restore =============================================================================== 4000b9b0 <_User_extensions_Thread_delete_visitor>: void _User_extensions_Thread_delete_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 4000b9b0: 9d e3 bf a0 save %sp, -96, %sp User_extensions_thread_delete_extension callout = callouts->thread_delete; 4000b9b4: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 if ( callout != NULL ) { 4000b9b8: 80 a0 60 00 cmp %g1, 0 4000b9bc: 02 80 00 04 be 4000b9cc <_User_extensions_Thread_delete_visitor+0x1c> <== ALWAYS TAKEN 4000b9c0: 92 10 00 19 mov %i1, %o1 (*callout)( executing, arg ); 4000b9c4: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000b9c8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED } } 4000b9cc: 81 c7 e0 08 ret 4000b9d0: 81 e8 00 00 restore =============================================================================== 4000ba40 <_User_extensions_Thread_exitted_visitor>: void _User_extensions_Thread_exitted_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 4000ba40: 9d e3 bf a0 save %sp, -96, %sp User_extensions_thread_exitted_extension callout = callouts->thread_exitted; 4000ba44: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1 if ( callout != NULL ) { 4000ba48: 80 a0 60 00 cmp %g1, 0 4000ba4c: 02 80 00 04 be 4000ba5c <_User_extensions_Thread_exitted_visitor+0x1c> <== ALWAYS TAKEN 4000ba50: 01 00 00 00 nop (*callout)( executing ); 4000ba54: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000ba58: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED } } 4000ba5c: 81 c7 e0 08 ret 4000ba60: 81 e8 00 00 restore =============================================================================== 4000b9f8 <_User_extensions_Thread_restart_visitor>: void _User_extensions_Thread_restart_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 4000b9f8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED User_extensions_thread_restart_extension callout = callouts->thread_restart; 4000b9fc: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED if ( callout != NULL ) { 4000ba00: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000ba04: 02 80 00 04 be 4000ba14 <_User_extensions_Thread_restart_visitor+0x1c> <== NOT EXECUTED 4000ba08: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED (*callout)( executing, arg ); 4000ba0c: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000ba10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED } } 4000ba14: 81 c7 e0 08 ret <== NOT EXECUTED 4000ba18: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000bca4 <_Watchdog_Do_tickle>: #ifdef RTEMS_SMP ISR_lock_Control *lock, #endif ISR_lock_Context *lock_context ) { 4000bca4: 9d e3 bf a0 save %sp, -96, %sp RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 4000bca8: ba 10 20 02 mov 2, %i5 do { if ( first->expire <= now ) { 4000bcac: c2 06 60 18 ld [ %i1 + 0x18 ], %g1 4000bcb0: 80 a0 40 1a cmp %g1, %i2 4000bcb4: 18 80 00 26 bgu 4000bd4c <_Watchdog_Do_tickle+0xa8> <== NEVER TAKEN 4000bcb8: 01 00 00 00 nop 4000bcbc: 22 80 00 21 be,a 4000bd40 <_Watchdog_Do_tickle+0x9c> <== ALWAYS TAKEN 4000bcc0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 4000bcc4: c4 06 60 04 ld [ %i1 + 4 ], %g2 <== NOT EXECUTED if ( node != NULL ) { 4000bcc8: 80 a0 a0 00 cmp %g2, 0 4000bccc: 32 80 00 05 bne,a 4000bce0 <_Watchdog_Do_tickle+0x3c> 4000bcd0: c2 00 80 00 ld [ %g2 ], %g1 4000bcd4: 10 80 00 19 b 4000bd38 <_Watchdog_Do_tickle+0x94> 4000bcd8: c2 06 60 08 ld [ %i1 + 8 ], %g1 4000bcdc: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED while ( ( left = _RBTree_Left( node ) ) != NULL ) { 4000bce0: 80 a0 60 00 cmp %g1, 0 4000bce4: 32 bf ff fe bne,a 4000bcdc <_Watchdog_Do_tickle+0x38> <== NEVER TAKEN 4000bce8: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED header->first = node; 4000bcec: 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 ); 4000bcf0: 92 10 00 19 mov %i1, %o1 4000bcf4: 7f ff f3 85 call 40008b08 <_RBTree_Extract> 4000bcf8: 90 10 00 18 mov %i0, %o0 _Watchdog_Set_state( first, WATCHDOG_INACTIVE ); routine = first->routine; 4000bcfc: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 <== NOT EXECUTED RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 4000bd00: fa 26 60 0c st %i5, [ %i1 + 0xc ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000bd04: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000bd08: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000bd0c: 01 00 00 00 nop _ISR_lock_Release_and_ISR_enable( lock, lock_context ); ( *routine )( first ); 4000bd10: 9f c0 80 00 call %g2 4000bd14: 90 10 00 19 mov %i1, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000bd18: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable_and_acquire( lock, lock_context ); 4000bd1c: c2 27 00 00 st %g1, [ %i4 ] 4000bd20: f2 06 20 04 ld [ %i0 + 4 ], %i1 } else { break; } first = _Watchdog_Header_first( header ); } while ( first != NULL ); 4000bd24: 80 a6 60 00 cmp %i1, 0 4000bd28: 32 bf ff e2 bne,a 4000bcb0 <_Watchdog_Do_tickle+0xc> 4000bd2c: c2 06 60 18 ld [ %i1 + 0x18 ], %g1 } 4000bd30: 81 c7 e0 08 ret 4000bd34: 81 e8 00 00 restore header->first = _RBTree_Parent( &the_watchdog->Node.RBTree ); 4000bd38: 10 bf ff ee b 4000bcf0 <_Watchdog_Do_tickle+0x4c> 4000bd3c: c2 26 20 04 st %g1, [ %i0 + 4 ] if ( first->expire <= now ) { 4000bd40: 80 a0 40 1b cmp %g1, %i3 4000bd44: 28 bf ff e1 bleu,a 4000bcc8 <_Watchdog_Do_tickle+0x24> 4000bd48: c4 06 60 04 ld [ %i1 + 4 ], %g2 } 4000bd4c: 81 c7 e0 08 ret 4000bd50: 81 e8 00 00 restore =============================================================================== 40015920 <_Watchdog_Insert>: _Assert( _Watchdog_Get_state( the_watchdog ) == WATCHDOG_INACTIVE ); link = _RBTree_Root_reference( &header->Watchdogs ); parent = NULL; old_first = header->first; 40015920: d8 02 20 04 ld [ %o0 + 4 ], %o4 new_first = &the_watchdog->Node.RBTree; the_watchdog->expire = expire; 40015924: d4 22 60 18 st %o2, [ %o1 + 0x18 ] link = _RBTree_Root_reference( &header->Watchdogs ); 40015928: 84 10 00 08 mov %o0, %g2 the_watchdog->expire = expire; 4001592c: d6 22 60 1c st %o3, [ %o1 + 0x1c ] { 40015930: 86 10 00 09 mov %o1, %g3 while ( *link != NULL ) { 40015934: c2 00 80 00 ld [ %g2 ], %g1 new_first = &the_watchdog->Node.RBTree; 40015938: 9a 10 00 09 mov %o1, %o5 while ( *link != NULL ) { 4001593c: 80 a0 60 00 cmp %g1, 0 40015940: 02 80 00 12 be 40015988 <_Watchdog_Insert+0x68> 40015944: 88 10 20 00 clr %g4 Watchdog_Control *parent_watchdog; parent = *link; parent_watchdog = (Watchdog_Control *) parent; if ( expire < parent_watchdog->expire ) { 40015948: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 4001594c: 80 a0 80 0a cmp %g2, %o2 40015950: 18 80 00 09 bgu 40015974 <_Watchdog_Insert+0x54> <== NEVER TAKEN 40015954: 84 10 00 01 mov %g1, %g2 40015958: 12 80 00 17 bne 400159b4 <_Watchdog_Insert+0x94> <== NEVER TAKEN 4001595c: 84 00 60 04 add %g1, 4, %g2 40015960: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 40015964: 80 a0 80 0b cmp %g2, %o3 40015968: 08 80 00 13 bleu 400159b4 <_Watchdog_Insert+0x94> 4001596c: 84 00 60 04 add %g1, 4, %g2 return &RB_LEFT( the_node, Node ); 40015970: 84 10 00 01 mov %g1, %g2 link = _RBTree_Left_reference( parent ); } else { link = _RBTree_Right_reference( parent ); new_first = old_first; 40015974: 88 10 00 01 mov %g1, %g4 while ( *link != NULL ) { 40015978: c2 00 80 00 ld [ %g2 ], %g1 4001597c: 80 a0 60 00 cmp %g1, 0 40015980: 32 bf ff f3 bne,a 4001594c <_Watchdog_Insert+0x2c> 40015984: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 } } header->first = new_first; 40015988: da 22 20 04 st %o5, [ %o0 + 4 ] RB_SET( child, parent, Node ); 4001598c: 82 10 20 01 mov 1, %g1 40015990: 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 ); 40015994: 92 10 00 03 mov %g3, %o1 40015998: c0 20 e0 04 clr [ %g3 + 4 ] 4001599c: c0 20 c0 00 clr [ %g3 ] 400159a0: c2 20 e0 0c st %g1, [ %g3 + 0xc ] *link = child; 400159a4: c6 20 80 00 st %g3, [ %g2 ] 400159a8: 82 13 c0 00 mov %o7, %g1 400159ac: 7f ff f1 7d call 40011fa0 <_RBTree_Insert_color> 400159b0: 9e 10 40 00 mov %g1, %o7 new_first = old_first; 400159b4: 9a 10 00 0c mov %o4, %o5 400159b8: 10 bf ff f0 b 40015978 <_Watchdog_Insert+0x58> 400159bc: 88 10 00 01 mov %g1, %g4 =============================================================================== 4000bc2c <_Watchdog_Remove>: void _Watchdog_Remove( Watchdog_Header *header, Watchdog_Control *the_watchdog ) { 4000bc2c: 9d e3 bf a0 save %sp, -96, %sp if ( _Watchdog_Is_scheduled( the_watchdog ) ) { 4000bc30: c2 06 60 0c ld [ %i1 + 0xc ], %g1 4000bc34: 80 a0 60 01 cmp %g1, 1 4000bc38: 28 80 00 04 bleu,a 4000bc48 <_Watchdog_Remove+0x1c> 4000bc3c: c2 06 20 04 ld [ %i0 + 4 ], %g1 } _RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree ); _Watchdog_Set_state( the_watchdog, WATCHDOG_INACTIVE ); } } 4000bc40: 81 c7 e0 08 ret 4000bc44: 81 e8 00 00 restore if ( header->first == &the_watchdog->Node.RBTree ) { 4000bc48: 80 a0 40 19 cmp %g1, %i1 4000bc4c: 22 80 00 09 be,a 4000bc70 <_Watchdog_Remove+0x44> 4000bc50: c4 06 60 04 ld [ %i1 + 4 ], %g2 _RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree ); 4000bc54: 92 10 00 19 mov %i1, %o1 4000bc58: 7f ff f3 ac call 40008b08 <_RBTree_Extract> 4000bc5c: 90 10 00 18 mov %i0, %o0 RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 4000bc60: 82 10 20 02 mov 2, %g1 4000bc64: c2 26 60 0c st %g1, [ %i1 + 0xc ] } 4000bc68: 81 c7 e0 08 ret 4000bc6c: 81 e8 00 00 restore if ( node != NULL ) { 4000bc70: 80 a0 a0 00 cmp %g2, 0 4000bc74: 32 80 00 05 bne,a 4000bc88 <_Watchdog_Remove+0x5c> <== NEVER TAKEN 4000bc78: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED 4000bc7c: 10 80 00 08 b 4000bc9c <_Watchdog_Remove+0x70> 4000bc80: c2 06 60 08 ld [ %i1 + 8 ], %g1 4000bc84: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED while ( ( left = _RBTree_Left( node ) ) != NULL ) { 4000bc88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000bc8c: 32 bf ff fe bne,a 4000bc84 <_Watchdog_Remove+0x58> <== NOT EXECUTED 4000bc90: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED header->first = node; 4000bc94: 10 bf ff f0 b 4000bc54 <_Watchdog_Remove+0x28> <== NOT EXECUTED 4000bc98: c4 26 20 04 st %g2, [ %i0 + 4 ] <== NOT EXECUTED header->first = _RBTree_Parent( &the_watchdog->Node.RBTree ); 4000bc9c: 10 bf ff ee b 4000bc54 <_Watchdog_Remove+0x28> 4000bca0: c2 26 20 04 st %g1, [ %i0 + 4 ] =============================================================================== 4000bd54 <_Watchdog_Tick>: void _Watchdog_Tick( Per_CPU_Control *cpu ) { 4000bd54: 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; 4000bd58: 05 10 00 4a sethi %hi(0x40012800), %g2 <== NOT EXECUTED 4000bd5c: c2 00 a2 5c ld [ %g2 + 0x25c ], %g1 ! 40012a5c <_Watchdog_Ticks_since_boot> <== NOT EXECUTED 4000bd60: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000bd64: c2 20 a2 5c st %g1, [ %g2 + 0x25c ] <== NOT EXECUTED 4000bd68: 91 d0 20 09 ta 9 <== NOT EXECUTED } _ISR_lock_ISR_disable_and_acquire( &cpu->Watchdog.Lock, &lock_context ); 4000bd6c: c2 27 bf ec st %g1, [ %fp + -20 ] ticks = cpu->Watchdog.ticks; 4000bd70: c4 1e 20 30 ldd [ %i0 + 0x30 ], %g2 _Assert( ticks < UINT64_MAX ); ++ticks; 4000bd74: 96 80 e0 01 addcc %g3, 1, %o3 4000bd78: 94 40 a0 00 addx %g2, 0, %o2 cpu->Watchdog.ticks = ticks; 4000bd7c: d4 3e 20 30 std %o2, [ %i0 + 0x30 ] 4000bd80: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ]; first = _Watchdog_Header_first( header ); if ( first != NULL ) { 4000bd84: 80 a2 60 00 cmp %o1, 0 4000bd88: 02 80 00 04 be 4000bd98 <_Watchdog_Tick+0x44> 4000bd8c: 98 07 bf ec add %fp, -20, %o4 _Watchdog_Tickle( 4000bd90: 7f ff ff c5 call 4000bca4 <_Watchdog_Do_tickle> 4000bd94: 90 06 20 38 add %i0, 0x38, %o0 4000bd98: fa 06 20 4c ld [ %i0 + 0x4c ], %i5 } header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_MONOTONIC ]; first = _Watchdog_Header_first( header ); if ( first != NULL ) { 4000bd9c: 80 a7 60 00 cmp %i5, 0 4000bda0: 22 80 00 11 be,a 4000bde4 <_Watchdog_Tick+0x90> 4000bda4: fa 06 20 44 ld [ %i0 + 0x44 ], %i5 _Timecounter_Getnanouptime( &now ); 4000bda8: 7f ff f0 cd call 400080dc <_Timecounter_Getnanouptime> 4000bdac: 90 07 bf f0 add %fp, -16, %o0 ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS; 4000bdb0: c2 07 bf f0 ld [ %fp + -16 ], %g1 ticks = (uint64_t) ts->tv_sec; 4000bdb4: d6 07 bf f4 ld [ %fp + -12 ], %o3 ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS; 4000bdb8: 83 28 60 1e sll %g1, 0x1e, %g1 4000bdbc: 95 32 e0 02 srl %o3, 2, %o2 _Watchdog_Tickle( 4000bdc0: 94 12 80 01 or %o2, %g1, %o2 4000bdc4: c2 07 bf f8 ld [ %fp + -8 ], %g1 4000bdc8: 97 2a e0 1e sll %o3, 0x1e, %o3 4000bdcc: 98 07 bf ec add %fp, -20, %o4 4000bdd0: 96 10 40 0b or %g1, %o3, %o3 4000bdd4: 92 10 00 1d mov %i5, %o1 4000bdd8: 7f ff ff b3 call 4000bca4 <_Watchdog_Do_tickle> 4000bddc: 90 06 20 48 add %i0, 0x48, %o0 4000bde0: fa 06 20 44 ld [ %i0 + 0x44 ], %i5 } header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_REALTIME ]; first = _Watchdog_Header_first( header ); if ( first != NULL ) { 4000bde4: 80 a7 60 00 cmp %i5, 0 4000bde8: 02 80 00 10 be 4000be28 <_Watchdog_Tick+0xd4> <== ALWAYS TAKEN 4000bdec: 01 00 00 00 nop _Timecounter_Getnanotime( &now ); 4000bdf0: 7f ff f0 e1 call 40008174 <_Timecounter_Getnanotime> <== NOT EXECUTED 4000bdf4: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED 4000bdf8: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED ticks = (uint64_t) ts->tv_sec; 4000bdfc: d6 07 bf f4 ld [ %fp + -12 ], %o3 <== NOT EXECUTED ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS; 4000be00: 83 28 60 1e sll %g1, 0x1e, %g1 <== NOT EXECUTED 4000be04: 95 32 e0 02 srl %o3, 2, %o2 <== NOT EXECUTED _Watchdog_Tickle( 4000be08: 94 12 80 01 or %o2, %g1, %o2 <== NOT EXECUTED 4000be0c: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== NOT EXECUTED 4000be10: 97 2a e0 1e sll %o3, 0x1e, %o3 <== NOT EXECUTED 4000be14: 98 07 bf ec add %fp, -20, %o4 <== NOT EXECUTED 4000be18: 96 10 40 0b or %g1, %o3, %o3 <== NOT EXECUTED 4000be1c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4000be20: 7f ff ff a1 call 4000bca4 <_Watchdog_Do_tickle> <== NOT EXECUTED 4000be24: 90 06 20 40 add %i0, 0x40, %o0 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000be28: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000be2c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000be30: 01 00 00 00 nop Thread_Control *executing = cpu->executing; 4000be34: d2 06 20 20 ld [ %i0 + 0x20 ], %o1 if ( scheduler != NULL && executing != NULL ) { 4000be38: 80 a2 60 00 cmp %o1, 0 4000be3c: 02 80 00 06 be 4000be54 <_Watchdog_Tick+0x100> <== NEVER TAKEN 4000be40: 11 10 00 3f sethi %hi(0x4000fc00), %o0 ( *scheduler->Operations.tick )( scheduler, executing ); 4000be44: 90 12 23 78 or %o0, 0x378, %o0 ! 4000ff78 <_Scheduler_Table> 4000be48: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 4000be4c: 9f c0 40 00 call %g1 4000be50: 01 00 00 00 nop } _ISR_lock_Release_and_ISR_enable( &cpu->Watchdog.Lock, &lock_context ); _Scheduler_Tick( cpu ); } 4000be54: 81 c7 e0 08 ret 4000be58: 81 e8 00 00 restore =============================================================================== 4000c038 <_Workspace_Allocate_aligned>: return _Heap_Allocate_aligned_with_boundary( heap, size, alignment, 0 ); 4000c038: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED 4000c03c: 96 10 20 00 clr %o3 <== NOT EXECUTED 4000c040: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED 4000c044: 11 10 00 4a sethi %hi(0x40012800), %o0 <== NOT EXECUTED 4000c048: 90 12 22 60 or %o0, 0x260, %o0 ! 40012a60 <_Workspace_Area> <== NOT EXECUTED 4000c04c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4000c050: 7f ff eb 23 call 40006cdc <_Heap_Allocate_aligned_with_boundary> <== NOT EXECUTED 4000c054: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 4000c070 <_Workspace_Allocate_or_fatal_error>: } void *_Workspace_Allocate_or_fatal_error( size_t size ) { 4000c070: 9d e3 bf a0 save %sp, -96, %sp return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 4000c074: 96 10 20 00 clr %o3 4000c078: 94 10 20 00 clr %o2 4000c07c: 92 10 00 18 mov %i0, %o1 4000c080: 11 10 00 4a sethi %hi(0x40012800), %o0 4000c084: 7f ff eb 16 call 40006cdc <_Heap_Allocate_aligned_with_boundary> 4000c088: 90 12 22 60 or %o0, 0x260, %o0 ! 40012a60 <_Workspace_Area> __builtin_return_address( 1 ), memory ); #endif if ( memory == NULL ) 4000c08c: 80 a2 20 00 cmp %o0, 0 4000c090: 02 80 00 04 be 4000c0a0 <_Workspace_Allocate_or_fatal_error+0x30> <== NEVER TAKEN 4000c094: b0 10 00 08 mov %o0, %i0 _Internal_error( INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 4000c098: 81 c7 e0 08 ret 4000c09c: 81 e8 00 00 restore _Internal_error( INTERNAL_ERROR_WORKSPACE_ALLOCATION ); 4000c0a0: 7f ff eb b2 call 40006f68 <_Internal_error> <== NOT EXECUTED 4000c0a4: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED 4000c0a8: 01 00 00 00 nop <== NOT EXECUTED ... =============================================================================== 4000be5c <_Workspace_Handler_initialization>: void _Workspace_Handler_initialization( Heap_Area *areas, size_t area_count, Heap_Initialization_or_extend_handler extend ) { 4000be5c: 9d e3 bf 98 save %sp, -104, %sp Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize; uintptr_t remaining = rtems_configuration_get_work_space_size(); 4000be60: 03 10 00 3f sethi %hi(0x4000fc00), %g1 4000be64: 86 10 62 94 or %g1, 0x294, %g3 ! 4000fe94 4000be68: c4 08 e0 36 ldub [ %g3 + 0x36 ], %g2 4000be6c: 80 a0 a0 00 cmp %g2, 0 4000be70: 12 80 00 04 bne 4000be80 <_Workspace_Handler_initialization+0x24> <== NEVER TAKEN 4000be74: f8 00 62 94 ld [ %g1 + 0x294 ], %i4 4000be78: c2 00 e0 04 ld [ %g3 + 4 ], %g1 4000be7c: b8 07 00 01 add %i4, %g1, %i4 bool do_zero = rtems_configuration_get_do_zero_of_workspace(); 4000be80: c8 08 e0 34 ldub [ %g3 + 0x34 ], %g4 bool unified = rtems_configuration_get_unified_work_area(); 4000be84: c6 08 e0 35 ldub [ %g3 + 0x35 ], %g3 bool do_zero = rtems_configuration_get_do_zero_of_workspace(); 4000be88: c8 2f bf ff stb %g4, [ %fp + -1 ] return (uintptr_t) _TLS_BSS_end - (uintptr_t) _TLS_Data_begin; 4000be8c: 03 10 00 43 sethi %hi(0x40010c00), %g1 4000be90: 82 10 61 b0 or %g1, 0x1b0, %g1 ! 40010db0 <_Linker_set__Sysinit_bsp_work_area_initialize> 4000be94: 05 10 00 43 sethi %hi(0x40010c00), %g2 4000be98: 84 10 a1 b0 or %g2, 0x1b0, %g2 ! 40010db0 <_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 ) { 4000be9c: 82 a0 40 02 subcc %g1, %g2, %g1 4000bea0: 02 80 00 1b be 4000bf0c <_Workspace_Handler_initialization+0xb0> <== ALWAYS TAKEN 4000bea4: c6 2f bf fe stb %g3, [ %fp + -2 ] return (val + msk) & ~msk; 4000bea8: 05 00 00 00 sethi %hi(0), %g2 <== NOT EXECUTED 4000beac: 84 10 a0 01 or %g2, 1, %g2 ! 1 <_TLS_Alignment> <== NOT EXECUTED 4000beb0: 84 00 a0 07 add %g2, 7, %g2 <== NOT EXECUTED 4000beb4: 84 08 bf f8 and %g2, -8, %g2 <== NOT EXECUTED sizeof(TLS_Thread_control_block) : alignment; 4000beb8: 80 a0 a0 08 cmp %g2, 8 <== NOT EXECUTED 4000bebc: 2a 80 00 02 bcs,a 4000bec4 <_Workspace_Handler_initialization+0x68> <== NOT EXECUTED 4000bec0: 84 10 20 08 mov 8, %g2 <== NOT EXECUTED thread_count += rtems_resource_maximum_per_allocation( 4000bec4: 09 10 00 44 sethi %hi(0x40011000), %g4 <== NOT EXECUTED if ( page_size < alignment ) { page_size = alignment; } return HEAP_BLOCK_HEADER_SIZE + page_size - 1 + size; 4000bec8: 85 28 a0 01 sll %g2, 1, %g2 <== NOT EXECUTED 4000becc: fa 01 22 a0 ld [ %g4 + 0x2a0 ], %i5 <== NOT EXECUTED 4000bed0: 07 10 00 43 sethi %hi(0x40010c00), %g3 <== NOT EXECUTED 4000bed4: c6 00 e2 04 ld [ %g3 + 0x204 ], %g3 ! 40010e04 <== NOT EXECUTED return (val + msk) & ~msk; 4000bed8: 82 00 60 07 add %g1, 7, %g1 <== NOT EXECUTED 4000bedc: 09 00 00 3f sethi %hi(0xfc00), %g4 <== NOT EXECUTED 4000bee0: 82 08 7f f8 and %g1, -8, %g1 <== NOT EXECUTED 4000bee4: 88 11 23 ff or %g4, 0x3ff, %g4 <== NOT EXECUTED 4000bee8: 82 00 60 0f add %g1, 0xf, %g1 <== NOT EXECUTED 4000beec: 86 08 c0 04 and %g3, %g4, %g3 <== NOT EXECUTED 4000bef0: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED 4000bef4: 84 0f 40 04 and %i5, %g4, %g2 <== NOT EXECUTED 4000bef8: 84 00 c0 02 add %g3, %g2, %g2 <== NOT EXECUTED 4000befc: 84 00 a0 01 inc %g2 <== NOT EXECUTED * size. */ remaining += _Heap_Min_block_size( page_size ); remaining += _Get_maximum_thread_count() * _Heap_Size_with_overhead( page_size, tls_alloc, tls_align ); 4000bf00: 82 58 40 02 smul %g1, %g2, %g1 <== NOT EXECUTED remaining += _Get_maximum_thread_count() 4000bf04: 82 00 60 10 add %g1, 0x10, %g1 <== NOT EXECUTED 4000bf08: b8 07 00 01 add %i4, %g1, %i4 <== NOT EXECUTED } for (i = 0; i < area_count; ++i) { 4000bf0c: 80 a6 60 00 cmp %i1, 0 4000bf10: 02 80 00 2d be 4000bfc4 <_Workspace_Handler_initialization+0x168> <== NEVER TAKEN 4000bf14: 80 a7 20 00 cmp %i4, 0 4000bf18: f6 0f bf ff ldub [ %fp + -1 ], %i3 if ( area->size > overhead ) { uintptr_t space_available; uintptr_t size; if ( unified ) { 4000bf1c: e2 0f bf fe ldub [ %fp + -2 ], %l1 4000bf20: b3 2e 60 03 sll %i1, 3, %i1 for (i = 0; i < area_count; ++i) { 4000bf24: 21 10 00 1a sethi %hi(0x40006800), %l0 } else { size = 0; } } space_available = (*init_or_extend)( 4000bf28: 25 10 00 4a sethi %hi(0x40012800), %l2 4000bf2c: b2 06 00 19 add %i0, %i1, %i1 for (i = 0; i < area_count; ++i) { 4000bf30: a0 14 22 04 or %l0, 0x204, %l0 space_available = (*init_or_extend)( 4000bf34: a4 14 a2 60 or %l2, 0x260, %l2 if ( do_zero ) { 4000bf38: 80 a6 e0 00 cmp %i3, 0 4000bf3c: 12 80 00 26 bne 4000bfd4 <_Workspace_Handler_initialization+0x178> 4000bf40: fa 06 20 04 ld [ %i0 + 4 ], %i5 if ( area->size > overhead ) { 4000bf44: 80 a7 60 16 cmp %i5, 0x16 4000bf48: 28 80 00 1b bleu,a 4000bfb4 <_Workspace_Handler_initialization+0x158> <== NEVER TAKEN 4000bf4c: b0 06 20 08 add %i0, 8, %i0 <== NOT EXECUTED if ( unified ) { 4000bf50: 80 a4 60 00 cmp %l1, 0 4000bf54: 12 80 00 09 bne 4000bf78 <_Workspace_Handler_initialization+0x11c> 4000bf58: d2 06 00 00 ld [ %i0 ], %o1 if ( remaining > 0 ) { 4000bf5c: 80 a7 20 00 cmp %i4, 0 4000bf60: 02 80 00 23 be 4000bfec <_Workspace_Handler_initialization+0x190> <== NEVER TAKEN 4000bf64: 96 10 20 08 mov 8, %o3 size = remaining < area->size - overhead ? 4000bf68: 82 07 7f ea add %i5, -22, %g1 remaining + overhead : area->size; 4000bf6c: 80 a0 40 1c cmp %g1, %i4 4000bf70: 38 80 00 02 bgu,a 4000bf78 <_Workspace_Handler_initialization+0x11c> <== ALWAYS TAKEN 4000bf74: ba 07 20 16 add %i4, 0x16, %i5 space_available = (*init_or_extend)( 4000bf78: 94 10 00 1d mov %i5, %o2 4000bf7c: 96 10 20 08 mov 8, %o3 4000bf80: 9f c4 00 00 call %l0 4000bf84: 90 10 00 12 mov %l2, %o0 area->begin, size, page_size ); area->begin = (char *) area->begin + size; 4000bf88: c4 06 00 00 ld [ %i0 ], %g2 area->size -= size; 4000bf8c: c2 06 20 04 ld [ %i0 + 4 ], %g1 area->begin = (char *) area->begin + size; 4000bf90: 84 00 80 1d add %g2, %i5, %g2 area->size -= size; 4000bf94: ba 20 40 1d sub %g1, %i5, %i5 area->begin = (char *) area->begin + size; 4000bf98: c4 26 00 00 st %g2, [ %i0 ] if ( space_available < remaining ) { 4000bf9c: 80 a2 00 1c cmp %o0, %i4 4000bfa0: 1a 80 00 18 bcc 4000c000 <_Workspace_Handler_initialization+0x1a4> <== ALWAYS TAKEN 4000bfa4: fa 26 20 04 st %i5, [ %i0 + 4 ] remaining -= space_available; 4000bfa8: b8 27 00 08 sub %i4, %o0, %i4 <== NOT EXECUTED } else { remaining = 0; } init_or_extend = extend; 4000bfac: a0 10 00 1a mov %i2, %l0 <== NOT EXECUTED 4000bfb0: b0 06 20 08 add %i0, 8, %i0 for (i = 0; i < area_count; ++i) { 4000bfb4: 80 a6 40 18 cmp %i1, %i0 4000bfb8: 12 bf ff e1 bne 4000bf3c <_Workspace_Handler_initialization+0xe0> <== NEVER TAKEN 4000bfbc: 80 a6 e0 00 cmp %i3, 0 } } if ( remaining > 0 ) { 4000bfc0: 80 a7 20 00 cmp %i4, 0 4000bfc4: 12 80 00 12 bne 4000c00c <_Workspace_Handler_initialization+0x1b0> <== NEVER TAKEN 4000bfc8: 01 00 00 00 nop _Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } _Heap_Protection_set_delayed_free_fraction( &_Workspace_Area, 1 ); } 4000bfcc: 81 c7 e0 08 ret 4000bfd0: 81 e8 00 00 restore memset( area->begin, 0, area->size ); 4000bfd4: d0 06 00 00 ld [ %i0 ], %o0 4000bfd8: 94 10 00 1d mov %i5, %o2 4000bfdc: 40 00 09 85 call 4000e5f0 4000bfe0: 92 10 20 00 clr %o1 4000bfe4: 10 bf ff d8 b 4000bf44 <_Workspace_Handler_initialization+0xe8> 4000bfe8: fa 06 20 04 ld [ %i0 + 4 ], %i5 space_available = (*init_or_extend)( 4000bfec: 94 10 20 00 clr %o2 <== NOT EXECUTED 4000bff0: 9f c4 00 00 call %l0 <== NOT EXECUTED 4000bff4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED init_or_extend = extend; 4000bff8: 10 bf ff ee b 4000bfb0 <_Workspace_Handler_initialization+0x154> <== NOT EXECUTED 4000bffc: a0 10 00 1a mov %i2, %l0 <== NOT EXECUTED 4000c000: a0 10 00 1a mov %i2, %l0 remaining = 0; 4000c004: 10 bf ff eb b 4000bfb0 <_Workspace_Handler_initialization+0x154> 4000c008: b8 10 20 00 clr %i4 _Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); 4000c00c: 7f ff eb d7 call 40006f68 <_Internal_error> <== NOT EXECUTED 4000c010: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED 4000c014: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 400438dc : } rtems_status_code rtems_clock_get_tod( rtems_time_of_day *time_buffer ) { 400438dc: 9d e3 bf 90 save %sp, -112, %sp uint32_t day_secs; uint32_t year; uint32_t year_days; uint32_t leap_years; if ( !time_buffer ) 400438e0: b8 96 20 00 orcc %i0, 0, %i4 400438e4: 02 80 00 95 be 40043b38 <== NEVER TAKEN 400438e8: 03 10 02 40 sethi %hi(0x40090000), %g1 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set() ) 400438ec: c2 08 63 e4 ldub [ %g1 + 0x3e4 ], %g1 ! 400903e4 <_TOD> 400438f0: 80 a0 60 00 cmp %g1, 0 400438f4: 02 80 00 3f be 400439f0 <== NEVER TAKEN 400438f8: b0 10 20 0b mov 0xb, %i0 _Timecounter_Microtime( time ); 400438fc: 7f ff 60 0d call 4001b930 <_Timecounter_Microtime> 40043900: 90 07 bf f0 add %fp, -16, %o0 /* Obtain the current time */ _TOD_Get_timeval( &now ); /* How many days and how many seconds in the day ? */ days = now.tv_sec / RTEMS_SECS_PER_DAY; 40043904: f4 1f bf f0 ldd [ %fp + -16 ], %i2 40043908: 94 10 20 00 clr %o2 4004390c: 90 10 00 1a mov %i2, %o0 40043910: 92 10 00 1b mov %i3, %o1 40043914: 17 00 00 54 sethi %hi(0x15000), %o3 40043918: 40 00 d7 b1 call 400797dc <__divdi3> 4004391c: 96 12 e1 80 or %o3, 0x180, %o3 ! 15180 day_secs = now.tv_sec % RTEMS_SECS_PER_DAY; 40043920: 90 10 00 1a mov %i2, %o0 days = now.tv_sec / RTEMS_SECS_PER_DAY; 40043924: ba 10 00 09 mov %o1, %i5 day_secs = now.tv_sec % RTEMS_SECS_PER_DAY; 40043928: 94 10 20 00 clr %o2 4004392c: 92 10 00 1b mov %i3, %o1 40043930: 17 00 00 54 sethi %hi(0x15000), %o3 40043934: 40 00 d8 35 call 40079a08 <__moddi3> 40043938: 96 12 e1 80 or %o3, 0x180, %o3 ! 15180 /* How many non-leap year years ? */ year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE; 4004393c: 03 19 c6 7c sethi %hi(0x6719f000), %g1 40043940: 82 10 63 61 or %g1, 0x361, %g1 ! 6719f361 40043944: 80 57 40 01 umul %i5, %g1, %g0 40043948: 89 40 00 00 rd %y, %g4 4004394c: 84 27 40 04 sub %i5, %g4, %g2 40043950: 85 30 a0 01 srl %g2, 1, %g2 40043954: 88 01 00 02 add %g4, %g2, %g4 return (year / 4) - (year / 100) + (year / 400); 40043958: 05 14 7a e1 sethi %hi(0x51eb8400), %g2 year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE; 4004395c: 89 31 20 08 srl %g4, 8, %g4 return (year / 4) - (year / 100) + (year / 400); 40043960: 84 10 a1 1f or %g2, 0x11f, %g2 year -= 1; 40043964: b6 01 27 b1 add %g4, 0x7b1, %i3 return (year / 4) - (year / 100) + (year / 400); 40043968: 80 56 c0 02 umul %i3, %g2, %g0 4004396c: 85 40 00 00 rd %y, %g2 40043970: 87 36 e0 02 srl %i3, 2, %g3 40043974: b1 30 a0 07 srl %g2, 7, %i0 40043978: 85 30 a0 05 srl %g2, 5, %g2 return _Leap_years_before( to ) - _Leap_years_before( from + 1 ); 4004397c: 86 00 c0 18 add %g3, %i0, %g3 40043980: 86 00 fe 23 add %g3, -477, %g3 40043984: 86 20 c0 02 sub %g3, %g2, %g3 /* Determine the number of leap years. */ leap_years = _Leap_years_between( RTEMS_YEAR_BASE, year ); /* Adjust the remaining number of days based on the leap years. */ year_days = ( days - leap_years ) % RTEMS_DAYS_PER_YEAR; 40043988: b4 27 40 03 sub %i5, %g3, %i2 4004398c: 80 56 80 01 umul %i2, %g1, %g0 40043990: 83 40 00 00 rd %y, %g1 40043994: b2 26 80 01 sub %i2, %g1, %i1 40043998: b3 36 60 01 srl %i1, 1, %i1 4004399c: 82 00 40 19 add %g1, %i1, %g1 /* Adjust the year and days in the year if in the leap year overflow. */ if ( leap_years > ( days % RTEMS_DAYS_PER_YEAR ) ) { 400439a0: b2 59 21 6d smul %g4, 0x16d, %i1 year_days = ( days - leap_years ) % RTEMS_DAYS_PER_YEAR; 400439a4: 83 30 60 08 srl %g1, 8, %g1 if ( leap_years > ( days % RTEMS_DAYS_PER_YEAR ) ) { 400439a8: ba 27 40 19 sub %i5, %i1, %i5 year_days = ( days - leap_years ) % RTEMS_DAYS_PER_YEAR; 400439ac: 82 58 61 6d smul %g1, 0x16d, %g1 if ( leap_years > ( days % RTEMS_DAYS_PER_YEAR ) ) { 400439b0: 80 a7 40 03 cmp %i5, %g3 400439b4: 1a 80 00 11 bcc 400439f8 <== NEVER TAKEN 400439b8: 82 26 80 01 sub %i2, %g1, %g1 return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0); 400439bc: 86 8e e0 03 andcc %i3, 3, %g3 400439c0: 32 80 00 57 bne,a 40043b1c <== NEVER TAKEN 400439c4: b0 5e 21 90 smul %i0, 0x190, %i0 <== NOT EXECUTED 400439c8: 88 58 a0 64 smul %g2, 0x64, %g4 400439cc: 80 a6 c0 04 cmp %i3, %g4 400439d0: 32 80 00 0c bne,a 40043a00 <== ALWAYS TAKEN 400439d4: 82 00 60 01 inc %g1 400439d8: b0 5e 21 90 smul %i0, 0x190, %i0 <== NOT EXECUTED 400439dc: 80 a6 c0 18 cmp %i3, %i0 <== NOT EXECUTED 400439e0: 22 80 00 08 be,a 40043a00 <== NOT EXECUTED 400439e4: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( _Leap_year( year ) ) { year_days += 1; } } time_buffer->year = year; 400439e8: 10 80 00 0e b 40043a20 <== NOT EXECUTED 400439ec: f6 27 00 00 st %i3, [ %i4 ] <== NOT EXECUTED time_buffer->minute = time_buffer->minute / RTEMS_SECS_PER_MINUTE; time_buffer->ticks = now.tv_usec / rtems_configuration_get_microseconds_per_tick( ); return RTEMS_SUCCESSFUL; } 400439f0: 81 c7 e0 08 ret <== NOT EXECUTED 400439f4: 81 e8 00 00 restore <== NOT EXECUTED year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE; 400439f8: b6 01 27 b2 add %g4, 0x7b2, %i3 <== NOT EXECUTED 400439fc: 86 0e e0 03 and %i3, 3, %g3 <== NOT EXECUTED return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0); 40043a00: 80 a0 e0 00 cmp %g3, 0 40043a04: 12 80 00 3a bne 40043aec <== NEVER TAKEN 40043a08: f6 27 00 00 st %i3, [ %i4 ] 40043a0c: 81 80 20 00 wr %g0, %y 40043a10: 01 00 00 00 nop 40043a14: 01 00 00 00 nop 40043a18: 01 00 00 00 nop 40043a1c: 84 76 e0 64 udiv %i3, 0x64, %g2 40043a20: 84 58 a0 64 smul %g2, 0x64, %g2 40043a24: 80 a6 c0 02 cmp %i3, %g2 40043a28: 02 80 00 32 be 40043af0 <== NEVER TAKEN 40043a2c: 05 14 7a e1 sethi %hi(0x51eb8400), %g2 days_to_date = _TOD_Days_to_date[1]; 40043a30: 3b 10 02 0e sethi %hi(0x40083800), %i5 40043a34: ba 17 63 34 or %i5, 0x334, %i5 ! 40083b34 <_TOD_Days_to_date+0x1a> days_to_date += 2; 40043a38: 84 07 60 04 add %i5, 4, %g2 uint32_t month = 0; 40043a3c: 86 10 20 00 clr %g3 40043a40: ba 07 60 1a add %i5, 0x1a, %i5 if (*day < *days_to_date) 40043a44: c8 10 80 00 lduh [ %g2 ], %g4 40043a48: 80 a1 00 01 cmp %g4, %g1 40043a4c: 18 80 00 39 bgu 40043b30 <== NEVER TAKEN 40043a50: 86 00 e0 01 inc %g3 ++days_to_date; 40043a54: 84 00 a0 02 add %g2, 2, %g2 while (month < 11) { 40043a58: 80 a0 80 1d cmp %g2, %i5 40043a5c: 32 bf ff fb bne,a 40043a48 40043a60: c8 10 80 00 lduh [ %g2 ], %g4 40043a64: 86 10 20 0c mov 0xc, %g3 time_buffer->day = year_days + 1; 40043a68: 82 00 60 01 inc %g1 time_buffer->ticks = now.tv_usec / 40043a6c: f4 07 bf f8 ld [ %fp + -8 ], %i2 time_buffer->day = year_days + 1; 40043a70: 88 20 40 04 sub %g1, %g4, %g4 time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR; 40043a74: 05 24 68 ac sethi %hi(0x91a2b000), %g2 time_buffer->ticks = now.tv_usec / 40043a78: 03 10 01 f1 sethi %hi(0x4007c400), %g1 time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR; 40043a7c: 84 10 a3 c5 or %g2, 0x3c5, %g2 40043a80: 80 52 40 02 umul %o1, %g2, %g0 40043a84: 85 40 00 00 rd %y, %g2 40043a88: 85 30 a0 0b srl %g2, 0xb, %g2 time_buffer->ticks = now.tv_usec / 40043a8c: 81 80 20 00 wr %g0, %y 40043a90: f6 00 62 48 ld [ %g1 + 0x248 ], %i3 40043a94: 01 00 00 00 nop 40043a98: 01 00 00 00 nop 40043a9c: b6 76 80 1b udiv %i2, %i3, %i3 time_buffer->minute = day_secs % RTEMS_SECS_PER_HOUR; 40043aa0: ba 58 ae 10 smul %g2, 0xe10, %i5 time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR; 40043aa4: c4 27 20 0c st %g2, [ %i4 + 0xc ] time_buffer->minute = day_secs % RTEMS_SECS_PER_HOUR; 40043aa8: 92 22 40 1d sub %o1, %i5, %o1 time_buffer->month = _Year_day_as_month( year, &year_days ) + 1; 40043aac: c6 27 20 04 st %g3, [ %i4 + 4 ] time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE; 40043ab0: 03 22 22 22 sethi %hi(0x88888800), %g1 time_buffer->day = year_days + 1; 40043ab4: c8 27 20 08 st %g4, [ %i4 + 8 ] time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE; 40043ab8: 82 10 60 89 or %g1, 0x89, %g1 time_buffer->ticks = now.tv_usec / 40043abc: f6 27 20 18 st %i3, [ %i4 + 0x18 ] time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE; 40043ac0: 80 52 40 01 umul %o1, %g1, %g0 40043ac4: 83 40 00 00 rd %y, %g1 40043ac8: 83 30 60 05 srl %g1, 5, %g1 40043acc: 85 28 60 04 sll %g1, 4, %g2 time_buffer->minute = time_buffer->minute / RTEMS_SECS_PER_MINUTE; 40043ad0: c2 27 20 10 st %g1, [ %i4 + 0x10 ] time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE; 40043ad4: 82 20 80 01 sub %g2, %g1, %g1 40043ad8: 83 28 60 02 sll %g1, 2, %g1 40043adc: 92 22 40 01 sub %o1, %g1, %o1 40043ae0: d2 27 20 14 st %o1, [ %i4 + 0x14 ] return RTEMS_SUCCESSFUL; 40043ae4: 81 c7 e0 08 ret 40043ae8: 91 e8 20 00 restore %g0, 0, %o0 return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0); 40043aec: 05 14 7a e1 sethi %hi(0x51eb8400), %g2 <== NOT EXECUTED 40043af0: 84 10 a1 1f or %g2, 0x11f, %g2 ! 51eb851f <== NOT EXECUTED 40043af4: 80 56 c0 02 umul %i3, %g2, %g0 <== NOT EXECUTED 40043af8: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED 40043afc: 85 30 a0 07 srl %g2, 7, %g2 <== NOT EXECUTED 40043b00: 84 58 a1 90 smul %g2, 0x190, %g2 <== NOT EXECUTED 40043b04: 80 a6 c0 02 cmp %i3, %g2 <== NOT EXECUTED 40043b08: 22 bf ff cb be,a 40043a34 <== NOT EXECUTED 40043b0c: 3b 10 02 0e sethi %hi(0x40083800), %i5 <== NOT EXECUTED days_to_date = _TOD_Days_to_date[0]; 40043b10: 3b 10 02 0e sethi %hi(0x40083800), %i5 <== NOT EXECUTED 40043b14: 10 bf ff c9 b 40043a38 <== NOT EXECUTED 40043b18: ba 17 63 1a or %i5, 0x31a, %i5 ! 40083b1a <_TOD_Days_to_date> <== NOT EXECUTED return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0); 40043b1c: 80 a6 c0 18 cmp %i3, %i0 <== NOT EXECUTED 40043b20: 12 80 00 08 bne 40043b40 <== NOT EXECUTED 40043b24: 3b 10 02 0e sethi %hi(0x40083800), %i5 <== NOT EXECUTED year_days += 1; 40043b28: 10 bf ff b6 b 40043a00 <== NOT EXECUTED 40043b2c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40043b30: 10 bf ff ce b 40043a68 <== NOT EXECUTED 40043b34: c8 10 bf fe lduh [ %g2 + -2 ], %g4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 40043b38: 81 c7 e0 08 ret <== NOT EXECUTED 40043b3c: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED time_buffer->year = year; 40043b40: f6 27 00 00 st %i3, [ %i4 ] <== NOT EXECUTED days_to_date = _TOD_Days_to_date[0]; 40043b44: 10 bf ff bd b 40043a38 <== NOT EXECUTED 40043b48: ba 17 63 1a or %i5, 0x31a, %i5 <== NOT EXECUTED =============================================================================== 40043b4c : #include rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { 40043b4c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED if ( !time ) 40043b50: 90 96 20 00 orcc %i0, 0, %o0 <== NOT EXECUTED 40043b54: 02 80 00 0a be 40043b7c <== NOT EXECUTED 40043b58: 03 10 02 40 sethi %hi(0x40090000), %g1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set() ) 40043b5c: c2 08 63 e4 ldub [ %g1 + 0x3e4 ], %g1 ! 400903e4 <_TOD> <== NOT EXECUTED 40043b60: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40043b64: 02 80 00 04 be 40043b74 <== NOT EXECUTED 40043b68: b0 10 20 0b mov 0xb, %i0 <== NOT EXECUTED 40043b6c: 7f ff 5f 71 call 4001b930 <_Timecounter_Microtime> <== NOT EXECUTED 40043b70: b0 10 20 00 clr %i0 <== NOT EXECUTED return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; 40043b74: 81 c7 e0 08 ret <== NOT EXECUTED 40043b78: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 40043b7c: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED } 40043b80: 81 c7 e0 08 ret <== NOT EXECUTED 40043b84: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40043b88 : * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 40043b88: 9d e3 bf a0 save %sp, -96, %sp 40043b8c: ba 10 00 18 mov %i0, %i5 if ( !uptime ) 40043b90: 80 a7 60 00 cmp %i5, 0 40043b94: 02 80 00 09 be 40043bb8 <== NEVER TAKEN 40043b98: b0 10 20 09 mov 9, %i0 _Timecounter_Nanouptime( time ); 40043b9c: 7f ff 5f 2a call 4001b844 <_Timecounter_Nanouptime> 40043ba0: 90 10 00 1d mov %i5, %o0 --time->tv_sec; 40043ba4: f4 1f 40 00 ldd [ %i5 ], %i2 40043ba8: 86 86 ff ff addcc %i3, -1, %g3 40043bac: 84 46 bf ff addx %i2, -1, %g2 40043bb0: c4 3f 40 00 std %g2, [ %i5 ] return RTEMS_INVALID_ADDRESS; _TOD_Get_zero_based_uptime_as_timespec( uptime ); return RTEMS_SUCCESSFUL; 40043bb4: b0 10 20 00 clr %i0 } 40043bb8: 81 c7 e0 08 ret 40043bbc: 81 e8 00 00 restore =============================================================================== 4000d804 : #include #include uint64_t rtems_clock_get_uptime_nanoseconds( void ) { 4000d804: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED *time = _Timecounter_Sbinuptime() - SBT_1S; 4000d808: 40 00 0d 25 call 40010c9c <_Timecounter_Sbinuptime> <== NOT EXECUTED 4000d80c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 4000d810: b2 10 20 00 clr %i1 <== NOT EXECUTED 4000d814: 86 82 40 19 addcc %o1, %i1, %g3 <== NOT EXECUTED 4000d818: 84 42 00 18 addx %o0, %i0, %g2 <== NOT EXECUTED 4000d81c: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED static __inline struct timespec sbttots(sbintime_t _sbt) { struct timespec _ts; _ts.tv_sec = _sbt >> 32; 4000d820: 83 38 a0 1f sra %g2, 0x1f, %g1 <== NOT EXECUTED 4000d824: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 4000d828: 05 0e e6 b2 sethi %hi(0x3b9ac800), %g2 <== NOT EXECUTED 4000d82c: 84 10 a2 00 or %g2, 0x200, %g2 ! 3b9aca00 <== NOT EXECUTED 4000d830: 86 52 40 02 umul %o1, %g2, %g3 <== NOT EXECUTED 4000d834: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 4000d838: d0 27 bf f4 st %o0, [ %fp + -12 ] <== NOT EXECUTED { struct timespec _ts; _ts = sbttots( *_time ); return _Timespec_Get_as_nanoseconds( &_ts ); 4000d83c: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED 4000d840: c2 27 bf f0 st %g1, [ %fp + -16 ] <== NOT EXECUTED 4000d844: 40 00 1f 0f call 40015480 <_Timespec_Get_as_nanoseconds> <== NOT EXECUTED 4000d848: c4 27 bf f8 st %g2, [ %fp + -8 ] <== NOT EXECUTED Timestamp_Control snapshot_as_timestamp; _TOD_Get_zero_based_uptime(&snapshot_as_timestamp); return _Timestamp_Get_as_nanoseconds(&snapshot_as_timestamp); } 4000d84c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 4000d850: 81 c7 e0 08 ret <== NOT EXECUTED 4000d854: 93 e8 00 09 restore %g0, %o1, %o1 <== NOT EXECUTED =============================================================================== 40043bc0 : #include rtems_status_code rtems_clock_set( const rtems_time_of_day *tod ) { 40043bc0: 9d e3 bf 88 save %sp, -120, %sp 40043bc4: ba 10 00 18 mov %i0, %i5 if ( !tod ) 40043bc8: 80 a7 60 00 cmp %i5, 0 40043bcc: 02 80 00 1a be 40043c34 <== NEVER TAKEN 40043bd0: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( tod ) ) { 40043bd4: 90 10 00 1d mov %i5, %o0 40043bd8: 40 00 00 46 call 40043cf0 <_TOD_Validate> 40043bdc: b0 10 20 14 mov 0x14, %i0 40043be0: 80 a2 20 00 cmp %o0, 0 40043be4: 02 80 00 14 be 40043c34 <== NEVER TAKEN 40043be8: 01 00 00 00 nop struct timespec tod_as_timespec; ISR_lock_Context lock_context; tod_as_timespec.tv_sec = _TOD_To_seconds( tod ); 40043bec: 40 00 00 14 call 40043c3c <_TOD_To_seconds> 40043bf0: 90 10 00 1d mov %i5, %o0 tod_as_timespec.tv_nsec = tod->ticks * rtems_configuration_get_nanoseconds_per_tick(); 40043bf4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 40043bf8: 05 10 01 f1 sethi %hi(0x4007c400), %g2 40043bfc: c4 00 a2 78 ld [ %g2 + 0x278 ], %g2 ! 4007c678 <_Watchdog_Nanoseconds_per_tick> 40043c00: 82 58 40 02 smul %g1, %g2, %g1 tod_as_timespec.tv_sec = _TOD_To_seconds( tod ); 40043c04: c0 27 bf f0 clr [ %fp + -16 ] 40043c08: d0 27 bf f4 st %o0, [ %fp + -12 ] _TOD_Lock(); 40043c0c: 40 00 02 34 call 400444dc <_TOD_Lock> 40043c10: c2 27 bf f8 st %g1, [ %fp + -8 ] 40043c14: 91 d0 20 09 ta 9 <== NOT EXECUTED _Timecounter_Acquire( lock_context ); 40043c18: c2 27 bf ec st %g1, [ %fp + -20 ] _TOD_Acquire( &lock_context ); _TOD_Set( &tod_as_timespec, &lock_context ); 40043c1c: 92 07 bf ec add %fp, -20, %o1 40043c20: 90 07 bf f0 add %fp, -16, %o0 40043c24: 40 00 02 38 call 40044504 <_TOD_Set> 40043c28: b0 10 20 00 clr %i0 _TOD_Unlock(); 40043c2c: 40 00 02 31 call 400444f0 <_TOD_Unlock> 40043c30: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 40043c34: 81 c7 e0 08 ret 40043c38: 81 e8 00 00 restore =============================================================================== 4000d858 : rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 4000d858: 9d e3 bf 88 save %sp, -120, %sp rtems_status_code sc; if ( event_out != NULL ) { 4000d85c: 80 a6 e0 00 cmp %i3, 0 4000d860: 02 80 00 1c be 4000d8d0 <== NEVER TAKEN 4000d864: 01 00 00 00 nop <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000d868: 91 d0 20 09 ta 9 <== NOT EXECUTED ISR_lock_Context *lock_context ) { Thread_Control *executing; _ISR_lock_ISR_disable( lock_context ); 4000d86c: c2 27 bf fc st %g1, [ %fp + -4 ] executing = _Thread_Executing; 4000d870: d8 01 a0 20 ld [ %g6 + 0x20 ], %o4 executing = _Thread_Wait_acquire_default_for_executing( &lock_context ); api = executing->API_Extensions[ THREAD_API_RTEMS ]; event = &api->Event; if ( !_Event_sets_Is_empty( event_in ) ) { 4000d874: 80 a6 20 00 cmp %i0, 0 4000d878: 12 80 00 09 bne 4000d89c <== ALWAYS TAKEN 4000d87c: da 03 21 58 ld [ %o4 + 0x158 ], %o5 THREAD_WAIT_CLASS_EVENT, STATES_WAITING_FOR_EVENT, &lock_context ); } else { *event_out = event->pending_events; 4000d880: c2 03 40 00 ld [ %o5 ], %g1 <== NOT EXECUTED 4000d884: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000d888: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000d88c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000d890: 01 00 00 00 nop <== NOT EXECUTED _Thread_Wait_release_default( executing, &lock_context ); sc = RTEMS_SUCCESSFUL; 4000d894: 81 c7 e0 08 ret <== NOT EXECUTED 4000d898: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED sc = _Event_Seize( 4000d89c: 82 07 bf fc add %fp, -4, %g1 4000d8a0: c2 23 a0 64 st %g1, [ %sp + 0x64 ] 4000d8a4: 82 10 20 04 mov 4, %g1 4000d8a8: c2 23 a0 60 st %g1, [ %sp + 0x60 ] 4000d8ac: 82 10 21 00 mov 0x100, %g1 4000d8b0: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 4000d8b4: 96 10 00 1b mov %i3, %o3 4000d8b8: 94 10 00 1a mov %i2, %o2 4000d8bc: 92 10 00 19 mov %i1, %o1 4000d8c0: 40 00 00 06 call 4000d8d8 <_Event_Seize> 4000d8c4: 90 10 00 18 mov %i0, %o0 4000d8c8: 81 c7 e0 08 ret 4000d8cc: 91 e8 00 08 restore %g0, %o0, %o0 } else { sc = RTEMS_INVALID_ADDRESS; } return sc; } 4000d8d0: 81 c7 e0 08 ret <== NOT EXECUTED 4000d8d4: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED =============================================================================== 4000da58 : rtems_status_code rtems_event_send( rtems_id id, rtems_event_set event_in ) { 4000da58: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; RTEMS_API_Control *api; ISR_lock_Context lock_context; the_thread = _Thread_Get( id, &lock_context ); 4000da5c: 90 10 00 18 mov %i0, %o0 4000da60: 92 07 bf fc add %fp, -4, %o1 4000da64: 40 00 16 28 call 40013304 <_Thread_Get> 4000da68: b0 10 20 04 mov 4, %i0 if ( the_thread == NULL ) { 4000da6c: 80 a2 20 00 cmp %o0, 0 4000da70: 02 80 00 07 be 4000da8c <== NEVER TAKEN 4000da74: 98 07 bf fc add %fp, -4, %o4 return RTEMS_INVALID_ID; #endif } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; return _Event_Surrender( 4000da78: d4 02 21 58 ld [ %o0 + 0x158 ], %o2 4000da7c: 96 10 21 00 mov 0x100, %o3 4000da80: 40 00 00 05 call 4000da94 <_Event_Surrender> 4000da84: 92 10 00 19 mov %i1, %o1 4000da88: b0 10 00 08 mov %o0, %i0 event_in, &api->Event, THREAD_WAIT_CLASS_EVENT, &lock_context ); } 4000da8c: 81 c7 e0 08 ret 4000da90: 81 e8 00 00 restore =============================================================================== 400193d4 : rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 400193d4: 9d e3 bf 88 save %sp, -120, %sp rtems_status_code sc; if ( event_out != NULL ) { 400193d8: 80 a6 e0 00 cmp %i3, 0 400193dc: 02 80 00 1d be 40019450 <== NEVER TAKEN 400193e0: 01 00 00 00 nop <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400193e4: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( lock_context ); 400193e8: c2 27 bf fc st %g1, [ %fp + -4 ] executing = _Thread_Executing; 400193ec: d8 01 a0 20 ld [ %g6 + 0x20 ], %o4 executing = _Thread_Wait_acquire_default_for_executing( &lock_context ); api = executing->API_Extensions[ THREAD_API_RTEMS ]; event = &api->System_event; if ( !_Event_sets_Is_empty( event_in ) ) { 400193f0: 80 a6 20 00 cmp %i0, 0 400193f4: 12 80 00 09 bne 40019418 <== ALWAYS TAKEN 400193f8: da 03 21 58 ld [ %o4 + 0x158 ], %o5 THREAD_WAIT_CLASS_SYSTEM_EVENT, STATES_WAITING_FOR_SYSTEM_EVENT, &lock_context ); } else { *event_out = event->pending_events; 400193fc: c2 03 60 04 ld [ %o5 + 4 ], %g1 <== NOT EXECUTED 40019400: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40019404: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40019408: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4001940c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Wait_release_default( executing, &lock_context ); sc = RTEMS_SUCCESSFUL; 40019410: 81 c7 e0 08 ret <== NOT EXECUTED 40019414: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED sc = _Event_Seize( 40019418: 82 07 bf fc add %fp, -4, %g1 4001941c: c2 23 a0 64 st %g1, [ %sp + 0x64 ] 40019420: 82 10 20 08 mov 8, %g1 40019424: c2 23 a0 60 st %g1, [ %sp + 0x60 ] 40019428: 82 10 22 00 mov 0x200, %g1 4001942c: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 40019430: 9a 03 60 04 add %o5, 4, %o5 40019434: 96 10 00 1b mov %i3, %o3 40019438: 94 10 00 1a mov %i2, %o2 4001943c: 92 10 00 19 mov %i1, %o1 40019440: 7f ff fe ff call 4001903c <_Event_Seize> 40019444: 90 10 00 18 mov %i0, %o0 40019448: 81 c7 e0 08 ret 4001944c: 91 e8 00 08 restore %g0, %o0, %o0 } else { sc = RTEMS_INVALID_ADDRESS; } return sc; } 40019450: 81 c7 e0 08 ret <== NOT EXECUTED 40019454: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED =============================================================================== 400060e0 : rtems_status_code rtems_event_system_send( rtems_id id, rtems_event_set event_in ) { 400060e0: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; RTEMS_API_Control *api; ISR_lock_Context lock_context; the_thread = _Thread_Get( id, &lock_context ); 400060e4: 90 10 00 18 mov %i0, %o0 400060e8: 92 07 bf fc add %fp, -4, %o1 400060ec: 40 00 0f 40 call 40009dec <_Thread_Get> 400060f0: b0 10 20 04 mov 4, %i0 if ( the_thread == NULL ) { 400060f4: 80 a2 20 00 cmp %o0, 0 400060f8: 02 80 00 08 be 40006118 <== NEVER TAKEN 400060fc: 98 07 bf fc add %fp, -4, %o4 return RTEMS_INVALID_ID; } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; return _Event_Surrender( 40006100: d4 02 21 58 ld [ %o0 + 0x158 ], %o2 40006104: 96 10 22 00 mov 0x200, %o3 40006108: 94 02 a0 04 add %o2, 4, %o2 4000610c: 40 00 1c 52 call 4000d254 <_Event_Surrender> 40006110: 92 10 00 19 mov %i1, %o1 40006114: b0 10 00 08 mov %o0, %i0 event_in, &api->System_event, THREAD_WAIT_CLASS_SYSTEM_EVENT, &lock_context ); } 40006118: 81 c7 e0 08 ret 4000611c: 81 e8 00 00 restore =============================================================================== 4000dbb4 : #include uint32_t rtems_get_current_processor(void) { return _SMP_Get_current_processor(); } 4000dbb4: 81 c3 e0 08 retl <== NOT EXECUTED 4000dbb8: 90 10 20 00 clr %o0 <== NOT EXECUTED =============================================================================== 4000dbbc : #include uint32_t rtems_get_processor_count(void) { return _SMP_Get_processor_count(); } 4000dbbc: 81 c3 e0 08 retl <== NOT EXECUTED 4000dbc0: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED =============================================================================== 40006070 : rtems_status_code rtems_interrupt_catch( rtems_isr_entry new_isr_handler, rtems_vector_number vector, rtems_isr_entry *old_isr_handler ) { 40006070: 9d e3 bf a0 save %sp, -96, %sp if ( !_ISR_Is_vector_number_valid( vector ) ) 40006074: 80 a6 61 ff cmp %i1, 0x1ff 40006078: 18 80 00 0b bgu 400060a4 <== NEVER TAKEN 4000607c: 82 10 20 0a mov 0xa, %g1 return RTEMS_INVALID_NUMBER; if ( !_ISR_Is_valid_user_handler( (void *) new_isr_handler ) ) return RTEMS_INVALID_ADDRESS; if ( !_ISR_Is_valid_user_handler( (void *) old_isr_handler ) ) 40006080: 80 a6 20 00 cmp %i0, 0 40006084: 02 80 00 0a be 400060ac <== NEVER TAKEN 40006088: 80 a6 a0 00 cmp %i2, 0 4000608c: 02 80 00 08 be 400060ac <== NEVER TAKEN 40006090: 94 10 00 1a mov %i2, %o2 return RTEMS_INVALID_ADDRESS; _ISR_Install_vector( 40006094: 92 10 00 18 mov %i0, %o1 40006098: 7f ff f2 f6 call 40002c70 <_CPU_ISR_install_vector> 4000609c: 90 10 00 19 mov %i1, %o0 vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler ); return RTEMS_SUCCESSFUL; 400060a0: 82 10 20 00 clr %g1 } 400060a4: 81 c7 e0 08 ret 400060a8: 91 e8 00 01 restore %g0, %g1, %o0 return RTEMS_INVALID_ADDRESS; 400060ac: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED } 400060b0: 81 c7 e0 08 ret <== NOT EXECUTED 400060b4: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED =============================================================================== 40019c34 : #include rtems_status_code rtems_message_queue_delete( rtems_id id ) { 40019c34: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED _RTEMS_Lock_allocator(); 40019c38: 7f ff d5 76 call 4000f210 <_RTEMS_Lock_allocator> <== NOT EXECUTED 40019c3c: 39 10 00 d1 sethi %hi(0x40034400), %i4 <== NOT EXECUTED Objects_Id id, Thread_queue_Context *queue_context ) { _Thread_queue_Context_initialize( queue_context ); return (Message_queue_Control *) _Objects_Get( 40019c40: 92 07 bf dc add %fp, -36, %o1 <== NOT EXECUTED 40019c44: 94 17 22 80 or %i4, 0x280, %o2 <== NOT EXECUTED 40019c48: 7f ff de c3 call 40011754 <_Objects_Get> <== NOT EXECUTED 40019c4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Thread_queue_Context queue_context; _Objects_Allocator_lock(); the_message_queue = _Message_queue_Get( id, &queue_context ); if ( the_message_queue == NULL ) { 40019c50: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED 40019c54: 02 80 00 0f be 40019c90 <== NOT EXECUTED 40019c58: 90 17 22 80 or %i4, 0x280, %o0 <== NOT EXECUTED _CORE_message_queue_Acquire_critical( &the_message_queue->message_queue, &queue_context ); _Objects_Close( &_Message_queue_Information, &the_message_queue->Object ); 40019c5c: 7f ff dd c0 call 4001135c <_Objects_Close> <== NOT EXECUTED 40019c60: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED _Thread_queue_Context_set_MP_callout( &queue_context, _Message_queue_MP_Send_object_was_deleted ); _CORE_message_queue_Close( 40019c64: 92 07 bf dc add %fp, -36, %o1 <== NOT EXECUTED 40019c68: 40 00 00 eb call 4001a014 <_CORE_message_queue_Close> <== NOT EXECUTED 40019c6c: 90 07 60 10 add %i5, 0x10, %o0 <== NOT EXECUTED _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 40019c70: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 40019c74: 90 17 22 80 or %i4, 0x280, %o0 <== NOT EXECUTED 40019c78: 7f ff de 85 call 4001168c <_Objects_Free> <== NOT EXECUTED 40019c7c: b0 10 20 00 clr %i0 <== NOT EXECUTED _RTEMS_Unlock_allocator(); 40019c80: 7f ff d5 69 call 4000f224 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 40019c84: 01 00 00 00 nop <== NOT EXECUTED #endif _Message_queue_Free( the_message_queue ); _Objects_Allocator_unlock(); return RTEMS_SUCCESSFUL; } 40019c88: 81 c7 e0 08 ret <== NOT EXECUTED 40019c8c: 81 e8 00 00 restore <== NOT EXECUTED 40019c90: 7f ff d5 65 call 4000f224 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 40019c94: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED return RTEMS_INVALID_ID; 40019c98: 81 c7 e0 08 ret <== NOT EXECUTED 40019c9c: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000dc0c : rtems_status_code rtems_object_get_classic_name( rtems_id id, rtems_name *name ) { 4000dc0c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) 4000dc10: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4000dc14: 02 80 00 0b be 4000dc40 <== NOT EXECUTED 4000dc18: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; status = _Objects_Id_to_name( id, &name_u ); 4000dc1c: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED 4000dc20: 40 00 0e f2 call 400117e8 <_Objects_Id_to_name> <== NOT EXECUTED 4000dc24: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED *name = name_u.name_u32; 4000dc28: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED 4000dc2c: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; 4000dc30: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED 4000dc34: 03 10 00 bb sethi %hi(0x4002ec00), %g1 <== NOT EXECUTED 4000dc38: 82 10 60 24 or %g1, 0x24, %g1 ! 4002ec24 <_Status_Object_name_errors_to_status> <== NOT EXECUTED 4000dc3c: c2 00 40 08 ld [ %g1 + %o0 ], %g1 <== NOT EXECUTED } 4000dc40: 81 c7 e0 08 ret <== NOT EXECUTED 4000dc44: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED =============================================================================== 40019d10 : Objects_Id id, size_t length, char *name ) { return _Objects_Get_name_as_string( id, length, name ); 40019d10: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 40019d14: 40 00 01 99 call 4001a378 <_Objects_Get_name_as_string> <== NOT EXECUTED 40019d18: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 40058018 : rtems_status_code rtems_rate_monotonic_get_statistics( rtems_id id, rtems_rate_monotonic_period_statistics *dst ) { 40058018: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Rate_monotonic_Control *the_period; ISR_lock_Context lock_context; const Rate_monotonic_Statistics *src; if ( dst == NULL ) { 4005801c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 40058020: 02 80 00 43 be 4005812c <== NOT EXECUTED 40058024: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED return (Rate_monotonic_Control *) 40058028: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED 4005802c: 15 10 02 41 sethi %hi(0x40090400), %o2 <== NOT EXECUTED 40058030: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40058034: 7f ff b2 1a call 4004489c <_Objects_Get> <== NOT EXECUTED 40058038: 94 12 a0 c0 or %o2, 0xc0, %o2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; } the_period = _Rate_monotonic_Get( id, &lock_context ); if ( the_period == NULL ) { 4005803c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40058040: 02 80 00 3d be 40058134 <== NOT EXECUTED 40058044: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED 40058048: c2 02 20 70 ld [ %o0 + 0x70 ], %g1 <== NOT EXECUTED 4005804c: c4 02 20 74 ld [ %o0 + 0x74 ], %g2 <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 40058050: 87 38 60 1f sra %g1, 0x1f, %g3 <== NOT EXECUTED _Rate_monotonic_Acquire_critical( the_period, &lock_context ); src = &the_period->Statistics; dst->count = src->count; dst->missed_count = src->missed_count; 40058054: f8 1a 20 68 ldd [ %o0 + 0x68 ], %i4 <== NOT EXECUTED 40058058: c2 26 60 0c st %g1, [ %i1 + 0xc ] <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 4005805c: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 40058060: c6 26 60 08 st %g3, [ %i1 + 8 ] <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 40058064: 82 10 62 00 or %g1, 0x200, %g1 <== NOT EXECUTED 40058068: 86 50 80 01 umul %g2, %g1, %g3 <== NOT EXECUTED 4005806c: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED 40058070: c4 26 60 10 st %g2, [ %i1 + 0x10 ] <== NOT EXECUTED 40058074: c6 02 20 78 ld [ %o0 + 0x78 ], %g3 <== NOT EXECUTED 40058078: c4 02 20 7c ld [ %o0 + 0x7c ], %g2 <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 4005807c: 89 38 e0 1f sra %g3, 0x1f, %g4 <== NOT EXECUTED 40058080: c6 26 60 1c st %g3, [ %i1 + 0x1c ] <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 40058084: 86 50 80 01 umul %g2, %g1, %g3 <== NOT EXECUTED 40058088: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 4005808c: c8 26 60 18 st %g4, [ %i1 + 0x18 ] <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 40058090: c4 26 60 20 st %g2, [ %i1 + 0x20 ] <== NOT EXECUTED 40058094: c6 02 20 80 ld [ %o0 + 0x80 ], %g3 <== NOT EXECUTED 40058098: c4 02 20 84 ld [ %o0 + 0x84 ], %g2 <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 4005809c: 89 38 e0 1f sra %g3, 0x1f, %g4 <== NOT EXECUTED 400580a0: c6 26 60 2c st %g3, [ %i1 + 0x2c ] <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 400580a4: 86 50 80 01 umul %g2, %g1, %g3 <== NOT EXECUTED 400580a8: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 400580ac: c8 26 60 28 st %g4, [ %i1 + 0x28 ] <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 400580b0: c4 26 60 30 st %g2, [ %i1 + 0x30 ] <== NOT EXECUTED 400580b4: c6 02 20 88 ld [ %o0 + 0x88 ], %g3 <== NOT EXECUTED 400580b8: c4 02 20 8c ld [ %o0 + 0x8c ], %g2 <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 400580bc: 89 38 e0 1f sra %g3, 0x1f, %g4 <== NOT EXECUTED 400580c0: c6 26 60 3c st %g3, [ %i1 + 0x3c ] <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 400580c4: 86 50 80 01 umul %g2, %g1, %g3 <== NOT EXECUTED 400580c8: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 400580cc: c8 26 60 38 st %g4, [ %i1 + 0x38 ] <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 400580d0: c4 26 60 40 st %g2, [ %i1 + 0x40 ] <== NOT EXECUTED 400580d4: c6 02 20 90 ld [ %o0 + 0x90 ], %g3 <== NOT EXECUTED 400580d8: c4 02 20 94 ld [ %o0 + 0x94 ], %g2 <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 400580dc: 89 38 e0 1f sra %g3, 0x1f, %g4 <== NOT EXECUTED 400580e0: c6 26 60 4c st %g3, [ %i1 + 0x4c ] <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 400580e4: 86 50 80 01 umul %g2, %g1, %g3 <== NOT EXECUTED 400580e8: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 400580ec: c8 26 60 48 st %g4, [ %i1 + 0x48 ] <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 400580f0: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED 400580f4: c8 02 20 98 ld [ %o0 + 0x98 ], %g4 <== NOT EXECUTED 400580f8: c4 02 20 9c ld [ %o0 + 0x9c ], %g2 <== NOT EXECUTED dst->count = src->count; 400580fc: f8 26 40 00 st %i4, [ %i1 ] <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 40058100: b9 39 20 1f sra %g4, 0x1f, %i4 <== NOT EXECUTED dst->missed_count = src->missed_count; 40058104: fa 26 60 04 st %i5, [ %i1 + 4 ] <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 40058108: 86 50 80 01 umul %g2, %g1, %g3 <== NOT EXECUTED 4005810c: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 40058110: c8 26 60 5c st %g4, [ %i1 + 0x5c ] <== NOT EXECUTED 40058114: f8 26 60 58 st %i4, [ %i1 + 0x58 ] <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 40058118: c4 26 60 60 st %g2, [ %i1 + 0x60 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4005811c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40058120: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40058124: 01 00 00 00 nop <== NOT EXECUTED _Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time ); _Timestamp_To_timespec( &src->max_wall_time, &dst->max_wall_time ); _Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time ); _Rate_monotonic_Release( the_period, &lock_context ); return RTEMS_SUCCESSFUL; 40058128: 82 10 20 00 clr %g1 ! 0 <== NOT EXECUTED } 4005812c: 81 c7 e0 08 ret <== NOT EXECUTED 40058130: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED 40058134: 81 c7 e0 08 ret <== NOT EXECUTED 40058138: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED =============================================================================== 4005813c : rtems_status_code rtems_rate_monotonic_get_status( rtems_id id, rtems_rate_monotonic_period_status *period_status ) { 4005813c: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED Rate_monotonic_Control *the_period; ISR_lock_Context lock_context; rtems_status_code status; if ( period_status == NULL ) { 40058140: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 40058144: 02 80 00 1c be 400581b4 <== NOT EXECUTED 40058148: 84 10 20 09 mov 9, %g2 <== NOT EXECUTED 4005814c: 92 07 bf ec add %fp, -20, %o1 <== NOT EXECUTED 40058150: 15 10 02 41 sethi %hi(0x40090400), %o2 <== NOT EXECUTED 40058154: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40058158: 7f ff b1 d1 call 4004489c <_Objects_Get> <== NOT EXECUTED 4005815c: 94 12 a0 c0 or %o2, 0xc0, %o2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; } the_period = _Rate_monotonic_Get( id, &lock_context ); if ( the_period == NULL ) { 40058160: 82 92 20 00 orcc %o0, 0, %g1 <== NOT EXECUTED 40058164: 02 80 00 30 be 40058224 <== NOT EXECUTED 40058168: 84 10 20 04 mov 4, %g2 <== NOT EXECUTED return RTEMS_INVALID_ID; } _Rate_monotonic_Acquire_critical( the_period, &lock_context ); period_status->owner = the_period->owner->Object.id; 4005816c: c4 00 60 54 ld [ %g1 + 0x54 ], %g2 <== NOT EXECUTED 40058170: c6 00 a0 08 ld [ %g2 + 8 ], %g3 <== NOT EXECUTED period_status->state = the_period->state; 40058174: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 <== NOT EXECUTED period_status->postponed_jobs_count = the_period->postponed_jobs; 40058178: c2 00 60 a0 ld [ %g1 + 0xa0 ], %g1 <== NOT EXECUTED 4005817c: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 40058180: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED period_status->owner = the_period->owner->Object.id; 40058184: c6 26 40 00 st %g3, [ %i1 ] <== NOT EXECUTED if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 40058188: 12 80 00 0d bne 400581bc <== NOT EXECUTED 4005818c: c4 26 60 04 st %g2, [ %i1 + 4 ] <== NOT EXECUTED /* * If the period is inactive, there is no information. */ _Timespec_Set_to_zero( &period_status->since_last_period ); 40058190: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED 40058194: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED 40058198: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED _Timespec_Set_to_zero( &period_status->executed_since_last_period ); 4005819c: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED 400581a0: c0 26 60 1c clr [ %i1 + 0x1c ] <== NOT EXECUTED 400581a4: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400581a8: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400581ac: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400581b0: 01 00 00 00 nop <== NOT EXECUTED } } _Rate_monotonic_Release( the_period, &lock_context ); return status; } 400581b4: 81 c7 e0 08 ret <== NOT EXECUTED 400581b8: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED valid_status = _Rate_monotonic_Get_status( 400581bc: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED 400581c0: 40 00 00 1b call 4005822c <_Rate_monotonic_Get_status> <== NOT EXECUTED 400581c4: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED if ( valid_status ) { 400581c8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400581cc: 02 bf ff f7 be 400581a8 <== NOT EXECUTED 400581d0: 84 10 20 0b mov 0xb, %g2 <== NOT EXECUTED 400581d4: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED 400581d8: c6 07 bf f8 ld [ %fp + -8 ], %g3 <== NOT EXECUTED 400581dc: f4 07 bf f4 ld [ %fp + -12 ], %i2 <== NOT EXECUTED 400581e0: f8 07 bf fc ld [ %fp + -4 ], %i4 <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 400581e4: b1 38 a0 1f sra %g2, 0x1f, %i0 <== NOT EXECUTED 400581e8: 89 38 e0 1f sra %g3, 0x1f, %g4 <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 400581ec: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 400581f0: c4 26 60 0c st %g2, [ %i1 + 0xc ] <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 400581f4: 82 10 62 00 or %g1, 0x200, %g1 <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 400581f8: f0 26 60 08 st %i0, [ %i1 + 8 ] <== NOT EXECUTED _ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32; 400581fc: b6 56 80 01 umul %i2, %g1, %i3 <== NOT EXECUTED 40058200: b5 40 00 00 rd %y, %i2 <== NOT EXECUTED 40058204: ba 57 00 01 umul %i4, %g1, %i5 <== NOT EXECUTED 40058208: b9 40 00 00 rd %y, %i4 <== NOT EXECUTED status = RTEMS_SUCCESSFUL; 4005820c: 84 10 20 00 clr %g2 <== NOT EXECUTED 40058210: f4 26 60 10 st %i2, [ %i1 + 0x10 ] <== NOT EXECUTED _ts.tv_sec = _sbt >> 32; 40058214: c6 26 60 1c st %g3, [ %i1 + 0x1c ] <== NOT EXECUTED 40058218: c8 26 60 18 st %g4, [ %i1 + 0x18 ] <== NOT EXECUTED 4005821c: 10 bf ff e3 b 400581a8 <== NOT EXECUTED 40058220: f8 26 60 20 st %i4, [ %i1 + 0x20 ] <== NOT EXECUTED } 40058224: 81 c7 e0 08 ret <== NOT EXECUTED 40058228: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED =============================================================================== 40043e20 : #define NANOSECONDS_FMT "%06ld" void rtems_rate_monotonic_report_statistics_with_plugin( const rtems_printer *printer ) { 40043e20: 9d e3 be d8 save %sp, -296, %sp <== NOT EXECUTED rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; rtems_printf( printer, "Period information by period\n" ); 40043e24: 13 10 02 0e sethi %hi(0x40083800), %o1 <== NOT EXECUTED 40043e28: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40043e2c: 7f ff 21 ca call 4000c554 <== NOT EXECUTED 40043e30: 92 12 63 b8 or %o1, 0x3b8, %o1 <== NOT EXECUTED rtems_printf( printer, "--- CPU times are in seconds ---\n" ); 40043e34: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40043e38: 13 10 02 0e sethi %hi(0x40083800), %o1 <== NOT EXECUTED 40043e3c: 7f ff 21 c6 call 4000c554 <== NOT EXECUTED 40043e40: 92 12 63 d8 or %o1, 0x3d8, %o1 ! 40083bd8 <_TOD_Days_per_month+0x88> <== NOT EXECUTED rtems_printf( printer, "--- Wall times are in seconds ---\n" ); 40043e44: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40043e48: 13 10 02 0f sethi %hi(0x40083c00), %o1 <== NOT EXECUTED 40043e4c: 7f ff 21 c2 call 4000c554 <== NOT EXECUTED 40043e50: 92 12 60 00 mov %o1, %o1 ! 40083c00 <_TOD_Days_per_month+0xb0> <== NOT EXECUTED Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ rtems_printf( printer, 40043e54: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40043e58: 13 10 02 0f sethi %hi(0x40083c00), %o1 <== NOT EXECUTED 40043e5c: 7f ff 21 be call 4000c554 <== NOT EXECUTED 40043e60: 92 12 60 28 or %o1, 0x28, %o1 ! 40083c28 <_TOD_Days_per_month+0xd8> <== NOT EXECUTED /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 40043e64: 37 10 02 41 sethi %hi(0x40090400), %i3 <== NOT EXECUTED 40043e68: b6 16 e0 c0 or %i3, 0xc0, %i3 ! 400904c0 <_Rate_monotonic_Information> <== NOT EXECUTED 40043e6c: fa 06 e0 08 ld [ %i3 + 8 ], %i5 <== NOT EXECUTED 40043e70: c2 06 e0 0c ld [ %i3 + 0xc ], %g1 <== NOT EXECUTED 40043e74: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED 40043e78: 18 80 00 75 bgu 4004404c <== NOT EXECUTED 40043e7c: 35 10 02 0f sethi %hi(0x40083c00), %i2 <== NOT EXECUTED struct timespec *min_cpu = &the_stats.min_cpu_time; struct timespec *max_cpu = &the_stats.max_cpu_time; struct timespec *total_cpu = &the_stats.total_cpu_time; _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average ); rtems_printf( printer, 40043e80: 39 04 18 93 sethi %hi(0x10624c00), %i4 <== NOT EXECUTED 40043e84: 21 10 02 0f sethi %hi(0x40083c00), %l0 <== NOT EXECUTED struct timespec *min_wall = &the_stats.min_wall_time; struct timespec *max_wall = &the_stats.max_wall_time; struct timespec *total_wall = &the_stats.total_wall_time; _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); rtems_printf( printer, 40043e88: 33 10 02 0f sethi %hi(0x40083c00), %i1 <== NOT EXECUTED rtems_printf( printer, "\n" ); 40043e8c: 23 10 02 0b sethi %hi(0x40082c00), %l1 <== NOT EXECUTED rtems_printf( printer, 40043e90: b4 16 a0 c0 or %i2, 0xc0, %i2 <== NOT EXECUTED rtems_printf( printer, 40043e94: b8 17 21 d3 or %i4, 0x1d3, %i4 <== NOT EXECUTED 40043e98: a0 14 20 d8 or %l0, 0xd8, %l0 <== NOT EXECUTED rtems_printf( printer, 40043e9c: b2 16 61 00 or %i1, 0x100, %i1 <== NOT EXECUTED rtems_printf( printer, "\n" ); 40043ea0: 10 80 00 4b b 40043fcc <== NOT EXECUTED 40043ea4: a2 14 60 38 or %l1, 0x38, %l1 <== NOT EXECUTED _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average ); 40043ea8: 40 00 04 cc call 400451d8 <_Timespec_Divide_by_integer> <== NOT EXECUTED 40043eac: 01 00 00 00 nop <== NOT EXECUTED rtems_printf( printer, 40043eb0: c2 07 bf 60 ld [ %fp + -160 ], %g1 <== NOT EXECUTED 40043eb4: 89 38 60 1f sra %g1, 0x1f, %g4 <== NOT EXECUTED 40043eb8: c6 07 bf b8 ld [ %fp + -72 ], %g3 <== NOT EXECUTED 40043ebc: 80 58 40 1c smul %g1, %i4, %g0 <== NOT EXECUTED 40043ec0: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED 40043ec4: 85 38 a0 06 sra %g2, 6, %g2 <== NOT EXECUTED 40043ec8: 84 20 80 04 sub %g2, %g4, %g2 <== NOT EXECUTED 40043ecc: 80 58 c0 1c smul %g3, %i4, %g0 <== NOT EXECUTED 40043ed0: 83 40 00 00 rd %y, %g1 <== NOT EXECUTED 40043ed4: c4 23 a0 6c st %g2, [ %sp + 0x6c ] <== NOT EXECUTED 40043ed8: 87 38 e0 1f sra %g3, 0x1f, %g3 <== NOT EXECUTED 40043edc: c4 07 bf 58 ld [ %fp + -168 ], %g2 <== NOT EXECUTED 40043ee0: 83 38 60 06 sra %g1, 6, %g1 <== NOT EXECUTED 40043ee4: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED 40043ee8: c4 23 a0 64 st %g2, [ %sp + 0x64 ] <== NOT EXECUTED 40043eec: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 40043ef0: c4 07 bf 5c ld [ %fp + -164 ], %g2 <== NOT EXECUTED 40043ef4: c2 23 a0 60 st %g1, [ %sp + 0x60 ] <== NOT EXECUTED 40043ef8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40043efc: c2 07 bf b4 ld [ %fp + -76 ], %g1 <== NOT EXECUTED 40043f00: c4 23 a0 68 st %g2, [ %sp + 0x68 ] <== NOT EXECUTED 40043f04: d8 07 bf a8 ld [ %fp + -88 ], %o4 <== NOT EXECUTED 40043f08: c2 23 a0 5c st %g1, [ %sp + 0x5c ] <== NOT EXECUTED 40043f0c: 80 5b 00 1c smul %o4, %i4, %g0 <== NOT EXECUTED 40043f10: 83 40 00 00 rd %y, %g1 <== NOT EXECUTED 40043f14: d4 1f bf a0 ldd [ %fp + -96 ], %o2 <== NOT EXECUTED 40043f18: 83 38 60 06 sra %g1, 6, %g1 <== NOT EXECUTED 40043f1c: da 07 bf b0 ld [ %fp + -80 ], %o5 <== NOT EXECUTED 40043f20: 99 3b 20 1f sra %o4, 0x1f, %o4 <== NOT EXECUTED 40043f24: 7f ff 21 8c call 4000c554 <== NOT EXECUTED 40043f28: 98 20 40 0c sub %g1, %o4, %o4 <== NOT EXECUTED _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 40043f2c: d2 07 bf 98 ld [ %fp + -104 ], %o1 <== NOT EXECUTED 40043f30: 94 07 bf 58 add %fp, -168, %o2 <== NOT EXECUTED 40043f34: 40 00 04 a9 call 400451d8 <_Timespec_Divide_by_integer> <== NOT EXECUTED 40043f38: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED rtems_printf( printer, 40043f3c: c2 07 bf 60 ld [ %fp + -160 ], %g1 <== NOT EXECUTED 40043f40: c6 07 bf e8 ld [ %fp + -24 ], %g3 <== NOT EXECUTED 40043f44: 80 58 40 1c smul %g1, %i4, %g0 <== NOT EXECUTED 40043f48: 85 40 00 00 rd %y, %g2 <== NOT EXECUTED 40043f4c: 89 38 60 1f sra %g1, 0x1f, %g4 <== NOT EXECUTED 40043f50: 85 38 a0 06 sra %g2, 6, %g2 <== NOT EXECUTED 40043f54: 84 20 80 04 sub %g2, %g4, %g2 <== NOT EXECUTED 40043f58: 80 58 c0 1c smul %g3, %i4, %g0 <== NOT EXECUTED 40043f5c: 83 40 00 00 rd %y, %g1 <== NOT EXECUTED 40043f60: c4 23 a0 6c st %g2, [ %sp + 0x6c ] <== NOT EXECUTED 40043f64: 83 38 60 06 sra %g1, 6, %g1 <== NOT EXECUTED 40043f68: c4 07 bf 58 ld [ %fp + -168 ], %g2 <== NOT EXECUTED 40043f6c: 87 38 e0 1f sra %g3, 0x1f, %g3 <== NOT EXECUTED 40043f70: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED 40043f74: c4 23 a0 64 st %g2, [ %sp + 0x64 ] <== NOT EXECUTED 40043f78: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40043f7c: c4 07 bf 5c ld [ %fp + -164 ], %g2 <== NOT EXECUTED 40043f80: c2 23 a0 60 st %g1, [ %sp + 0x60 ] <== NOT EXECUTED 40043f84: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40043f88: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED 40043f8c: d8 07 bf d8 ld [ %fp + -40 ], %o4 <== NOT EXECUTED 40043f90: c2 23 a0 5c st %g1, [ %sp + 0x5c ] <== NOT EXECUTED 40043f94: 80 5b 00 1c smul %o4, %i4, %g0 <== NOT EXECUTED 40043f98: 83 40 00 00 rd %y, %g1 <== NOT EXECUTED 40043f9c: c4 23 a0 68 st %g2, [ %sp + 0x68 ] <== NOT EXECUTED 40043fa0: 83 38 60 06 sra %g1, 6, %g1 <== NOT EXECUTED 40043fa4: da 07 bf e0 ld [ %fp + -32 ], %o5 <== NOT EXECUTED 40043fa8: d4 1f bf d0 ldd [ %fp + -48 ], %o2 <== NOT EXECUTED 40043fac: 99 3b 20 1f sra %o4, 0x1f, %o4 <== NOT EXECUTED 40043fb0: 7f ff 21 69 call 4000c554 <== NOT EXECUTED 40043fb4: 98 20 40 0c sub %g1, %o4, %o4 <== NOT EXECUTED for ( id=_Rate_monotonic_Information.minimum_id ; 40043fb8: c2 06 e0 0c ld [ %i3 + 0xc ], %g1 <== NOT EXECUTED id++ ) { 40043fbc: ba 07 60 01 inc %i5 <== NOT EXECUTED for ( id=_Rate_monotonic_Information.minimum_id ; 40043fc0: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED 40043fc4: 0a 80 00 22 bcs 4004404c <== NOT EXECUTED 40043fc8: 01 00 00 00 nop <== NOT EXECUTED status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 40043fcc: 92 07 bf 98 add %fp, -104, %o1 <== NOT EXECUTED 40043fd0: 40 00 50 12 call 40058018 <== NOT EXECUTED 40043fd4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED (void) rtems_rate_monotonic_get_status( id, &the_status ); 40043fd8: 92 07 bf 68 add %fp, -152, %o1 <== NOT EXECUTED if ( status != RTEMS_SUCCESSFUL ) 40043fdc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40043fe0: 12 bf ff f6 bne 40043fb8 <== NOT EXECUTED 40043fe4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED (void) rtems_rate_monotonic_get_status( id, &the_status ); 40043fe8: 40 00 50 55 call 4005813c <== NOT EXECUTED 40043fec: 01 00 00 00 nop <== NOT EXECUTED rtems_object_get_name( the_status.owner, sizeof(name), name ); 40043ff0: d0 07 bf 68 ld [ %fp + -152 ], %o0 <== NOT EXECUTED 40043ff4: 94 07 bf 50 add %fp, -176, %o2 <== NOT EXECUTED 40043ff8: 40 00 00 43 call 40044104 <== NOT EXECUTED 40043ffc: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED rtems_printf( printer, 40044000: d8 1f bf 98 ldd [ %fp + -104 ], %o4 <== NOT EXECUTED 40044004: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 40044008: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4004400c: 96 07 bf 50 add %fp, -176, %o3 <== NOT EXECUTED 40044010: 7f ff 21 51 call 4000c554 <== NOT EXECUTED 40044014: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (the_stats.count == 0) { 40044018: c2 07 bf 98 ld [ %fp + -104 ], %g1 <== NOT EXECUTED _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average ); 4004401c: 94 07 bf 58 add %fp, -168, %o2 <== NOT EXECUTED if (the_stats.count == 0) { 40044020: 92 90 60 00 orcc %g1, 0, %o1 <== NOT EXECUTED 40044024: 12 bf ff a1 bne 40043ea8 <== NOT EXECUTED 40044028: 90 07 bf c0 add %fp, -64, %o0 <== NOT EXECUTED rtems_printf( printer, "\n" ); 4004402c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 40044030: 7f ff 21 49 call 4000c554 <== NOT EXECUTED 40044034: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED for ( id=_Rate_monotonic_Information.minimum_id ; 40044038: c2 06 e0 0c ld [ %i3 + 0xc ], %g1 <== NOT EXECUTED id++ ) { 4004403c: ba 07 60 01 inc %i5 <== NOT EXECUTED for ( id=_Rate_monotonic_Information.minimum_id ; 40044040: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED 40044044: 1a bf ff e3 bcc 40043fd0 <== NOT EXECUTED 40044048: 92 07 bf 98 add %fp, -104, %o1 <== NOT EXECUTED _Timespec_Get_seconds( &wall_average ), _Timespec_Get_nanoseconds( &wall_average ) / NANOSECONDS_DIVIDER ); } } } 4004404c: 81 c7 e0 08 ret <== NOT EXECUTED 40044050: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40044054 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 40044054: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED _RTEMS_Lock_allocator(); 40044058: 7f ff 57 0b call 40019c84 <_RTEMS_Lock_allocator> <== NOT EXECUTED 4004405c: 39 10 02 41 sethi %hi(0x40090400), %i4 <== NOT EXECUTED /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 40044060: b8 17 20 c0 or %i4, 0xc0, %i4 ! 400904c0 <_Rate_monotonic_Information> <== NOT EXECUTED 40044064: fa 07 20 08 ld [ %i4 + 8 ], %i5 <== NOT EXECUTED 40044068: c2 07 20 0c ld [ %i4 + 0xc ], %g1 <== NOT EXECUTED 4004406c: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED 40044070: 18 80 00 09 bgu 40044094 <== NOT EXECUTED 40044074: 01 00 00 00 nop <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; id++ ) { (void) rtems_rate_monotonic_reset_statistics( id ); 40044078: 40 00 00 09 call 4004409c <== NOT EXECUTED 4004407c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED for ( id=_Rate_monotonic_Information.minimum_id ; 40044080: c2 07 20 0c ld [ %i4 + 0xc ], %g1 <== NOT EXECUTED id++ ) { 40044084: ba 07 60 01 inc %i5 <== NOT EXECUTED for ( id=_Rate_monotonic_Information.minimum_id ; 40044088: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED 4004408c: 1a bf ff fb bcc 40044078 <== NOT EXECUTED 40044090: 01 00 00 00 nop <== NOT EXECUTED _RTEMS_Unlock_allocator(); 40044094: 7f ff 57 01 call 40019c98 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 40044098: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4004409c : #include rtems_status_code rtems_rate_monotonic_reset_statistics( rtems_id id ) { 4004409c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get( Objects_Id id, ISR_lock_Context *lock_context ) { return (Rate_monotonic_Control *) 400440a0: 15 10 02 41 sethi %hi(0x40090400), %o2 <== NOT EXECUTED 400440a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400440a8: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED 400440ac: 94 12 a0 c0 or %o2, 0xc0, %o2 <== NOT EXECUTED 400440b0: 40 00 01 fb call 4004489c <_Objects_Get> <== NOT EXECUTED 400440b4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED Rate_monotonic_Control *the_period; ISR_lock_Context lock_context; the_period = _Rate_monotonic_Get( id, &lock_context ); if ( the_period == NULL ) { 400440b8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400440bc: 02 80 00 10 be 400440fc <== NOT EXECUTED 400440c0: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED ) { Rate_monotonic_Statistics *statistics; statistics = &the_period->Statistics; memset( statistics, 0, sizeof( *statistics ) ); 400440c4: 94 10 20 38 mov 0x38, %o2 <== NOT EXECUTED 400440c8: 92 10 20 00 clr %o1 <== NOT EXECUTED 400440cc: 40 00 73 71 call 40060e90 <== NOT EXECUTED 400440d0: 90 02 20 68 add %o0, 0x68, %o0 <== NOT EXECUTED *_time = tstosbt(_ts); 400440d4: 05 1f ff ff sethi %hi(0x7ffffc00), %g2 <== NOT EXECUTED 400440d8: 07 09 70 5f sethi %hi(0x25c17c00), %g3 <== NOT EXECUTED 400440dc: 84 10 a3 ff or %g2, 0x3ff, %g2 <== NOT EXECUTED 400440e0: 86 10 e1 00 or %g3, 0x100, %g3 <== NOT EXECUTED 400440e4: c4 3f 60 88 std %g2, [ %i5 + 0x88 ] <== NOT EXECUTED 400440e8: c4 3f 60 70 std %g2, [ %i5 + 0x70 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400440ec: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400440f0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400440f4: 01 00 00 00 nop <== NOT EXECUTED } _Rate_monotonic_Acquire_critical( the_period, &lock_context ); _Rate_monotonic_Reset_statistics( the_period ); _Rate_monotonic_Release( the_period, &lock_context ); return RTEMS_SUCCESSFUL; 400440f8: b0 10 20 00 clr %i0 ! 0 <== NOT EXECUTED } 400440fc: 81 c7 e0 08 ret <== NOT EXECUTED 40044100: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000dc48 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 4000dc48: 9d e3 bf 70 save %sp, -144, %sp <== NOT EXECUTED Semaphore_Variant variant; const Scheduler_Control *scheduler; bool valid; Priority_Control priority; if ( !rtems_is_name_valid( name ) ) 4000dc4c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 4000dc50: 02 80 00 3b be 4000dd3c <== NOT EXECUTED 4000dc54: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 4000dc58: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED 4000dc5c: 02 80 00 74 be 4000de2c <== NOT EXECUTED 4000dc60: 84 8e a1 f0 andcc %i2, 0x1f0, %g2 <== NOT EXECUTED /* Attribute subset defining a mutex variant with a locking protocol */ mutex_with_protocol = attribute_set & ( SEMAPHORE_KIND_MASK | RTEMS_GLOBAL | RTEMS_PRIORITY ); if ( maybe_global == RTEMS_COUNTING_SEMAPHORE ) { 4000dc64: 02 80 00 12 be 4000dcac <== NOT EXECUTED 4000dc68: 80 a6 60 01 cmp %i1, 1 <== NOT EXECUTED variant = SEMAPHORE_VARIANT_COUNTING; } else if ( count > 1 ) { 4000dc6c: 18 80 00 34 bgu 4000dd3c <== NOT EXECUTED 4000dc70: 82 10 20 0a mov 0xa, %g1 <== NOT EXECUTED /* * The remaining variants are all binary semphores, thus reject an invalid * count value. */ return RTEMS_INVALID_NUMBER; } else if ( maybe_global == RTEMS_SIMPLE_BINARY_SEMAPHORE ) { 4000dc74: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED 4000dc78: 02 80 00 33 be 4000dd44 <== NOT EXECUTED 4000dc7c: 80 a0 a0 10 cmp %g2, 0x10 <== NOT EXECUTED variant = SEMAPHORE_VARIANT_SIMPLE_BINARY; } else if ( maybe_global == RTEMS_BINARY_SEMAPHORE ) { 4000dc80: 02 80 00 6e be 4000de38 <== NOT EXECUTED 4000dc84: 84 0e a1 f6 and %i2, 0x1f6, %g2 <== NOT EXECUTED variant = SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL; } else if ( 4000dc88: 80 a0 a0 54 cmp %g2, 0x54 <== NOT EXECUTED 4000dc8c: 02 80 00 71 be 4000de50 <== NOT EXECUTED 4000dc90: 80 a0 a0 94 cmp %g2, 0x94 <== NOT EXECUTED } else if ( mutex_with_protocol == ( RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_PRIORITY_CEILING ) ) { variant = SEMAPHORE_VARIANT_MUTEX_PRIORITY_CEILING; } else if ( 4000dc94: 02 80 00 04 be 4000dca4 <== NOT EXECUTED 4000dc98: 80 a0 a1 10 cmp %g2, 0x110 <== NOT EXECUTED 4000dc9c: 12 80 00 28 bne 4000dd3c <== NOT EXECUTED 4000dca0: 82 10 20 0b mov 0xb, %g1 <== NOT EXECUTED 4000dca4: 10 80 00 03 b 4000dcb0 <== NOT EXECUTED 4000dca8: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED variant = SEMAPHORE_VARIANT_COUNTING; 4000dcac: a0 10 20 04 mov 4, %l0 <== NOT EXECUTED * This function allocates a semaphore control block from * the inactive chain of free semaphore control blocks. */ RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void ) { return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information ); 4000dcb0: 23 10 00 d1 sethi %hi(0x40034400), %l1 <== NOT EXECUTED 4000dcb4: 40 00 0d a5 call 40011348 <_Objects_Allocate> <== NOT EXECUTED 4000dcb8: 90 14 63 34 or %l1, 0x334, %o0 ! 40034734 <_Semaphore_Information> <== NOT EXECUTED return RTEMS_NOT_DEFINED; } the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 4000dcbc: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED 4000dcc0: 02 80 00 60 be 4000de40 <== NOT EXECUTED 4000dcc4: 84 0c 20 07 and %l0, 7, %g2 <== NOT EXECUTED } #endif executing = _Thread_Get_executing(); the_semaphore->variant = variant; 4000dcc8: c2 0f 60 38 ldub [ %i5 + 0x38 ], %g1 <== NOT EXECUTED 4000dccc: e4 01 a0 20 ld [ %g6 + 0x20 ], %l2 <== NOT EXECUTED 4000dcd0: 82 08 60 1f and %g1, 0x1f, %g1 <== NOT EXECUTED 4000dcd4: 87 28 a0 05 sll %g2, 5, %g3 <== NOT EXECUTED 4000dcd8: 82 10 40 03 or %g1, %g3, %g1 <== NOT EXECUTED if ( _Attributes_Is_priority( attribute_set ) ) { 4000dcdc: 80 8e a0 04 btst 4, %i2 <== NOT EXECUTED 4000dce0: 02 80 00 1b be 4000dd4c <== NOT EXECUTED 4000dce4: c2 2f 60 38 stb %g1, [ %i5 + 0x38 ] <== NOT EXECUTED the_semaphore->discipline = SEMAPHORE_DISCIPLINE_PRIORITY; 4000dce8: 82 08 7f ef and %g1, -17, %g1 <== NOT EXECUTED } else { the_semaphore->discipline = SEMAPHORE_DISCIPLINE_FIFO; } switch ( the_semaphore->variant ) { 4000dcec: 84 08 a0 ff and %g2, 0xff, %g2 <== NOT EXECUTED 4000dcf0: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 4000dcf4: 02 80 00 1b be 4000dd60 <== NOT EXECUTED 4000dcf8: c2 2f 60 38 stb %g1, [ %i5 + 0x38 ] <== NOT EXECUTED 4000dcfc: 0a 80 00 45 bcs 4000de10 <== NOT EXECUTED 4000dd00: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED 4000dd04: 02 80 00 43 be 4000de10 <== NOT EXECUTED 4000dd08: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED default: _Assert( the_semaphore->variant == SEMAPHORE_VARIANT_SIMPLE_BINARY || the_semaphore->variant == SEMAPHORE_VARIANT_COUNTING ); _CORE_semaphore_Initialize( 4000dd0c: 40 00 05 8f call 4000f348 <_CORE_semaphore_Initialize> <== NOT EXECUTED 4000dd10: 90 07 60 10 add %i5, 0x10, %o0 <== NOT EXECUTED information->local_table[ index ] = the_object; 4000dd14: c2 17 60 0a lduh [ %i5 + 0xa ], %g1 <== NOT EXECUTED the_object->name = name; 4000dd18: f0 27 60 0c st %i0, [ %i5 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000dd1c: a2 14 63 34 or %l1, 0x334, %l1 <== NOT EXECUTED 4000dd20: c6 04 60 1c ld [ %l1 + 0x1c ], %g3 <== NOT EXECUTED 4000dd24: c4 07 60 08 ld [ %i5 + 8 ], %g2 <== NOT EXECUTED 4000dd28: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 4000dd2c: fa 20 c0 01 st %i5, [ %g3 + %g1 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 4000dd30: 40 00 05 3d call 4000f224 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 4000dd34: c4 27 00 00 st %g2, [ %i4 ] <== NOT EXECUTED name, 0 /* Not used */ ); #endif _Objects_Allocator_unlock(); return RTEMS_SUCCESSFUL; 4000dd38: 82 10 20 00 clr %g1 <== NOT EXECUTED } 4000dd3c: 81 c7 e0 08 ret <== NOT EXECUTED 4000dd40: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED variant = SEMAPHORE_VARIANT_SIMPLE_BINARY; 4000dd44: 10 bf ff db b 4000dcb0 <== NOT EXECUTED 4000dd48: a0 10 20 03 mov 3, %l0 <== NOT EXECUTED the_semaphore->discipline = SEMAPHORE_DISCIPLINE_FIFO; 4000dd4c: 82 10 60 10 or %g1, 0x10, %g1 <== NOT EXECUTED switch ( the_semaphore->variant ) { 4000dd50: 84 08 a0 ff and %g2, 0xff, %g2 <== NOT EXECUTED 4000dd54: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 4000dd58: 12 bf ff e9 bne 4000dcfc <== NOT EXECUTED 4000dd5c: c2 2f 60 38 stb %g1, [ %i5 + 0x38 ] <== NOT EXECUTED const Scheduler_Control *scheduler, rtems_task_priority priority, bool *valid ) { *valid = ( priority <= scheduler->maximum_priority ); 4000dd60: 11 10 00 b5 sethi %hi(0x4002d400), %o0 <== NOT EXECUTED 4000dd64: 90 12 20 b8 or %o0, 0xb8, %o0 ! 4002d4b8 <_Scheduler_Table> <== NOT EXECUTED return ( *scheduler->Operations.map_priority )( scheduler, priority ); 4000dd68: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED 4000dd6c: f4 02 20 40 ld [ %o0 + 0x40 ], %i2 <== NOT EXECUTED 4000dd70: e0 02 20 44 ld [ %o0 + 0x44 ], %l0 <== NOT EXECUTED 4000dd74: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000dd78: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000dd7c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED if ( valid ) { 4000dd80: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 4000dd84: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED 4000dd88: 02 80 00 34 be 4000de58 <== NOT EXECUTED 4000dd8c: aa 10 00 09 mov %o1, %l5 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex ) { _Thread_queue_Object_initialize( &the_mutex->Wait_queue ); 4000dd90: 40 00 16 9a call 400137f8 <_Thread_queue_Object_initialize> <== NOT EXECUTED 4000dd94: 90 07 60 10 add %i5, 0x10, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _CORE_recursive_mutex_Initialize( CORE_recursive_mutex_Control *the_mutex ) { _CORE_mutex_Initialize( &the_mutex->Mutex ); the_mutex->nest_level = 0; 4000dd98: c0 27 60 1c clr [ %i5 + 0x1c ] <== NOT EXECUTED if ( count == 0 ) { 4000dd9c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4000dda0: 12 bf ff dd bne 4000dd14 <== NOT EXECUTED 4000dda4: e8 3f 60 30 std %l4, [ %i5 + 0x30 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_queue_Context_clear_priority_updates( Thread_queue_Context *queue_context ) { queue_context->Priority.update_count = 0; 4000dda8: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000ddac: 91 d0 20 09 ta 9 <== NOT EXECUTED _ISR_lock_ISR_disable( &queue_context.Lock_context.Lock_context ); 4000ddb0: c2 27 bf dc st %g1, [ %fp + -36 ] <== NOT EXECUTED _Thread_Wait_acquire_default_critical( owner, &lock_context ); scheduler_node = _Thread_Scheduler_get_home_node( owner ); if ( 4000ddb4: c2 04 a0 38 ld [ %l2 + 0x38 ], %g1 <== NOT EXECUTED 4000ddb8: c6 07 60 30 ld [ %i5 + 0x30 ], %g3 <== NOT EXECUTED 4000ddbc: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 <== NOT EXECUTED 4000ddc0: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED 4000ddc4: 18 80 00 09 bgu 4000dde8 <== NOT EXECUTED 4000ddc8: 01 00 00 00 nop <== NOT EXECUTED 4000ddcc: 32 80 00 27 bne,a 4000de68 <== NOT EXECUTED 4000ddd0: e4 27 60 14 st %l2, [ %i5 + 0x14 ] <== NOT EXECUTED 4000ddd4: c4 07 60 34 ld [ %i5 + 0x34 ], %g2 <== NOT EXECUTED 4000ddd8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 4000dddc: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 4000dde0: 28 80 00 22 bleu,a 4000de68 <== NOT EXECUTED 4000dde4: e4 27 60 14 st %l2, [ %i5 + 0x14 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000dde8: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000ddec: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ddf0: 01 00 00 00 nop <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 4000ddf4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4000ddf8: 40 00 0e 25 call 4001168c <_Objects_Free> <== NOT EXECUTED 4000ddfc: 90 14 63 34 or %l1, 0x334, %o0 <== NOT EXECUTED 4000de00: 40 00 05 09 call 4000f224 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 4000de04: 01 00 00 00 nop <== NOT EXECUTED return _Status_Get( status ); 4000de08: 10 bf ff cd b 4000dd3c <== NOT EXECUTED 4000de0c: 82 10 20 13 mov 0x13, %g1 ! 13 <_TLS_Alignment+0x12> <== NOT EXECUTED _Thread_queue_Object_initialize( &the_mutex->Wait_queue ); 4000de10: 40 00 16 7a call 400137f8 <_Thread_queue_Object_initialize> <== NOT EXECUTED 4000de14: 90 07 60 10 add %i5, 0x10, %o0 <== NOT EXECUTED if ( count == 0 ) { 4000de18: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4000de1c: 12 bf ff be bne 4000dd14 <== NOT EXECUTED 4000de20: c0 27 60 1c clr [ %i5 + 0x1c ] <== NOT EXECUTED the_mutex->Wait_queue.Queue.owner = owner; 4000de24: 10 bf ff bc b 4000dd14 <== NOT EXECUTED 4000de28: e4 27 60 14 st %l2, [ %i5 + 0x14 ] <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 4000de2c: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED } 4000de30: 81 c7 e0 08 ret <== NOT EXECUTED 4000de34: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED variant = SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL; 4000de38: 10 bf ff 9e b 4000dcb0 <== NOT EXECUTED 4000de3c: a0 10 20 02 mov 2, %l0 <== NOT EXECUTED 4000de40: 40 00 04 f9 call 4000f224 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 4000de44: 01 00 00 00 nop <== NOT EXECUTED return RTEMS_TOO_MANY; 4000de48: 10 bf ff bd b 4000dd3c <== NOT EXECUTED 4000de4c: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4> <== NOT EXECUTED variant = SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY; 4000de50: 10 bf ff 98 b 4000dcb0 <== NOT EXECUTED 4000de54: a0 10 20 00 clr %l0 <== NOT EXECUTED if ( valid ) { 4000de58: 80 a6 c0 10 cmp %i3, %l0 <== NOT EXECUTED 4000de5c: 08 bf ff cd bleu 4000dd90 <== NOT EXECUTED 4000de60: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4000de64: 30 bf ff e5 b,a 4000ddf8 <== NOT EXECUTED return STATUS_MUTEX_CEILING_VIOLATED; } _CORE_mutex_Set_owner( &the_mutex->Recursive.Mutex, owner ); _Thread_Resource_count_increment( owner ); _Thread_Priority_add( 4000de68: 92 07 60 20 add %i5, 0x20, %o1 <== NOT EXECUTED 4000de6c: 94 07 bf dc add %fp, -36, %o2 <== NOT EXECUTED 4000de70: 40 00 14 2e call 40012f28 <_Thread_Priority_add> <== NOT EXECUTED 4000de74: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 4000de78: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000de7c: 82 00 60 01 inc %g1 <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000de80: b6 10 00 06 mov %g6, %i3 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000de84: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000de88: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000de8c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000de90: 01 00 00 00 nop <== NOT EXECUTED ); _Thread_Wait_release_default_critical( owner, &lock_context ); cpu_self = _Thread_queue_Dispatch_disable( queue_context ); _CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context ); _Thread_Priority_update( queue_context ); 4000de94: 40 00 14 36 call 40012f6c <_Thread_Priority_update> <== NOT EXECUTED 4000de98: 90 07 bf dc add %fp, -36, %o0 <== NOT EXECUTED uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000de9c: c2 06 e0 18 ld [ %i3 + 0x18 ], %g1 <== NOT EXECUTED if ( disable_level == 1 ) { 4000dea0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000dea4: 02 80 00 05 be 4000deb8 <== NOT EXECUTED 4000dea8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000deac: c2 26 e0 18 st %g1, [ %i3 + 0x18 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000deb0: 10 bf ff 9a b 4000dd18 <== NOT EXECUTED 4000deb4: c2 17 60 0a lduh [ %i5 + 0xa ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000deb8: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000debc: c4 0e e0 1c ldub [ %i3 + 0x1c ], %g2 <== NOT EXECUTED 4000dec0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000dec4: 12 80 00 07 bne 4000dee0 <== NOT EXECUTED 4000dec8: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = 0; 4000decc: c0 26 e0 18 clr [ %i3 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000ded0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ded4: 01 00 00 00 nop <== NOT EXECUTED 4000ded8: 10 bf ff 90 b 4000dd18 <== NOT EXECUTED 4000dedc: c2 17 60 0a lduh [ %i5 + 0xa ], %g1 <== NOT EXECUTED _Thread_Do_dispatch( cpu_self, level ); 4000dee0: c2 27 bf d4 st %g1, [ %fp + -44 ] <== NOT EXECUTED 4000dee4: 40 00 14 a9 call 40013188 <_Thread_Do_dispatch> <== NOT EXECUTED 4000dee8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 4000deec: 10 bf ff f9 b 4000ded0 <== NOT EXECUTED 4000def0: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED =============================================================================== 4000def4 : #include rtems_status_code rtems_semaphore_delete( rtems_id id ) { 4000def4: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED _RTEMS_Lock_allocator(); 4000def8: 40 00 04 c6 call 4000f210 <_RTEMS_Lock_allocator> <== NOT EXECUTED 4000defc: 39 10 00 d1 sethi %hi(0x40034400), %i4 <== NOT EXECUTED Objects_Id id, Thread_queue_Context *queue_context ) { _Thread_queue_Context_initialize( queue_context ); return (Semaphore_Control *) _Objects_Get( 4000df00: 92 07 bf dc add %fp, -36, %o1 <== NOT EXECUTED 4000df04: 94 17 23 34 or %i4, 0x334, %o2 <== NOT EXECUTED 4000df08: 40 00 0e 13 call 40011754 <_Objects_Get> <== NOT EXECUTED 4000df0c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Status_Control status; _Objects_Allocator_lock(); the_semaphore = _Semaphore_Get( id, &queue_context ); if ( the_semaphore == NULL ) { 4000df10: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED 4000df14: 02 80 00 43 be 4000e020 <== NOT EXECUTED 4000df18: 01 00 00 00 nop <== NOT EXECUTED _Thread_queue_Acquire_critical( &the_semaphore->Core_control.Wait_queue, &queue_context ); switch ( the_semaphore->variant ) { 4000df1c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED 4000df20: 83 30 60 1d srl %g1, 0x1d, %g1 <== NOT EXECUTED 4000df24: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000df28: 18 80 00 06 bgu 4000df40 <== NOT EXECUTED 4000df2c: 90 17 23 34 or %i4, 0x334, %o0 <== NOT EXECUTED case SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY: case SEMAPHORE_VARIANT_MUTEX_PRIORITY_CEILING: case SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL: if ( 4000df30: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED 4000df34: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000df38: 12 80 00 26 bne 4000dfd0 <== NOT EXECUTED 4000df3c: 01 00 00 00 nop <== NOT EXECUTED ); _Objects_Allocator_unlock(); return _Status_Get( status ); } _Objects_Close( &_Semaphore_Information, &the_semaphore->Object ); 4000df40: 40 00 0d 07 call 4001135c <_Objects_Close> <== NOT EXECUTED 4000df44: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED if ( the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY ) { 4000df48: c2 0f 60 38 ldub [ %i5 + 0x38 ], %g1 <== NOT EXECUTED 4000df4c: 80 88 60 e0 btst 0xe0, %g1 <== NOT EXECUTED 4000df50: 12 80 00 10 bne 4000df90 <== NOT EXECUTED 4000df54: 90 07 60 10 add %i5, 0x10, %o0 <== NOT EXECUTED || the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_PRIORITY_CEILING || the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL || the_semaphore->variant == SEMAPHORE_VARIANT_SIMPLE_BINARY || the_semaphore->variant == SEMAPHORE_VARIANT_COUNTING ); _Thread_queue_Flush_critical( 4000df58: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED return &_Thread_queue_Operations_priority_inherit; 4000df5c: 13 10 00 bb sethi %hi(0x4002ec00), %o1 <== NOT EXECUTED 4000df60: 15 10 00 4f sethi %hi(0x40013c00), %o2 <== NOT EXECUTED 4000df64: 92 12 63 cc or %o1, 0x3cc, %o1 <== NOT EXECUTED 4000df68: 40 00 17 7e call 40013d60 <_Thread_queue_Flush_critical> <== NOT EXECUTED 4000df6c: 94 12 a1 50 or %o2, 0x150, %o2 <== NOT EXECUTED _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 4000df70: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4000df74: 90 17 23 34 or %i4, 0x334, %o0 <== NOT EXECUTED 4000df78: 40 00 0d c5 call 4001168c <_Objects_Free> <== NOT EXECUTED 4000df7c: b0 10 20 00 clr %i0 <== NOT EXECUTED _RTEMS_Unlock_allocator(); 4000df80: 40 00 04 a9 call 4000f224 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 4000df84: 01 00 00 00 nop <== NOT EXECUTED #endif _Semaphore_Free( the_semaphore ); _Objects_Allocator_unlock(); return RTEMS_SUCCESSFUL; } 4000df88: 81 c7 e0 08 ret <== NOT EXECUTED 4000df8c: 81 e8 00 00 restore <== NOT EXECUTED if ( the_semaphore->discipline == SEMAPHORE_DISCIPLINE_PRIORITY ) { 4000df90: 80 88 60 10 btst 0x10, %g1 <== NOT EXECUTED 4000df94: 12 80 00 16 bne 4000dfec <== NOT EXECUTED 4000df98: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED return &_Thread_queue_Operations_priority; 4000df9c: 13 10 00 bb sethi %hi(0x4002ec00), %o1 <== NOT EXECUTED _Thread_queue_Flush_critical( 4000dfa0: 15 10 00 4f sethi %hi(0x40013c00), %o2 <== NOT EXECUTED 4000dfa4: 92 12 63 e0 or %o1, 0x3e0, %o1 <== NOT EXECUTED 4000dfa8: 40 00 17 6e call 40013d60 <_Thread_queue_Flush_critical> <== NOT EXECUTED 4000dfac: 94 12 a1 50 or %o2, 0x150, %o2 <== NOT EXECUTED _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 4000dfb0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4000dfb4: 90 17 23 34 or %i4, 0x334, %o0 <== NOT EXECUTED 4000dfb8: 40 00 0d b5 call 4001168c <_Objects_Free> <== NOT EXECUTED 4000dfbc: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000dfc0: 40 00 04 99 call 4000f224 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 4000dfc4: 01 00 00 00 nop <== NOT EXECUTED } 4000dfc8: 81 c7 e0 08 ret <== NOT EXECUTED 4000dfcc: 81 e8 00 00 restore <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000dfd0: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000dfd4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000dfd8: 01 00 00 00 nop <== NOT EXECUTED 4000dfdc: 40 00 04 92 call 4000f224 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 4000dfe0: b0 10 20 0c mov 0xc, %i0 ! c <_TLS_Alignment+0xb> <== NOT EXECUTED return _Status_Get( status ); 4000dfe4: 81 c7 e0 08 ret <== NOT EXECUTED 4000dfe8: 81 e8 00 00 restore <== NOT EXECUTED return &_Thread_queue_Operations_FIFO; 4000dfec: 13 10 00 bb sethi %hi(0x4002ec00), %o1 <== NOT EXECUTED _Thread_queue_Flush_critical( 4000dff0: 15 10 00 4f sethi %hi(0x40013c00), %o2 <== NOT EXECUTED 4000dff4: 92 12 63 f4 or %o1, 0x3f4, %o1 <== NOT EXECUTED 4000dff8: 40 00 17 5a call 40013d60 <_Thread_queue_Flush_critical> <== NOT EXECUTED 4000dffc: 94 12 a1 50 or %o2, 0x150, %o2 <== NOT EXECUTED _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 4000e000: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4000e004: 90 17 23 34 or %i4, 0x334, %o0 <== NOT EXECUTED 4000e008: 40 00 0d a1 call 4001168c <_Objects_Free> <== NOT EXECUTED 4000e00c: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000e010: 40 00 04 85 call 4000f224 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 4000e014: 01 00 00 00 nop <== NOT EXECUTED } 4000e018: 81 c7 e0 08 ret <== NOT EXECUTED 4000e01c: 81 e8 00 00 restore <== NOT EXECUTED 4000e020: 40 00 04 81 call 4000f224 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 4000e024: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED return RTEMS_INVALID_ID; 4000e028: 81 c7 e0 08 ret <== NOT EXECUTED 4000e02c: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000e030 : rtems_status_code rtems_semaphore_obtain( rtems_id id, rtems_option option_set, rtems_interval timeout ) { 4000e030: 9d e3 bf 70 save %sp, -144, %sp <== NOT EXECUTED return (Semaphore_Control *) _Objects_Get( 4000e034: 15 10 00 d1 sethi %hi(0x40034400), %o2 <== NOT EXECUTED 4000e038: 92 07 bf dc add %fp, -36, %o1 <== NOT EXECUTED 4000e03c: 94 12 a3 34 or %o2, 0x334, %o2 <== NOT EXECUTED 4000e040: 40 00 0d c5 call 40011754 <_Objects_Get> <== NOT EXECUTED 4000e044: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED bool wait; Status_Control status; the_semaphore = _Semaphore_Get( id, &queue_context ); if ( the_semaphore == NULL ) { 4000e048: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000e04c: 02 80 00 6c be 4000e1fc <== NOT EXECUTED 4000e050: 96 38 00 19 xnor %g0, %i1, %o3 <== NOT EXECUTED #else return RTEMS_INVALID_ID; #endif } executing = _Thread_Executing; 4000e054: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5 <== NOT EXECUTED wait = !_Options_Is_no_wait( option_set ); if ( wait ) { 4000e058: b2 8e 60 01 andcc %i1, 1, %i1 <== NOT EXECUTED 4000e05c: 02 80 00 21 be 4000e0e0 <== NOT EXECUTED 4000e060: 96 0a e0 01 and %o3, 1, %o3 <== NOT EXECUTED queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra; 4000e064: 03 10 00 4e sethi %hi(0x40013800), %g1 <== NOT EXECUTED 4000e068: 82 10 61 24 or %g1, 0x124, %g1 ! 40013924 <_Thread_queue_Enqueue_do_nothing_extra> <== NOT EXECUTED 4000e06c: c2 27 bf e4 st %g1, [ %fp + -28 ] <== NOT EXECUTED _Thread_queue_Context_set_enqueue_timeout_ticks( &queue_context, timeout ); } else { _Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context ); } switch ( the_semaphore->variant ) { 4000e070: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 <== NOT EXECUTED 4000e074: 83 30 60 1d srl %g1, 0x1d, %g1 <== NOT EXECUTED 4000e078: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000e07c: 02 80 00 22 be 4000e104 <== NOT EXECUTED 4000e080: 84 02 20 10 add %o0, 0x10, %g2 <== NOT EXECUTED 4000e084: 0a 80 00 42 bcs 4000e18c <== NOT EXECUTED 4000e088: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000e08c: 12 80 00 2d bne 4000e140 <== NOT EXECUTED 4000e090: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1 <== NOT EXECUTED if ( the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY ) { 4000e094: 80 88 60 e0 btst 0xe0, %g1 <== NOT EXECUTED 4000e098: 12 80 00 4e bne 4000e1d0 <== NOT EXECUTED 4000e09c: 80 88 60 10 btst 0x10, %g1 <== NOT EXECUTED return &_Thread_queue_Operations_priority_inherit; 4000e0a0: 13 10 00 bb sethi %hi(0x4002ec00), %o1 <== NOT EXECUTED 4000e0a4: 92 12 63 cc or %o1, 0x3cc, %o1 ! 4002efcc <_Thread_queue_Operations_priority_inherit> <== NOT EXECUTED 4000e0a8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 <== NOT EXECUTED if ( owner == NULL ) { 4000e0ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000e0b0: 02 80 00 4d be 4000e1e4 <== NOT EXECUTED 4000e0b4: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED if ( owner == executing ) { 4000e0b8: 12 80 00 74 bne 4000e288 <== NOT EXECUTED 4000e0bc: 98 07 bf dc add %fp, -36, %o4 <== NOT EXECUTED ++the_mutex->nest_level; 4000e0c0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED 4000e0c4: 82 00 60 01 inc %g1 <== NOT EXECUTED { _Assert( _ISR_Get_level() != 0 ); _CORE_semaphore_Acquire_critical( the_semaphore, queue_context ); if ( the_semaphore->count != 0 ) { the_semaphore->count -= 1; 4000e0c8: c2 22 20 1c st %g1, [ %o0 + 0x1c ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e0cc: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e0d0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e0d4: 01 00 00 00 nop <== NOT EXECUTED 4000e0d8: 81 c7 e0 08 ret <== NOT EXECUTED 4000e0dc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks; 4000e0e0: 03 10 00 52 sethi %hi(0x40014800), %g1 <== NOT EXECUTED queue_context->Timeout.ticks = ticks; 4000e0e4: f4 27 bf e8 st %i2, [ %fp + -24 ] <== NOT EXECUTED queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks; 4000e0e8: 82 10 61 44 or %g1, 0x144, %g1 <== NOT EXECUTED 4000e0ec: c2 27 bf e4 st %g1, [ %fp + -28 ] <== NOT EXECUTED 4000e0f0: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 <== NOT EXECUTED 4000e0f4: 83 30 60 1d srl %g1, 0x1d, %g1 <== NOT EXECUTED 4000e0f8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000e0fc: 12 bf ff e2 bne 4000e084 <== NOT EXECUTED 4000e100: 84 02 20 10 add %o0, 0x10, %g2 <== NOT EXECUTED 4000e104: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 <== NOT EXECUTED _CORE_mutex_Acquire_critical( &the_mutex->Recursive.Mutex, queue_context ); owner = _CORE_mutex_Get_owner( &the_mutex->Recursive.Mutex ); if ( owner == NULL ) { 4000e108: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000e10c: 02 80 00 4c be 4000e23c <== NOT EXECUTED 4000e110: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED executing, queue_context ); } if ( owner == executing ) { 4000e114: 22 bf ff ec be,a 4000e0c4 <== NOT EXECUTED 4000e118: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED status = ( *nested )( &the_mutex->Recursive ); _CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context ); return status; } return _CORE_mutex_Seize_slow( 4000e11c: 98 07 bf dc add %fp, -36, %o4 <== NOT EXECUTED 4000e120: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 4000e124: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED 4000e128: 13 10 00 bb sethi %hi(0x4002ec00), %o1 <== NOT EXECUTED 4000e12c: 40 00 04 6f call 4000f2e8 <_CORE_mutex_Seize_slow> <== NOT EXECUTED 4000e130: 92 12 63 e0 or %o1, 0x3e0, %o1 ! 4002efe0 <_Thread_queue_Operations_priority> <== NOT EXECUTED 4000e134: b0 0a 60 ff and %o1, 0xff, %i0 <== NOT EXECUTED 4000e138: 81 c7 e0 08 ret <== NOT EXECUTED 4000e13c: 81 e8 00 00 restore <== NOT EXECUTED if ( the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY ) { 4000e140: 80 88 60 e0 btst 0xe0, %g1 <== NOT EXECUTED 4000e144: 02 80 00 21 be 4000e1c8 <== NOT EXECUTED 4000e148: 13 10 00 bb sethi %hi(0x4002ec00), %o1 <== NOT EXECUTED if ( the_semaphore->discipline == SEMAPHORE_DISCIPLINE_PRIORITY ) { 4000e14c: 80 88 60 10 btst 0x10, %g1 <== NOT EXECUTED 4000e150: 12 80 00 37 bne 4000e22c <== NOT EXECUTED 4000e154: 13 10 00 bb sethi %hi(0x4002ec00), %o1 <== NOT EXECUTED return &_Thread_queue_Operations_priority; 4000e158: 13 10 00 bb sethi %hi(0x4002ec00), %o1 <== NOT EXECUTED 4000e15c: 92 12 63 e0 or %o1, 0x3e0, %o1 ! 4002efe0 <_Thread_queue_Operations_priority> <== NOT EXECUTED if ( the_semaphore->count != 0 ) { 4000e160: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED 4000e164: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000e168: 12 80 00 27 bne 4000e204 <== NOT EXECUTED 4000e16c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED _CORE_semaphore_Release( the_semaphore, queue_context ); return STATUS_SUCCESSFUL; } if ( !wait ) { 4000e170: 02 80 00 27 be 4000e20c <== NOT EXECUTED 4000e174: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e178: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e17c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e180: 01 00 00 00 nop <== NOT EXECUTED 4000e184: 81 c7 e0 08 ret <== NOT EXECUTED 4000e188: 91 e8 20 0d restore %g0, 0xd, %o0 <== NOT EXECUTED 4000e18c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 <== NOT EXECUTED if ( owner == NULL ) { 4000e190: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000e194: 02 80 00 14 be 4000e1e4 <== NOT EXECUTED 4000e198: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED if ( owner == executing ) { 4000e19c: 22 bf ff ca be,a 4000e0c4 <== NOT EXECUTED 4000e1a0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED return _CORE_mutex_Seize_slow( 4000e1a4: 98 07 bf dc add %fp, -36, %o4 <== NOT EXECUTED 4000e1a8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 4000e1ac: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED 4000e1b0: 13 10 00 bb sethi %hi(0x4002ec00), %o1 <== NOT EXECUTED 4000e1b4: 40 00 04 4d call 4000f2e8 <_CORE_mutex_Seize_slow> <== NOT EXECUTED 4000e1b8: 92 12 63 cc or %o1, 0x3cc, %o1 ! 4002efcc <_Thread_queue_Operations_priority_inherit> <== NOT EXECUTED 4000e1bc: b0 0a 60 ff and %o1, 0xff, %i0 <== NOT EXECUTED 4000e1c0: 81 c7 e0 08 ret <== NOT EXECUTED 4000e1c4: 81 e8 00 00 restore <== NOT EXECUTED return &_Thread_queue_Operations_priority_inherit; 4000e1c8: 10 bf ff e6 b 4000e160 <== NOT EXECUTED 4000e1cc: 92 12 63 cc or %o1, 0x3cc, %o1 <== NOT EXECUTED if ( the_semaphore->discipline == SEMAPHORE_DISCIPLINE_PRIORITY ) { 4000e1d0: 32 80 00 19 bne,a 4000e234 <== NOT EXECUTED 4000e1d4: 13 10 00 bb sethi %hi(0x4002ec00), %o1 <== NOT EXECUTED return &_Thread_queue_Operations_priority; 4000e1d8: 13 10 00 bb sethi %hi(0x4002ec00), %o1 <== NOT EXECUTED 4000e1dc: 10 bf ff b3 b 4000e0a8 <== NOT EXECUTED 4000e1e0: 92 12 63 e0 or %o1, 0x3e0, %o1 ! 4002efe0 <_Thread_queue_Operations_priority> <== NOT EXECUTED the_mutex->Wait_queue.Queue.owner = owner; 4000e1e4: fa 22 20 14 st %i5, [ %o0 + 0x14 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e1e8: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e1ec: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e1f0: 01 00 00 00 nop <== NOT EXECUTED 4000e1f4: 81 c7 e0 08 ret <== NOT EXECUTED 4000e1f8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED ); break; } return _Status_Get( status ); } 4000e1fc: 81 c7 e0 08 ret <== NOT EXECUTED 4000e200: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED the_semaphore->count -= 1; 4000e204: 10 bf ff b1 b 4000e0c8 <== NOT EXECUTED 4000e208: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED _Thread_queue_Context_set_thread_state( queue_context, STATES_WAITING_FOR_SEMAPHORE ); _Thread_queue_Enqueue( 4000e20c: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED queue_context->thread_state = thread_state; 4000e210: c2 27 bf e0 st %g1, [ %fp + -32 ] <== NOT EXECUTED 4000e214: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 4000e218: 40 00 15 cd call 4001394c <_Thread_queue_Enqueue> <== NOT EXECUTED 4000e21c: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED 4000e220: f0 0f 60 4f ldub [ %i5 + 0x4f ], %i0 <== NOT EXECUTED return _Status_Get( status ); 4000e224: 81 c7 e0 08 ret <== NOT EXECUTED 4000e228: 81 e8 00 00 restore <== NOT EXECUTED return &_Thread_queue_Operations_FIFO; 4000e22c: 10 bf ff cd b 4000e160 <== NOT EXECUTED 4000e230: 92 12 63 f4 or %o1, 0x3f4, %o1 <== NOT EXECUTED 4000e234: 10 bf ff 9d b 4000e0a8 <== NOT EXECUTED 4000e238: 92 12 63 f4 or %o1, 0x3f4, %o1 <== NOT EXECUTED if ( 4000e23c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED queue_context->Priority.update_count = 0; 4000e240: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED 4000e244: c6 02 20 30 ld [ %o0 + 0x30 ], %g3 <== NOT EXECUTED 4000e248: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 <== NOT EXECUTED 4000e24c: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED 4000e250: 18 80 00 09 bgu 4000e274 <== NOT EXECUTED 4000e254: 01 00 00 00 nop <== NOT EXECUTED 4000e258: 32 80 00 12 bne,a 4000e2a0 <== NOT EXECUTED 4000e25c: fa 22 20 14 st %i5, [ %o0 + 0x14 ] <== NOT EXECUTED 4000e260: c4 02 20 34 ld [ %o0 + 0x34 ], %g2 <== NOT EXECUTED 4000e264: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 4000e268: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 4000e26c: 28 80 00 0d bleu,a 4000e2a0 <== NOT EXECUTED 4000e270: fa 22 20 14 st %i5, [ %o0 + 0x14 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e274: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e278: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e27c: 01 00 00 00 nop <== NOT EXECUTED 4000e280: 81 c7 e0 08 ret <== NOT EXECUTED 4000e284: 91 e8 20 13 restore %g0, 0x13, %o0 <== NOT EXECUTED return _CORE_mutex_Seize_slow( 4000e288: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 4000e28c: 40 00 04 17 call 4000f2e8 <_CORE_mutex_Seize_slow> <== NOT EXECUTED 4000e290: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED 4000e294: b0 0a 60 ff and %o1, 0xff, %i0 <== NOT EXECUTED 4000e298: 81 c7 e0 08 ret <== NOT EXECUTED 4000e29c: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Priority_add( 4000e2a0: 92 02 20 20 add %o0, 0x20, %o1 <== NOT EXECUTED 4000e2a4: 94 07 bf dc add %fp, -36, %o2 <== NOT EXECUTED 4000e2a8: 40 00 13 20 call 40012f28 <_Thread_Priority_add> <== NOT EXECUTED 4000e2ac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 4000e2b0: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000e2b4: 82 00 60 01 inc %g1 <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000e2b8: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000e2bc: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e2c0: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e2c4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e2c8: 01 00 00 00 nop <== NOT EXECUTED _Thread_Priority_update( queue_context ); 4000e2cc: 40 00 13 28 call 40012f6c <_Thread_Priority_update> <== NOT EXECUTED 4000e2d0: 90 07 bf dc add %fp, -36, %o0 <== NOT EXECUTED uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000e2d4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED if ( disable_level == 1 ) { 4000e2d8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000e2dc: 02 80 00 06 be 4000e2f4 <== NOT EXECUTED 4000e2e0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000e2e4: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000e2e8: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED 4000e2ec: 81 c7 e0 08 ret <== NOT EXECUTED 4000e2f0: 81 e8 00 00 restore <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000e2f4: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000e2f8: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2 <== NOT EXECUTED 4000e2fc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000e300: 12 80 00 07 bne 4000e31c <== NOT EXECUTED 4000e304: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = 0; 4000e308: c0 27 60 18 clr [ %i5 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e30c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e310: 01 00 00 00 nop <== NOT EXECUTED 4000e314: 81 c7 e0 08 ret <== NOT EXECUTED 4000e318: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED _Thread_Do_dispatch( cpu_self, level ); 4000e31c: c2 27 bf d4 st %g1, [ %fp + -44 ] <== NOT EXECUTED 4000e320: 40 00 13 9a call 40013188 <_Thread_Do_dispatch> <== NOT EXECUTED 4000e324: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 4000e328: 10 bf ff f9 b 4000e30c <== NOT EXECUTED 4000e32c: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED =============================================================================== 4000e330 : #include #include rtems_status_code rtems_semaphore_release( rtems_id id ) { 4000e330: 9d e3 bf 70 save %sp, -144, %sp <== NOT EXECUTED return (Semaphore_Control *) _Objects_Get( 4000e334: 15 10 00 d1 sethi %hi(0x40034400), %o2 <== NOT EXECUTED 4000e338: 92 07 bf dc add %fp, -36, %o1 <== NOT EXECUTED 4000e33c: 94 12 a3 34 or %o2, 0x334, %o2 <== NOT EXECUTED 4000e340: 40 00 0d 05 call 40011754 <_Objects_Get> <== NOT EXECUTED 4000e344: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Thread_Control *executing; Status_Control status; the_semaphore = _Semaphore_Get( id, &queue_context ); if ( the_semaphore == NULL ) { 4000e348: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED 4000e34c: 02 80 00 52 be 4000e494 <== NOT EXECUTED 4000e350: 01 00 00 00 nop <== NOT EXECUTED _Thread_queue_Context_set_MP_callout( &queue_context, _Semaphore_Core_mutex_mp_support ); switch ( the_semaphore->variant ) { 4000e354: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED 4000e358: 83 30 60 1d srl %g1, 0x1d, %g1 <== NOT EXECUTED executing = _Thread_Executing; 4000e35c: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0 <== NOT EXECUTED switch ( the_semaphore->variant ) { 4000e360: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000e364: 02 80 00 24 be 4000e3f4 <== NOT EXECUTED 4000e368: b8 07 60 10 add %i5, 0x10, %i4 <== NOT EXECUTED 4000e36c: 0a 80 00 36 bcs 4000e444 <== NOT EXECUTED 4000e370: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000e374: 02 80 00 16 be 4000e3cc <== NOT EXECUTED 4000e378: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 4000e37c: 12 80 00 0b bne 4000e3a8 <== NOT EXECUTED 4000e380: c2 0f 60 38 ldub [ %i5 + 0x38 ], %g1 <== NOT EXECUTED if ( the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY ) { 4000e384: 80 88 60 e0 btst 0xe0, %g1 <== NOT EXECUTED 4000e388: 02 80 00 76 be 4000e560 <== NOT EXECUTED 4000e38c: 37 10 00 bb sethi %hi(0x4002ec00), %i3 <== NOT EXECUTED if ( the_semaphore->discipline == SEMAPHORE_DISCIPLINE_PRIORITY ) { 4000e390: 80 88 60 10 btst 0x10, %g1 <== NOT EXECUTED 4000e394: 32 80 00 8a bne,a 4000e5bc <== NOT EXECUTED 4000e398: 37 10 00 bb sethi %hi(0x4002ec00), %i3 <== NOT EXECUTED return &_Thread_queue_Operations_priority; 4000e39c: 37 10 00 bb sethi %hi(0x4002ec00), %i3 <== NOT EXECUTED 4000e3a0: 10 80 00 71 b 4000e564 <== NOT EXECUTED 4000e3a4: b6 16 e3 e0 or %i3, 0x3e0, %i3 ! 4002efe0 <_Thread_queue_Operations_priority> <== NOT EXECUTED if ( the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY ) { 4000e3a8: 80 88 60 e0 btst 0xe0, %g1 <== NOT EXECUTED 4000e3ac: 02 80 00 4f be 4000e4e8 <== NOT EXECUTED 4000e3b0: 37 10 00 bb sethi %hi(0x4002ec00), %i3 <== NOT EXECUTED if ( the_semaphore->discipline == SEMAPHORE_DISCIPLINE_PRIORITY ) { 4000e3b4: 80 88 60 10 btst 0x10, %g1 <== NOT EXECUTED 4000e3b8: 32 80 00 83 bne,a 4000e5c4 <== NOT EXECUTED 4000e3bc: 37 10 00 bb sethi %hi(0x4002ec00), %i3 <== NOT EXECUTED return &_Thread_queue_Operations_priority; 4000e3c0: 37 10 00 bb sethi %hi(0x4002ec00), %i3 <== NOT EXECUTED 4000e3c4: 10 80 00 4a b 4000e4ec <== NOT EXECUTED 4000e3c8: b6 16 e3 e0 or %i3, 0x3e0, %i3 ! 4002efe0 <_Thread_queue_Operations_priority> <== NOT EXECUTED if ( the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY ) { 4000e3cc: c2 0f 60 38 ldub [ %i5 + 0x38 ], %g1 <== NOT EXECUTED 4000e3d0: 80 88 60 e0 btst 0xe0, %g1 <== NOT EXECUTED 4000e3d4: 02 80 00 32 be 4000e49c <== NOT EXECUTED 4000e3d8: 19 10 00 bb sethi %hi(0x4002ec00), %o4 <== NOT EXECUTED if ( the_semaphore->discipline == SEMAPHORE_DISCIPLINE_PRIORITY ) { 4000e3dc: 80 88 60 10 btst 0x10, %g1 <== NOT EXECUTED 4000e3e0: 32 80 00 75 bne,a 4000e5b4 <== NOT EXECUTED 4000e3e4: 19 10 00 bb sethi %hi(0x4002ec00), %o4 <== NOT EXECUTED return &_Thread_queue_Operations_priority; 4000e3e8: 19 10 00 bb sethi %hi(0x4002ec00), %o4 <== NOT EXECUTED 4000e3ec: 10 80 00 2d b 4000e4a0 <== NOT EXECUTED 4000e3f0: 98 13 23 e0 or %o4, 0x3e0, %o4 ! 4002efe0 <_Thread_queue_Operations_priority> <== NOT EXECUTED Per_CPU_Control *cpu_self; Thread_Control *new_owner; _CORE_mutex_Acquire_critical( &the_mutex->Recursive.Mutex, queue_context ); if ( !_CORE_mutex_Is_owner( &the_mutex->Recursive.Mutex, executing ) ) { 4000e3f4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED 4000e3f8: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED 4000e3fc: 12 80 00 0d bne 4000e430 <== NOT EXECUTED 4000e400: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context ); return STATUS_NOT_OWNER; } nest_level = the_mutex->Recursive.nest_level; 4000e404: f0 07 60 1c ld [ %i5 + 0x1c ], %i0 <== NOT EXECUTED if ( nest_level > 0 ) { 4000e408: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 4000e40c: 22 80 00 70 be,a 4000e5cc <== NOT EXECUTED 4000e410: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED the_mutex->nest_level = nest_level - 1; 4000e414: b0 06 3f ff add %i0, -1, %i0 <== NOT EXECUTED 4000e418: f0 27 60 1c st %i0, [ %i5 + 0x1c ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e41c: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e420: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e424: 01 00 00 00 nop <== NOT EXECUTED 4000e428: 81 c7 e0 08 ret <== NOT EXECUTED 4000e42c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e430: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e434: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e438: 01 00 00 00 nop <== NOT EXECUTED 4000e43c: 81 c7 e0 08 ret <== NOT EXECUTED 4000e440: 91 e8 20 17 restore %g0, 0x17, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_owner( &the_mutex->Mutex, executing ) ) { 4000e444: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED 4000e448: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED 4000e44c: 12 bf ff f9 bne 4000e430 <== NOT EXECUTED 4000e450: 01 00 00 00 nop <== NOT EXECUTED nest_level = the_mutex->nest_level; 4000e454: f0 07 60 1c ld [ %i5 + 0x1c ], %i0 <== NOT EXECUTED if ( nest_level > 0 ) { 4000e458: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 4000e45c: 32 bf ff ef bne,a 4000e418 <== NOT EXECUTED 4000e460: b0 06 3f ff add %i0, -1, %i0 <== NOT EXECUTED the_mutex->Wait_queue.Queue.owner = owner; 4000e464: c0 27 60 14 clr [ %i5 + 0x14 ] <== NOT EXECUTED heads = the_mutex->Mutex.Wait_queue.Queue.heads; 4000e468: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED if ( heads == NULL ) { 4000e46c: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED 4000e470: 02 80 00 30 be 4000e530 <== NOT EXECUTED 4000e474: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED _Thread_queue_Surrender( 4000e478: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED 4000e47c: 19 10 00 bb sethi %hi(0x4002ec00), %o4 <== NOT EXECUTED 4000e480: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED 4000e484: 40 00 15 e9 call 40013c28 <_Thread_queue_Surrender> <== NOT EXECUTED 4000e488: 98 13 23 cc or %o4, 0x3cc, %o4 <== NOT EXECUTED 4000e48c: 81 c7 e0 08 ret <== NOT EXECUTED 4000e490: 81 e8 00 00 restore <== NOT EXECUTED ); break; } return _Status_Get( status ); } 4000e494: 81 c7 e0 08 ret <== NOT EXECUTED 4000e498: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED return &_Thread_queue_Operations_priority_inherit; 4000e49c: 98 13 23 cc or %o4, 0x3cc, %o4 <== NOT EXECUTED if ( !_CORE_mutex_Is_owner( &the_mutex->Mutex, executing ) ) { 4000e4a0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED 4000e4a4: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED 4000e4a8: 12 bf ff e2 bne 4000e430 <== NOT EXECUTED 4000e4ac: 01 00 00 00 nop <== NOT EXECUTED nest_level = the_mutex->nest_level; 4000e4b0: f0 07 60 1c ld [ %i5 + 0x1c ], %i0 <== NOT EXECUTED if ( nest_level > 0 ) { 4000e4b4: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 4000e4b8: 32 bf ff d8 bne,a 4000e418 <== NOT EXECUTED 4000e4bc: b0 06 3f ff add %i0, -1, %i0 <== NOT EXECUTED the_mutex->Wait_queue.Queue.owner = owner; 4000e4c0: c0 27 60 14 clr [ %i5 + 0x14 ] <== NOT EXECUTED heads = the_mutex->Mutex.Wait_queue.Queue.heads; 4000e4c4: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED if ( heads == NULL ) { 4000e4c8: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED 4000e4cc: 02 80 00 19 be 4000e530 <== NOT EXECUTED 4000e4d0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED _Thread_queue_Surrender( 4000e4d4: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED 4000e4d8: 40 00 15 d4 call 40013c28 <_Thread_queue_Surrender> <== NOT EXECUTED 4000e4dc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED 4000e4e0: 81 c7 e0 08 ret <== NOT EXECUTED 4000e4e4: 81 e8 00 00 restore <== NOT EXECUTED 4000e4e8: b6 16 e3 cc or %i3, 0x3cc, %i3 <== NOT EXECUTED 4000e4ec: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED const Thread_queue_Operations *operations ) { Thread_queue_Heads *heads = the_thread_queue->Queue.heads; if ( heads != NULL ) { 4000e4f0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000e4f4: 22 80 00 09 be,a 4000e518 <== NOT EXECUTED 4000e4f8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED return ( *operations->first )( heads ); 4000e4fc: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1 <== NOT EXECUTED 4000e500: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000e504: 01 00 00 00 nop <== NOT EXECUTED if ( the_thread != NULL ) { 4000e508: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000e50c: 12 80 00 0e bne 4000e544 <== NOT EXECUTED 4000e510: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED if ( the_semaphore->count < maximum_count ) 4000e514: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED 4000e518: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED 4000e51c: 02 80 00 05 be 4000e530 <== NOT EXECUTED 4000e520: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED the_semaphore->count += 1; 4000e524: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000e528: c2 27 60 1c st %g1, [ %i5 + 0x1c ] <== NOT EXECUTED 4000e52c: b0 10 20 00 clr %i0 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e530: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e534: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e538: 01 00 00 00 nop <== NOT EXECUTED return _Status_Get( status ); 4000e53c: 81 c7 e0 08 ret <== NOT EXECUTED 4000e540: 81 e8 00 00 restore <== NOT EXECUTED _Thread_queue_Extract_critical( 4000e544: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000e548: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED 4000e54c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 4000e550: 40 00 15 75 call 40013b24 <_Thread_queue_Extract_critical> <== NOT EXECUTED 4000e554: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED 4000e558: 81 c7 e0 08 ret <== NOT EXECUTED 4000e55c: 81 e8 00 00 restore <== NOT EXECUTED 4000e560: b6 16 e3 cc or %i3, 0x3cc, %i3 <== NOT EXECUTED 4000e564: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED if ( heads != NULL ) { 4000e568: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000e56c: 22 80 00 09 be,a 4000e590 <== NOT EXECUTED 4000e570: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED return ( *operations->first )( heads ); 4000e574: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1 <== NOT EXECUTED 4000e578: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000e57c: 01 00 00 00 nop <== NOT EXECUTED if ( the_thread != NULL ) { 4000e580: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000e584: 12 bf ff f0 bne 4000e544 <== NOT EXECUTED 4000e588: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED if ( the_semaphore->count < maximum_count ) 4000e58c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED 4000e590: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000e594: 12 80 00 03 bne 4000e5a0 <== NOT EXECUTED 4000e598: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_semaphore->count += 1; 4000e59c: c2 27 60 1c st %g1, [ %i5 + 0x1c ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e5a0: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __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 <== NOT EXECUTED 4000e5ac: 81 c7 e0 08 ret <== NOT EXECUTED 4000e5b0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED return &_Thread_queue_Operations_FIFO; 4000e5b4: 10 bf ff bb b 4000e4a0 <== NOT EXECUTED 4000e5b8: 98 13 23 f4 or %o4, 0x3f4, %o4 <== NOT EXECUTED 4000e5bc: 10 bf ff ea b 4000e564 <== NOT EXECUTED 4000e5c0: b6 16 e3 f4 or %i3, 0x3f4, %i3 <== NOT EXECUTED 4000e5c4: 10 bf ff ca b 4000e4ec <== NOT EXECUTED 4000e5c8: b6 16 e3 f4 or %i3, 0x3f4, %i3 <== NOT EXECUTED _Thread_Resource_count_decrement( executing ); _Thread_queue_Context_clear_priority_updates( queue_context ); _Thread_Wait_acquire_default_critical( executing, &lock_context ); _Thread_Priority_remove( 4000e5cc: a0 07 60 20 add %i5, 0x20, %l0 <== NOT EXECUTED 4000e5d0: 94 07 bf dc add %fp, -36, %o2 <== NOT EXECUTED 4000e5d4: 40 00 12 5a call 40012f3c <_Thread_Priority_remove> <== NOT EXECUTED 4000e5d8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 4000e5dc: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED if ( heads != NULL ) { 4000e5e0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000e5e4: 02 80 00 1f be 4000e660 <== NOT EXECUTED 4000e5e8: 35 10 00 bb sethi %hi(0x4002ec00), %i2 <== NOT EXECUTED return ( *operations->first )( heads ); 4000e5ec: b4 16 a3 e0 or %i2, 0x3e0, %i2 ! 4002efe0 <_Thread_queue_Operations_priority> <== NOT EXECUTED 4000e5f0: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED 4000e5f4: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000e5f8: 01 00 00 00 nop <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 4000e5fc: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED the_mutex->Wait_queue.Queue.owner = owner; 4000e600: d0 27 60 14 st %o0, [ %i5 + 0x14 ] <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000e604: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000e608: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED 4000e60c: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED cpu_self = _Thread_Dispatch_disable_critical( &queue_context->Lock_context.Lock_context ); if ( new_owner != NULL ) { 4000e610: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000e614: 02 80 00 18 be 4000e674 <== NOT EXECUTED 4000e618: b6 10 00 06 mov %g6, %i3 <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( _Objects_Is_local_id( new_owner->Object.id ) ) #endif { _Thread_Resource_count_increment( new_owner ); _Thread_Priority_add( 4000e61c: 94 07 bf dc add %fp, -36, %o2 <== NOT EXECUTED 4000e620: 40 00 12 42 call 40012f28 <_Thread_Priority_add> <== NOT EXECUTED 4000e624: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED &the_mutex->Priority_ceiling, queue_context ); } _Thread_queue_Extract_critical( 4000e628: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED 4000e62c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 4000e630: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4000e634: 40 00 15 3c call 40013b24 <_Thread_queue_Extract_critical> <== NOT EXECUTED 4000e638: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED ); } else { _CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context ); } _Thread_Priority_update( queue_context ); 4000e63c: 40 00 12 4c call 40012f6c <_Thread_Priority_update> <== NOT EXECUTED 4000e640: 90 07 bf dc add %fp, -36, %o0 <== NOT EXECUTED uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000e644: c2 06 e0 18 ld [ %i3 + 0x18 ], %g1 <== NOT EXECUTED if ( disable_level == 1 ) { 4000e648: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000e64c: 02 80 00 0e be 4000e684 <== NOT EXECUTED 4000e650: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000e654: c2 26 e0 18 st %g1, [ %i3 + 0x18 ] <== NOT EXECUTED 4000e658: 81 c7 e0 08 ret <== NOT EXECUTED 4000e65c: 81 e8 00 00 restore <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 4000e660: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED the_mutex->Wait_queue.Queue.owner = owner; 4000e664: c0 27 60 14 clr [ %i5 + 0x14 ] <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000e668: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000e66c: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000e670: b6 10 00 06 mov %g6, %i3 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e674: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e678: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e67c: 01 00 00 00 nop <== NOT EXECUTED 4000e680: 30 bf ff ef b,a 4000e63c <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000e684: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000e688: c4 0e e0 1c ldub [ %i3 + 0x1c ], %g2 <== NOT EXECUTED 4000e68c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000e690: 12 80 00 07 bne 4000e6ac <== NOT EXECUTED 4000e694: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = 0; 4000e698: c0 26 e0 18 clr [ %i3 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e69c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000e6a0: 01 00 00 00 nop <== NOT EXECUTED 4000e6a4: 81 c7 e0 08 ret <== NOT EXECUTED 4000e6a8: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Do_dispatch( cpu_self, level ); 4000e6ac: c2 27 bf d4 st %g1, [ %fp + -44 ] <== NOT EXECUTED 4000e6b0: 40 00 12 b6 call 40013188 <_Thread_Do_dispatch> <== NOT EXECUTED 4000e6b4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 4000e6b8: 10 bf ff f9 b 4000e69c <== NOT EXECUTED 4000e6bc: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED =============================================================================== 4000d374 : [RTEMS_IO_ERROR] = EIO, [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_status_code_to_errno(rtems_status_code sc) { 4000d374: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 4000d378: 82 10 00 18 mov %i0, %g1 <== NOT EXECUTED if (sc == RTEMS_SUCCESSFUL) { 4000d37c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000d380: 02 80 00 0c be 4000d3b0 <== NOT EXECUTED 4000d384: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } else { int eno = EINVAL; if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) { 4000d388: 80 a0 60 1c cmp %g1, 0x1c <== NOT EXECUTED 4000d38c: 18 80 00 06 bgu 4000d3a4 <== NOT EXECUTED 4000d390: ba 10 20 16 mov 0x16, %i5 <== NOT EXECUTED eno = status_code_to_errno [sc]; 4000d394: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 4000d398: 05 10 00 42 sethi %hi(0x40010800), %g2 <== NOT EXECUTED 4000d39c: 84 10 a2 d8 or %g2, 0x2d8, %g2 ! 40010ad8 <== NOT EXECUTED 4000d3a0: fa 00 80 01 ld [ %g2 + %g1 ], %i5 <== NOT EXECUTED } errno = eno; 4000d3a4: 40 00 04 1a call 4000e40c <__errno> <== NOT EXECUTED 4000d3a8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 4000d3ac: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED return -1; } } 4000d3b0: 81 c7 e0 08 ret <== NOT EXECUTED 4000d3b4: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 400060b8 : const char *rtems_status_text( rtems_status_code code ) { size_t i = code; const char *text = "?"; if ( i < RTEMS_ARRAY_SIZE( status_code_text ) ) { 400060b8: 80 a2 20 1c cmp %o0, 0x1c <== NOT EXECUTED 400060bc: 18 80 00 06 bgu 400060d4 <== NOT EXECUTED 400060c0: 03 10 00 41 sethi %hi(0x40010400), %g1 <== NOT EXECUTED text = status_code_text [i]; 400060c4: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED 400060c8: 82 10 63 60 or %g1, 0x360, %g1 <== NOT EXECUTED 400060cc: 81 c3 e0 08 retl <== NOT EXECUTED 400060d0: d0 00 40 08 ld [ %g1 + %o0 ], %o0 <== NOT EXECUTED const char *text = "?"; 400060d4: 11 10 00 41 sethi %hi(0x40010400), %o0 <== NOT EXECUTED } return text; } 400060d8: 81 c3 e0 08 retl <== NOT EXECUTED 400060dc: 90 12 20 a8 or %o0, 0xa8, %o0 ! 400104a8 <== NOT EXECUTED =============================================================================== 40006120 : size_t stack_size, rtems_mode initial_modes, rtems_attribute attribute_set, rtems_id *id ) { 40006120: 9d e3 bf 70 save %sp, -144, %sp Priority_Control priority; RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) 40006124: 80 a7 60 00 cmp %i5, 0 40006128: 02 80 00 50 be 40006268 <== NEVER TAKEN 4000612c: 80 a6 20 00 cmp %i0, 0 return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 40006130: 02 80 00 3e be 40006228 <== NEVER TAKEN 40006134: 82 10 20 03 mov 3, %g1 */ RTEMS_INLINE_ROUTINE bool _Attributes_Is_system_task( rtems_attribute attribute_set ) { return ( attribute_set & RTEMS_SYSTEM_TASK ) ? true : false; 40006138: 83 37 20 0f srl %i4, 0xf, %g1 4000613c: 82 08 60 01 and %g1, 1, %g1 /* * Validate the RTEMS API priority and convert it to the core priority range. */ if ( !_Attributes_Is_system_task( the_attribute_set ) ) { if ( initial_priority == PRIORITY_MINIMUM ) { 40006140: 80 90 40 19 orcc %g1, %i1, %g0 40006144: 02 80 00 3e be 4000623c <== NEVER TAKEN 40006148: 92 10 20 00 clr %o1 const Scheduler_Control *scheduler, rtems_task_priority priority, bool *valid ) { *valid = ( priority <= scheduler->maximum_priority ); 4000614c: 21 10 00 3f sethi %hi(0x4000fc00), %l0 40006150: 90 14 23 78 or %l0, 0x378, %o0 ! 4000ff78 <_Scheduler_Table> RTEMS_INLINE_ROUTINE Priority_Control _Scheduler_Map_priority( const Scheduler_Control *scheduler, Priority_Control priority ) { return ( *scheduler->Operations.map_priority )( scheduler, priority ); 40006154: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 40006158: e2 02 20 40 ld [ %o0 + 0x40 ], %l1 4000615c: e8 02 20 44 ld [ %o0 + 0x44 ], %l4 40006160: 9f c0 40 00 call %g1 40006164: 94 10 00 19 mov %i1, %o2 } scheduler = _Thread_Scheduler_get_home( _Thread_Get_executing() ); priority = _RTEMS_Priority_To_core( scheduler, initial_priority, &valid ); if ( !valid ) { 40006168: 80 a4 60 00 cmp %l1, 0 4000616c: a4 10 00 08 mov %o0, %l2 40006170: 02 80 00 30 be 40006230 <== ALWAYS TAKEN 40006174: a6 10 00 09 mov %o1, %l3 _RTEMS_Lock_allocator(); 40006178: 40 00 01 5f call 400066f4 <_RTEMS_Lock_allocator> 4000617c: 23 10 00 49 sethi %hi(0x40012400), %l1 _Thread_Kill_zombies(); 40006180: 40 00 14 2a call 4000b228 <_Thread_Kill_zombies> 40006184: 01 00 00 00 nop return (Thread_Control *) 40006188: 40 00 08 ae call 40008440 <_Objects_Allocate_unprotected> 4000618c: 90 14 61 4c or %l1, 0x14c, %o0 * this results in a lack of control over when memory is allocated * and can be freed in the event of an error. */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { 40006190: b2 92 20 00 orcc %o0, 0, %i1 40006194: 02 80 00 38 be 40006274 40006198: 85 36 e0 09 srl %i3, 9, %g2 /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 4000619c: e4 3f bf f0 std %l2, [ %fp + -16 ] */ RTEMS_INLINE_ROUTINE bool _Modes_Is_timeslice ( Modes_Control mode_set ) { return (mode_set & RTEMS_TIMESLICE_MASK) == RTEMS_TIMESLICE; 400061a0: 84 08 a0 01 and %g2, 1, %g2 400061a4: 82 07 bf fc add %fp, -4, %g1 400061a8: c4 23 a0 68 st %g2, [ %sp + 0x68 ] 400061ac: 9a 0f 20 01 and %i4, 1, %o5 400061b0: c4 07 bf f0 ld [ %fp + -16 ], %g2 400061b4: c2 23 a0 74 st %g1, [ %sp + 0x74 ] */ RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level ( Modes_Control mode_set ) { return ( mode_set & RTEMS_INTERRUPT_MASK ); 400061b8: 82 0e e0 0f and %i3, 0xf, %g1 400061bc: c4 23 a0 5c st %g2, [ %sp + 0x5c ] 400061c0: 98 10 00 1a mov %i2, %o4 400061c4: c4 07 bf f4 ld [ %fp + -12 ], %g2 400061c8: c2 23 a0 70 st %g1, [ %sp + 0x70 ] return (mode_set & RTEMS_PREEMPT_MASK) == RTEMS_PREEMPT; 400061cc: 83 36 e0 08 srl %i3, 8, %g1 400061d0: c0 23 a0 6c clr [ %sp + 0x6c ] 400061d4: 82 18 60 01 xor %g1, 1, %g1 400061d8: c4 23 a0 60 st %g2, [ %sp + 0x60 ] 400061dc: 82 08 60 01 and %g1, 1, %g1 400061e0: c2 23 a0 64 st %g1, [ %sp + 0x64 ] 400061e4: 96 10 20 00 clr %o3 400061e8: f0 27 bf fc st %i0, [ %fp + -4 ] 400061ec: 94 14 23 78 or %l0, 0x378, %o2 400061f0: 92 10 00 19 mov %i1, %o1 400061f4: 40 00 0f 3b call 40009ee0 <_Thread_Initialize> 400061f8: 90 14 61 4c or %l1, 0x14c, %o0 NULL, /* no budget algorithm callout */ _Modes_Get_interrupt_level(initial_modes), (Objects_Name) name ); if ( !status ) { 400061fc: 80 a2 20 00 cmp %o0, 0 40006200: 02 80 00 12 be 40006248 <== NEVER TAKEN 40006204: b7 36 e0 0a srl %i3, 0xa, %i3 } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true; 40006208: c4 06 61 58 ld [ %i1 + 0x158 ], %g2 *id = the_thread->Object.id; 4000620c: c2 06 60 08 ld [ %i1 + 8 ], %g1 asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true; 40006210: b6 1e e0 01 xor %i3, 1, %i3 40006214: b6 0e e0 01 and %i3, 1, %i3 40006218: f6 28 a0 08 stb %i3, [ %g2 + 8 ] _RTEMS_Unlock_allocator(); 4000621c: 40 00 01 3b call 40006708 <_RTEMS_Unlock_allocator> 40006220: c2 27 40 00 st %g1, [ %i5 ] } #endif _Objects_Allocator_unlock(); return RTEMS_SUCCESSFUL; 40006224: 82 10 20 00 clr %g1 } 40006228: 81 c7 e0 08 ret 4000622c: 91 e8 00 01 restore %g0, %g1, %o0 if ( !valid ) { 40006230: 80 a6 40 14 cmp %i1, %l4 40006234: 08 bf ff d1 bleu 40006178 <== ALWAYS TAKEN 40006238: 01 00 00 00 nop return RTEMS_INVALID_PRIORITY; 4000623c: 82 10 20 13 mov 0x13, %g1 ! 13 <_TLS_Alignment+0x12> <== NOT EXECUTED } 40006240: 81 c7 e0 08 ret <== NOT EXECUTED 40006244: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED _Objects_Free( 40006248: 40 00 09 aa call 400088f0 <_Objects_Get_information_id> <== NOT EXECUTED 4000624c: d0 06 60 08 ld [ %i1 + 8 ], %o0 <== NOT EXECUTED 40006250: 40 00 09 7c call 40008840 <_Objects_Free> <== NOT EXECUTED 40006254: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40006258: 40 00 01 2c call 40006708 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 4000625c: 01 00 00 00 nop <== NOT EXECUTED return RTEMS_UNSATISFIED; 40006260: 10 bf ff f2 b 40006228 <== NOT EXECUTED 40006264: 82 10 20 0d mov 0xd, %g1 ! d <_TLS_Alignment+0xc> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 40006268: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED } 4000626c: 81 c7 e0 08 ret <== NOT EXECUTED 40006270: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED 40006274: 40 00 01 25 call 40006708 <_RTEMS_Unlock_allocator> 40006278: 01 00 00 00 nop return RTEMS_TOO_MANY; 4000627c: 10 bf ff eb b 40006228 40006280: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4> =============================================================================== 40006284 : #include rtems_status_code rtems_task_delete( rtems_id id ) { 40006284: 9d e3 bf 70 save %sp, -144, %sp Thread_Control *the_thread; Thread_Close_context context; Thread_Control *executing; _Thread_queue_Context_initialize( &context.Base ); the_thread = _Thread_Get( id, &context.Base.Lock_context.Lock_context ); 40006288: 90 10 00 18 mov %i0, %o0 4000628c: 40 00 0e d8 call 40009dec <_Thread_Get> 40006290: 92 07 bf d8 add %fp, -40, %o1 if ( the_thread == NULL ) { 40006294: 82 92 20 00 orcc %o0, 0, %g1 40006298: 02 80 00 26 be 40006330 <== NEVER TAKEN 4000629c: 01 00 00 00 nop #endif return RTEMS_INVALID_ID; } executing = _Thread_Executing; 400062a0: d2 01 a0 20 ld [ %g6 + 0x20 ], %o1 if ( the_thread == executing ) { 400062a4: 80 a0 40 09 cmp %g1, %o1 400062a8: 02 80 00 07 be 400062c4 <== ALWAYS TAKEN 400062ac: ba 10 00 06 mov %g6, %i5 THREAD_LIFE_TERMINATING | THREAD_LIFE_DETACHED, NULL ); _Thread_Dispatch_enable( cpu_self ); } else { _Thread_Close( the_thread, executing, &context ); 400062b0: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED 400062b4: 40 00 14 93 call 4000b500 <_Thread_Close> <== NOT EXECUTED 400062b8: b0 10 20 00 clr %i0 <== NOT EXECUTED 400062bc: 81 c7 e0 08 ret <== NOT EXECUTED 400062c0: 81 e8 00 00 restore <== NOT EXECUTED const ISR_lock_Context *lock_context ) { uint32_t disable_level; disable_level = cpu_self->thread_dispatch_disable_level; 400062c4: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED _Profiling_Thread_dispatch_disable_critical( cpu_self, disable_level, lock_context ); cpu_self->thread_dispatch_disable_level = disable_level + 1; 400062c8: 82 00 60 01 inc %g1 <== NOT EXECUTED 400062cc: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400062d0: c2 07 bf d8 ld [ %fp + -40 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400062d4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400062d8: 01 00 00 00 nop _Thread_Exit( 400062dc: 94 10 20 00 clr %o2 ! 0 400062e0: 40 00 14 97 call 4000b53c <_Thread_Exit> 400062e4: 92 10 20 14 mov 0x14, %o1 * * @param[in] cpu_self The current processor. */ RTEMS_INLINE_ROUTINE void _Thread_Dispatch_enable( Per_CPU_Control *cpu_self ) { uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 400062e8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 if ( disable_level == 1 ) { 400062ec: 80 a0 60 01 cmp %g1, 1 400062f0: 02 80 00 06 be 40006308 <== ALWAYS TAKEN 400062f4: 82 00 7f ff add %g1, -1, %g1 } return RTEMS_SUCCESSFUL; 400062f8: b0 10 20 00 clr %i0 <== NOT EXECUTED } _ISR_Local_enable( level ); } else { _Assert( disable_level > 0 ); cpu_self->thread_dispatch_disable_level = disable_level - 1; 400062fc: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED 40006300: 81 c7 e0 08 ret <== NOT EXECUTED 40006304: 81 e8 00 00 restore <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40006308: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000630c: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2 40006310: 80 a0 a0 00 cmp %g2, 0 40006314: 12 80 00 09 bne 40006338 <== ALWAYS TAKEN 40006318: 92 10 00 01 mov %g1, %o1 cpu_self->thread_dispatch_disable_level = 0; 4000631c: c0 27 60 18 clr [ %i5 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40006320: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40006324: 01 00 00 00 nop <== NOT EXECUTED 40006328: 81 c7 e0 08 ret <== NOT EXECUTED 4000632c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED } 40006330: 81 c7 e0 08 ret <== NOT EXECUTED 40006334: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED _Thread_Do_dispatch( cpu_self, level ); 40006338: c2 27 bf d4 st %g1, [ %fp + -44 ] 4000633c: 40 00 0e 4d call 40009c70 <_Thread_Do_dispatch> 40006340: 90 10 00 1d mov %i5, %o0 40006344: 10 bf ff f7 b 40006320 <== NOT EXECUTED 40006348: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED =============================================================================== 4000634c : rtems_status_code rtems_task_ident( rtems_name name, uint32_t node, rtems_id *id ) { 4000634c: 9d e3 bf a0 save %sp, -96, %sp Objects_Name_or_id_lookup_errors status; if ( !id ) 40006350: 80 a6 a0 00 cmp %i2, 0 40006354: 02 80 00 14 be 400063a4 <== NEVER TAKEN 40006358: 80 a6 20 00 cmp %i0, 0 return RTEMS_INVALID_ADDRESS; if ( name == OBJECTS_ID_OF_SELF ) { 4000635c: 12 80 00 07 bne 40006378 <== NEVER TAKEN 40006360: 92 10 00 18 mov %i0, %o1 *id = _Thread_Get_executing()->Object.id; 40006364: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1 40006368: c2 00 60 08 ld [ %g1 + 8 ], %g1 4000636c: c2 26 80 00 st %g1, [ %i2 ] return RTEMS_SUCCESSFUL; 40006370: 81 c7 e0 08 ret 40006374: 81 e8 00 00 restore } status = _Objects_Name_to_id_u32( 40006378: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 4000637c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 40006380: 11 10 00 49 sethi %hi(0x40012400), %o0 <== NOT EXECUTED 40006384: 40 00 09 6e call 4000893c <_Objects_Name_to_id_u32> <== NOT EXECUTED 40006388: 90 12 21 4c or %o0, 0x14c, %o0 ! 4001254c <_RTEMS_tasks_Information> <== NOT EXECUTED name, node, id ); return _Status_Object_name_errors_to_status[ status ]; 4000638c: 03 10 00 42 sethi %hi(0x40010800), %g1 <== NOT EXECUTED 40006390: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED 40006394: 82 10 63 4c or %g1, 0x34c, %g1 <== NOT EXECUTED 40006398: f0 00 40 08 ld [ %g1 + %o0 ], %i0 <== NOT EXECUTED 4000639c: 81 c7 e0 08 ret <== NOT EXECUTED 400063a0: 81 e8 00 00 restore <== NOT EXECUTED } 400063a4: 81 c7 e0 08 ret <== NOT EXECUTED 400063a8: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED =============================================================================== 4000ea4c : void rtems_task_iterate( rtems_task_visitor visitor, void *arg ) { 4000ea4c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED _RTEMS_Lock_allocator(); 4000ea50: 40 00 01 f0 call 4000f210 <_RTEMS_Lock_allocator> <== NOT EXECUTED 4000ea54: 01 00 00 00 nop <== NOT EXECUTED _Objects_Allocator_lock(); _Thread_Iterate( visitor, arg ); 4000ea58: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000ea5c: 40 00 13 27 call 400136f8 <_Thread_Iterate> <== NOT EXECUTED 4000ea60: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _RTEMS_Unlock_allocator(); 4000ea64: 40 00 01 f0 call 4000f224 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 4000ea68: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000ea6c : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 4000ea6c: 9d e3 bf 98 save %sp, -104, %sp ASR_Information *asr; bool preempt_enabled; bool needs_asr_dispatching; rtems_mode old_mode; if ( !previous_mode_set ) 4000ea70: 80 a6 a0 00 cmp %i2, 0 4000ea74: 02 80 00 77 be 4000ec50 <== NEVER TAKEN 4000ea78: 01 00 00 00 nop 4000ea7c: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4 executing = _Thread_Get_executing(); api = executing->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 4000ea80: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1 4000ea84: 80 a0 00 01 cmp %g0, %g1 if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 4000ea88: c2 07 20 90 ld [ %i4 + 0x90 ], %g1 old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 4000ea8c: 90 60 3f ff subx %g0, -1, %o0 api = executing->API_Extensions[ THREAD_API_RTEMS ]; 4000ea90: e0 07 21 58 ld [ %i4 + 0x158 ], %l0 if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 4000ea94: 80 a0 60 00 cmp %g1, 0 4000ea98: 12 80 00 5d bne 4000ec0c <== NEVER TAKEN 4000ea9c: b7 2a 20 08 sll %o0, 8, %i3 old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 4000eaa0: c2 0c 20 08 ldub [ %l0 + 8 ], %g1 4000eaa4: 80 a0 00 01 cmp %g0, %g1 old_mode |= _ISR_Get_level(); 4000eaa8: 7f ff e3 a8 call 40007948 <_CPU_ISR_Get_level> 4000eaac: ba 60 3f ff subx %g0, -1, %i5 old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 4000eab0: bb 2f 60 0a sll %i5, 0xa, %i5 old_mode |= _ISR_Get_level(); 4000eab4: 90 17 40 08 or %i5, %o0, %o0 4000eab8: 90 12 00 1b or %o0, %i3, %o0 *previous_mode_set = old_mode; 4000eabc: d0 26 80 00 st %o0, [ %i2 ] /* * These are generic thread scheduling characteristics. */ preempt_enabled = false; if ( mask & RTEMS_PREEMPT_MASK ) { 4000eac0: 80 8e 61 00 btst 0x100, %i1 4000eac4: 02 80 00 09 be 4000eae8 <== NEVER TAKEN 4000eac8: 84 10 20 00 clr %g2 bool is_preempt_enabled = _Modes_Is_preempt( mode_set ); preempt_enabled = !executing->is_preemptible && is_preempt_enabled; 4000eacc: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1 4000ead0: 85 36 20 08 srl %i0, 8, %g2 4000ead4: 82 18 60 01 xor %g1, 1, %g1 4000ead8: 84 18 a0 01 xor %g2, 1, %g2 4000eadc: 84 08 a0 01 and %g2, 1, %g2 executing->is_preemptible = is_preempt_enabled; 4000eae0: c4 2f 20 89 stb %g2, [ %i4 + 0x89 ] preempt_enabled = !executing->is_preemptible && is_preempt_enabled; 4000eae4: 84 08 80 01 and %g2, %g1, %g2 } if ( mask & RTEMS_TIMESLICE_MASK ) { 4000eae8: 80 8e 62 00 btst 0x200, %i1 4000eaec: 02 80 00 0a be 4000eb14 <== ALWAYS TAKEN 4000eaf0: 80 8e 60 0f btst 0xf, %i1 if ( _Modes_Is_timeslice(mode_set) ) { 4000eaf4: 80 8e 22 00 btst 0x200, %i0 <== NOT EXECUTED 4000eaf8: 02 80 00 53 be 4000ec44 <== NOT EXECUTED 4000eafc: 80 8e 60 0f btst 0xf, %i1 <== NOT EXECUTED executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; executing->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice(); 4000eb00: 03 10 00 b4 sethi %hi(0x4002d000), %g1 <== NOT EXECUTED executing->cpu_time_budget = 4000eb04: c2 00 63 e0 ld [ %g1 + 0x3e0 ], %g1 ! 4002d3e0 <== NOT EXECUTED 4000eb08: c2 27 20 8c st %g1, [ %i4 + 0x8c ] <== NOT EXECUTED executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 4000eb0c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 4000eb10: c2 27 20 90 st %g1, [ %i4 + 0x90 ] <== NOT EXECUTED } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) { 4000eb14: 02 80 00 07 be 4000eb30 <== ALWAYS TAKEN 4000eb18: 80 8e 64 00 btst 0x400, %i1 */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 4000eb1c: 83 2e 20 08 sll %i0, 8, %g1 <== NOT EXECUTED 4000eb20: 82 08 6f 00 and %g1, 0xf00, %g1 <== NOT EXECUTED 4000eb24: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000eb28: 01 00 00 00 nop <== NOT EXECUTED /* * This is specific to the RTEMS API */ needs_asr_dispatching = false; if ( mask & RTEMS_ASR_MASK ) { 4000eb2c: 80 8e 64 00 btst 0x400, %i1 <== NOT EXECUTED 4000eb30: 02 80 00 22 be 4000ebb8 <== ALWAYS TAKEN 4000eb34: 80 88 a0 ff btst 0xff, %g2 bool is_asr_enabled = !_Modes_Is_asr_disabled( mode_set ); 4000eb38: b1 36 20 0a srl %i0, 0xa, %i0 <== NOT EXECUTED 4000eb3c: b0 1e 20 01 xor %i0, 1, %i0 <== NOT EXECUTED 4000eb40: b0 0e 20 01 and %i0, 1, %i0 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000eb44: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000eb48: 88 10 00 01 mov %g1, %g4 <== NOT EXECUTED _Thread_State_acquire( executing, &lock_context ); if ( is_asr_enabled != asr->is_enabled ) { 4000eb4c: c6 0c 20 08 ldub [ %l0 + 8 ], %g3 <== NOT EXECUTED 4000eb50: 80 a6 00 03 cmp %i0, %g3 <== NOT EXECUTED 4000eb54: 02 80 00 15 be 4000eba8 <== NOT EXECUTED 4000eb58: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE rtems_signal_set _ASR_Swap_signals( ASR_Information *asr ) { rtems_signal_set new_signals_posted; new_signals_posted = asr->signals_pending; 4000eb5c: c6 04 20 18 ld [ %l0 + 0x18 ], %g3 <== NOT EXECUTED asr->signals_pending = asr->signals_posted; 4000eb60: fa 04 20 14 ld [ %l0 + 0x14 ], %i5 <== NOT EXECUTED asr->is_enabled = is_asr_enabled; 4000eb64: f0 2c 20 08 stb %i0, [ %l0 + 8 ] <== NOT EXECUTED if ( _ASR_Swap_signals( asr ) != 0 ) { 4000eb68: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 4000eb6c: fa 24 20 18 st %i5, [ %l0 + 0x18 ] <== NOT EXECUTED 4000eb70: 02 80 00 0e be 4000eba8 <== NOT EXECUTED 4000eb74: c6 24 20 14 st %g3, [ %l0 + 0x14 ] <== NOT EXECUTED action->handler = handler; 4000eb78: 05 10 00 67 sethi %hi(0x40019c00), %g2 <== NOT EXECUTED 4000eb7c: 84 10 a1 54 or %g2, 0x154, %g2 ! 40019d54 <_Signal_Action_handler> <== NOT EXECUTED 4000eb80: c4 24 20 28 st %g2, [ %l0 + 0x28 ] <== NOT EXECUTED } else { _Atomic_Fetch_or_ulong( &cpu_target->message, 0, ATOMIC_ORDER_RELEASE ); _CPU_SMP_Send_interrupt( _Per_CPU_Get_index( cpu_target ) ); } #else cpu_self->dispatch_necessary = true; 4000eb84: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED 4000eb88: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Chain_Append_if_is_off_chain_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { if ( _Chain_Is_node_off_chain( the_node ) ) { 4000eb8c: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 <== NOT EXECUTED 4000eb90: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000eb94: 22 80 00 33 be,a 4000ec60 <== NOT EXECUTED 4000eb98: c4 07 20 e8 ld [ %i4 + 0xe8 ], %g2 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000eb9c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000eba0: 01 00 00 00 nop <== NOT EXECUTED 4000eba4: 30 80 00 07 b,a 4000ebc0 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000eba8: 82 10 00 04 mov %g4, %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000ebac: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ebb0: 01 00 00 00 nop <== NOT EXECUTED } _Thread_State_release( executing, &lock_context ); } if ( preempt_enabled || needs_asr_dispatching ) { 4000ebb4: 80 88 a0 ff btst 0xff, %g2 <== NOT EXECUTED 4000ebb8: 02 80 00 28 be 4000ec58 <== NEVER TAKEN 4000ebbc: 01 00 00 00 nop <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 4000ebc0: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000ebc4: 82 00 60 01 inc %g1 <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000ebc8: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000ebcc: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000ebd0: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000ebd4: c2 27 bf fc st %g1, [ %fp + -4 ] ( *scheduler->Operations.schedule )( scheduler, the_thread ); 4000ebd8: 11 10 00 b5 sethi %hi(0x4002d400), %o0 4000ebdc: 90 12 20 b8 or %o0, 0xb8, %o0 ! 4002d4b8 <_Scheduler_Table> 4000ebe0: c4 02 20 08 ld [ %o0 + 8 ], %g2 4000ebe4: 9f c0 80 00 call %g2 4000ebe8: 92 10 00 1c mov %i4, %o1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000ebec: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000ebf0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ebf4: 01 00 00 00 nop _Scheduler_Schedule( executing ); _Thread_State_release( executing, &lock_context ); _Thread_Dispatch_direct( cpu_self ); } return RTEMS_SUCCESSFUL; 4000ebf8: b0 10 20 00 clr %i0 ! 0 _Thread_Dispatch_direct( cpu_self ); 4000ebfc: 40 00 11 ab call 400132a8 <_Thread_Dispatch_direct> 4000ec00: 90 10 00 1d mov %i5, %o0 4000ec04: 81 c7 e0 08 ret 4000ec08: 81 e8 00 00 restore old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 4000ec0c: c2 0c 20 08 ldub [ %l0 + 8 ], %g1 <== NOT EXECUTED 4000ec10: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED old_mode |= RTEMS_TIMESLICE; 4000ec14: b6 16 e2 00 or %i3, 0x200, %i3 <== NOT EXECUTED old_mode |= _ISR_Get_level(); 4000ec18: 7f ff e3 4c call 40007948 <_CPU_ISR_Get_level> <== NOT EXECUTED 4000ec1c: ba 60 3f ff subx %g0, -1, %i5 <== NOT EXECUTED old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 4000ec20: bb 2f 60 0a sll %i5, 0xa, %i5 <== NOT EXECUTED old_mode |= _ISR_Get_level(); 4000ec24: 90 17 40 08 or %i5, %o0, %o0 <== NOT EXECUTED 4000ec28: 90 12 00 1b or %o0, %i3, %o0 <== NOT EXECUTED *previous_mode_set = old_mode; 4000ec2c: d0 26 80 00 st %o0, [ %i2 ] <== NOT EXECUTED if ( mask & RTEMS_PREEMPT_MASK ) { 4000ec30: 80 8e 61 00 btst 0x100, %i1 <== NOT EXECUTED 4000ec34: 02 bf ff ad be 4000eae8 <== NOT EXECUTED 4000ec38: 84 10 20 00 clr %g2 <== NOT EXECUTED preempt_enabled = !executing->is_preemptible && is_preempt_enabled; 4000ec3c: 10 bf ff a5 b 4000ead0 <== NOT EXECUTED 4000ec40: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1 <== NOT EXECUTED if ( mask & RTEMS_INTERRUPT_MASK ) { 4000ec44: 02 bf ff ba be 4000eb2c <== NOT EXECUTED 4000ec48: c0 27 20 90 clr [ %i4 + 0x90 ] <== NOT EXECUTED 4000ec4c: 30 bf ff b4 b,a 4000eb1c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 4000ec50: 81 c7 e0 08 ret <== NOT EXECUTED 4000ec54: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED } 4000ec58: 81 c7 e0 08 ret <== NOT EXECUTED 4000ec5c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED return &the_chain->Tail.Node; 4000ec60: 86 07 20 e4 add %i4, 0xe4, %g3 <== NOT EXECUTED the_node->next = tail; 4000ec64: c6 24 20 20 st %g3, [ %l0 + 0x20 ] <== NOT EXECUTED _Chain_Append_if_is_off_chain_unprotected( 4000ec68: 86 04 20 20 add %l0, 0x20, %g3 <== NOT EXECUTED tail->previous = the_node; 4000ec6c: c6 27 20 e8 st %g3, [ %i4 + 0xe8 ] <== NOT EXECUTED old_last->next = the_node; 4000ec70: c6 20 80 00 st %g3, [ %g2 ] <== NOT EXECUTED the_node->previous = old_last; 4000ec74: c4 24 20 24 st %g2, [ %l0 + 0x24 ] <== NOT EXECUTED 4000ec78: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ec7c: 01 00 00 00 nop <== NOT EXECUTED 4000ec80: 30 bf ff d0 b,a 4000ebc0 <== NOT EXECUTED =============================================================================== 4000eccc : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority_p ) { 4000eccc: 9d e3 bf 70 save %sp, -144, %sp Thread_queue_Context queue_context; const Scheduler_Control *scheduler; Priority_Control old_priority; rtems_status_code status; if ( old_priority_p == NULL ) { 4000ecd0: 80 a6 a0 00 cmp %i2, 0 4000ecd4: 02 80 00 18 be 4000ed34 <== NEVER TAKEN 4000ecd8: b8 10 20 09 mov 9, %i4 queue_context->Priority.update_count = 0; 4000ecdc: c0 27 bf f0 clr [ %fp + -16 ] return RTEMS_INVALID_ADDRESS; } _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_clear_priority_updates( &queue_context ); the_thread = _Thread_Get( id, &queue_context.Lock_context.Lock_context ); 4000ece0: 90 10 00 18 mov %i0, %o0 4000ece4: 40 00 11 88 call 40013304 <_Thread_Get> 4000ece8: 92 07 bf dc add %fp, -36, %o1 if ( the_thread == NULL ) { 4000ecec: b8 92 20 00 orcc %o0, 0, %i4 4000ecf0: 02 80 00 3e be 4000ede8 <== NEVER TAKEN 4000ecf4: 80 a6 60 00 cmp %i1, 0 4000ecf8: c2 07 20 38 ld [ %i4 + 0x38 ], %g1 _Thread_Wait_acquire_critical( the_thread, &queue_context ); scheduler = _Thread_Scheduler_get_home( the_thread ); old_priority = _Thread_Get_priority( the_thread ); if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 4000ecfc: 12 80 00 10 bne 4000ed3c 4000ed00: e0 18 60 18 ldd [ %g1 + 0x18 ], %l0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000ed04: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000ed08: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ed0c: 01 00 00 00 nop 4000ed10: 3b 10 00 b5 sethi %hi(0x4002d400), %i5 new_priority, &queue_context ); } else { _Thread_Wait_release( the_thread, &queue_context ); status = RTEMS_SUCCESSFUL; 4000ed14: b8 10 20 00 clr %i4 4000ed18: ba 17 60 b8 or %i5, 0xb8, %i5 return ( *scheduler->Operations.unmap_priority )( scheduler, priority ); 4000ed1c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 4000ed20: 92 10 00 10 mov %l0, %o1 4000ed24: 94 10 00 11 mov %l1, %o2 4000ed28: 9f c0 40 00 call %g1 4000ed2c: 90 10 00 1d mov %i5, %o0 RTEMS_INLINE_ROUTINE rtems_task_priority _RTEMS_Priority_From_core( const Scheduler_Control *scheduler, Priority_Control priority ) { return (rtems_task_priority) 4000ed30: d2 26 80 00 st %o1, [ %i2 ] } *old_priority_p = _RTEMS_Priority_From_core( scheduler, old_priority ); return status; } 4000ed34: 81 c7 e0 08 ret 4000ed38: 91 e8 00 1c restore %g0, %i4, %o0 *valid = ( priority <= scheduler->maximum_priority ); 4000ed3c: 3b 10 00 b5 sethi %hi(0x4002d400), %i5 4000ed40: ba 17 60 b8 or %i5, 0xb8, %i5 ! 4002d4b8 <_Scheduler_Table> return ( *scheduler->Operations.map_priority )( scheduler, priority ); 4000ed44: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 4000ed48: f6 07 60 40 ld [ %i5 + 0x40 ], %i3 4000ed4c: f0 07 60 44 ld [ %i5 + 0x44 ], %i0 4000ed50: 92 10 20 00 clr %o1 4000ed54: 94 10 00 19 mov %i1, %o2 4000ed58: 9f c0 40 00 call %g1 4000ed5c: 90 10 00 1d mov %i5, %o0 if ( !valid ) { 4000ed60: 80 a6 e0 00 cmp %i3, 0 4000ed64: 32 80 00 06 bne,a 4000ed7c <== NEVER TAKEN 4000ed68: d0 3f 20 30 std %o0, [ %i4 + 0x30 ] <== NOT EXECUTED 4000ed6c: 80 a6 40 18 cmp %i1, %i0 4000ed70: 18 80 00 19 bgu 4000edd4 <== NEVER TAKEN 4000ed74: 01 00 00 00 nop RTEMS_INLINE_ROUTINE void _Priority_Node_set_priority( Priority_Node *node, Priority_Control priority ) { node->priority = priority; 4000ed78: d0 3f 20 30 std %o0, [ %i4 + 0x30 ] _Thread_Priority_changed( 4000ed7c: 96 07 bf dc add %fp, -36, %o3 4000ed80: 94 10 20 00 clr %o2 4000ed84: 92 07 20 20 add %i4, 0x20, %o1 4000ed88: 40 00 10 72 call 40012f50 <_Thread_Priority_changed> 4000ed8c: 90 10 00 1c mov %i4, %o0 disable_level = cpu_self->thread_dispatch_disable_level; 4000ed90: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000ed94: 82 00 60 01 inc %g1 <== NOT EXECUTED return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000ed98: b6 10 00 06 mov %g6, %i3 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000ed9c: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000eda0: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000eda4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000eda8: 01 00 00 00 nop _Thread_Priority_update( queue_context ); 4000edac: 40 00 10 70 call 40012f6c <_Thread_Priority_update> 4000edb0: 90 07 bf dc add %fp, -36, %o0 uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000edb4: c2 06 e0 18 ld [ %i3 + 0x18 ], %g1 if ( disable_level == 1 ) { 4000edb8: 80 a0 60 01 cmp %g1, 1 4000edbc: 02 80 00 0e be 4000edf4 <== ALWAYS TAKEN 4000edc0: 82 00 7f ff add %g1, -1, %g1 return RTEMS_SUCCESSFUL; 4000edc4: b8 10 20 00 clr %i4 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level - 1; 4000edc8: c2 26 e0 18 st %g1, [ %i3 + 0x18 ] <== NOT EXECUTED return ( *scheduler->Operations.unmap_priority )( scheduler, priority ); 4000edcc: 10 bf ff d5 b 4000ed20 <== NOT EXECUTED 4000edd0: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000edd4: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000edd8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000eddc: 01 00 00 00 nop <== NOT EXECUTED return RTEMS_INVALID_PRIORITY; 4000ede0: 10 bf ff cf b 4000ed1c <== NOT EXECUTED 4000ede4: b8 10 20 13 mov 0x13, %i4 ! 13 <_TLS_Alignment+0x12> <== NOT EXECUTED return RTEMS_INVALID_ID; 4000ede8: b8 10 20 04 mov 4, %i4 <== NOT EXECUTED } 4000edec: 81 c7 e0 08 ret <== NOT EXECUTED 4000edf0: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000edf4: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 4000edf8: c4 0e e0 1c ldub [ %i3 + 0x1c ], %g2 4000edfc: 80 a0 a0 00 cmp %g2, 0 4000ee00: 12 80 00 07 bne 4000ee1c <== NEVER TAKEN 4000ee04: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = 0; 4000ee08: c0 26 e0 18 clr [ %i3 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000ee0c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000ee10: 01 00 00 00 nop return RTEMS_SUCCESSFUL; 4000ee14: 10 bf ff c2 b 4000ed1c 4000ee18: b8 10 20 00 clr %i4 ! 0 _Thread_Do_dispatch( cpu_self, level ); 4000ee1c: c2 27 bf d4 st %g1, [ %fp + -44 ] <== NOT EXECUTED 4000ee20: 40 00 10 da call 40013188 <_Thread_Do_dispatch> <== NOT EXECUTED 4000ee24: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 4000ee28: 10 bf ff f9 b 4000ee0c <== NOT EXECUTED 4000ee2c: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED =============================================================================== 400064a8 : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 400064a8: 9d e3 bf 90 save %sp, -112, %sp Thread_Entry_information entry = { 400064ac: 03 10 00 27 sethi %hi(0x40009c00), %g1 400064b0: 82 10 61 d4 or %g1, 0x1d4, %g1 ! 40009dd4 <_Thread_Entry_adaptor_numeric> }; Thread_Control *the_thread; ISR_lock_Context lock_context; bool ok; the_thread = _Thread_Get( id, &lock_context ); 400064b4: 90 10 00 18 mov %i0, %o0 Thread_Entry_information entry = { 400064b8: f2 27 bf f8 st %i1, [ %fp + -8 ] the_thread = _Thread_Get( id, &lock_context ); 400064bc: 92 07 bf f0 add %fp, -16, %o1 Thread_Entry_information entry = { 400064c0: f4 27 bf fc st %i2, [ %fp + -4 ] if ( _Thread_MP_Is_remote( id ) ) { return RTEMS_ILLEGAL_ON_REMOTE_OBJECT; } #endif return RTEMS_INVALID_ID; 400064c4: b0 10 20 04 mov 4, %i0 the_thread = _Thread_Get( id, &lock_context ); 400064c8: 40 00 0e 49 call 40009dec <_Thread_Get> 400064cc: c2 27 bf f4 st %g1, [ %fp + -12 ] if ( the_thread == NULL ) { 400064d0: 80 a2 20 00 cmp %o0, 0 400064d4: 02 80 00 08 be 400064f4 <== NEVER TAKEN 400064d8: 94 07 bf f0 add %fp, -16, %o2 } ok = _Thread_Start( the_thread, &entry, &lock_context ); 400064dc: 40 00 14 95 call 4000b730 <_Thread_Start> 400064e0: 92 07 bf f4 add %fp, -12, %o1 return ok ? RTEMS_SUCCESSFUL : RTEMS_INCORRECT_STATE; 400064e4: 80 a0 00 08 cmp %g0, %o0 400064e8: b0 60 20 00 subx %g0, 0, %i0 400064ec: b0 0e 3f f2 and %i0, -14, %i0 400064f0: b0 06 20 0e add %i0, 0xe, %i0 } 400064f4: 81 c7 e0 08 ret 400064f8: 81 e8 00 00 restore =============================================================================== 4000ee84 : #include rtems_status_code rtems_task_wake_after( rtems_interval ticks ) { 4000ee84: 9d e3 bf 98 save %sp, -104, %sp disable_level = cpu_self->thread_dispatch_disable_level; 4000ee88: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000ee8c: 82 00 60 01 inc %g1 4000ee90: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000ee94: ba 10 00 06 mov %g6, %i5 Per_CPU_Control *cpu_self; cpu_self = _Thread_Dispatch_disable(); executing = _Per_CPU_Get_executing( cpu_self ); if ( ticks == 0 ) { 4000ee98: 80 a6 20 00 cmp %i0, 0 4000ee9c: 02 80 00 1d be 4000ef10 <== NEVER TAKEN 4000eea0: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4 _Thread_Yield( executing ); } else { _Thread_Set_state( executing, STATES_WAITING_FOR_TIME ); 4000eea4: 92 10 21 00 mov 0x100, %o1 4000eea8: 40 00 18 c3 call 400151b4 <_Thread_Set_state> 4000eeac: 90 10 00 1c mov %i4, %o0 the_thread->Wait.flags = flags; 4000eeb0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 4000eeb4: c2 27 20 50 st %g1, [ %i4 + 0x50 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000eeb8: 91 d0 20 09 ta 9 <== NOT EXECUTED return psr; 4000eebc: c2 27 bf fc st %g1, [ %fp + -4 ] the_thread->Timer.Watchdog.routine = _Thread_Timeout; 4000eec0: 05 10 00 55 sethi %hi(0x40015400), %g2 expire = ticks + cpu->Watchdog.ticks; 4000eec4: d4 1f 60 30 ldd [ %i5 + 0x30 ], %o2 &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ]; 4000eec8: 90 07 60 38 add %i5, 0x38, %o0 the_thread->Timer.Watchdog.routine = _Thread_Timeout; 4000eecc: 84 10 a0 20 or %g2, 0x20, %g2 the_thread->Timer.header = 4000eed0: d0 27 20 60 st %o0, [ %i4 + 0x60 ] _Watchdog_Insert(header, the_watchdog, expire); 4000eed4: 86 82 c0 18 addcc %o3, %i0, %g3 the_thread->Timer.Watchdog.routine = _Thread_Timeout; 4000eed8: c4 27 20 78 st %g2, [ %i4 + 0x78 ] 4000eedc: 84 42 a0 00 addx %o2, 0, %g2 4000eee0: 92 07 20 68 add %i4, 0x68, %o1 4000eee4: 94 10 00 02 mov %g2, %o2 4000eee8: 40 00 1a 8e call 40015920 <_Watchdog_Insert> 4000eeec: 96 10 00 03 mov %g3, %o3 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000eef0: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000eef4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000eef8: 01 00 00 00 nop _Thread_Wait_flags_set( executing, THREAD_WAIT_STATE_BLOCKED ); _Thread_Add_timeout_ticks( executing, cpu_self, ticks ); } _Thread_Dispatch_direct( cpu_self ); return RTEMS_SUCCESSFUL; } 4000eefc: b0 10 20 00 clr %i0 ! 0 _Thread_Dispatch_direct( cpu_self ); 4000ef00: 40 00 10 ea call 400132a8 <_Thread_Dispatch_direct> 4000ef04: 90 10 00 1d mov %i5, %o0 } 4000ef08: 81 c7 e0 08 ret 4000ef0c: 81 e8 00 00 restore _Thread_Yield( executing ); 4000ef10: 40 00 19 4b call 4001543c <_Thread_Yield> <== NOT EXECUTED 4000ef14: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED } 4000ef18: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Dispatch_direct( cpu_self ); 4000ef1c: 40 00 10 e3 call 400132a8 <_Thread_Dispatch_direct> <== NOT EXECUTED 4000ef20: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED } 4000ef24: 81 c7 e0 08 ret <== NOT EXECUTED 4000ef28: 81 e8 00 00 restore <== NOT EXECUTED