RTEMS-5
Annotated Report
Tue Jun 19 13:18:53 2018
4001b884 <TOD_TICKS_PER_SECOND_method>:
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 <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0xf40f0>
<== 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 <rtems/score/apimutex.h>
#include <rtems/score/percpu.h>
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 <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0xebd>
<== 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 <RAM_END+0x3fbfffff>
<== 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 <memset>
<== 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 <memcpy>
<== 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 <memset>
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 <state_pairs+0xf8>
<== 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 <state_pairs+0x108>
<== 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 <state_pairs+0xd8>
<== 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 <state_pairs+0xe8>
<== 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 <memcpy>
<== 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 <memcpy>
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 <strlen>
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 <rtems/score/objectimpl.h>
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 <CSWTCH.1>
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 <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0xfeaf>
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 <memcpy>
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 <memcpy>
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 <memcpy>
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 <PROM_START>
<== 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 <RAM_END+0xbfbfffff>
<== 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 <rtems/score/wkspace.h>
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 <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0xfeaf>
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 <rtems/score/rbtreeimpl.h>
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 <rtems/score/rbtreeimpl.h>
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 <rtems/score/rbtreeimpl.h>
#include <rtems/score/basedefs.h>
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 <Configuration_RTEMS_API>
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 <rtems_task_create>
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 <rtems_task_start>
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 <Configuration+0x18>
<== 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 <rtems_task_mode>
<== NOT EXECUTED
40019d9c: 92 16 e3 ff or %i3, 0x3ff, %o1 ! ffff <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0xfeaf>
<== 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 <rtems_task_mode>
<== 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 <RAM_END+0xb42fa09>
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 <RAM_END+0x92b92c6f>
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 <RAM_SIZE+0x219ae500>
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 <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0xf40f0>
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 <RAM_END+0x11ab851f>
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 <rtems/score/threadimpl.h>
#include <rtems/score/status.h>
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 <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0xfdb0>
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 <RAM_SIZE+0x2fc15fff>
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 <rtems/score/threadimpl.h>
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 <strlcpy>
<== 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 <Configuration>
#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 <memset>
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 <Configuration+0x18>
<== 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 <rtems/config.h>
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 <Configuration+0x30>
* 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 <PROM_START>
<== 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 <PROM_START>
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 <rtems/score/threadimpl.h>
#include <rtems/score/assert.h>
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 <rtems/score/threadimpl.h>
#include <rtems/score/schedulerimpl.h>
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 <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0x2bbe>
<== 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 <RAM_SIZE+0x2fc15fff>
<== 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 <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0x14b7>
<== 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 <strlcpy>
<== 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 <strlcpy>
<== 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 <timehands>
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 <timehands>
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 <timehands>
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 <timehands>
<== 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 <timecounters>
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 <timehands>
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 <timehands>
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 <RAM_SIZE+0x3b5aca00>
<== 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 <RAM_SIZE+0x3b5aca00>
<== 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 <rtems/score/todimpl.h>
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 <RAM_SIZE+0x3b5aca00>
<== 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 <TOD_TICKS_PER_SECOND_method>
<== 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 <rtems/config.h>
#include <rtems/score/userextimpl.h>
#include <rtems/score/wkspace.h>
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 <Configuration>
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 <Configuration>
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 <Configuration>
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 <Configuration_RTEMS_API>
<== 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 <memset>
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_clock_get_tod>:
}
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 <rtems_clock_get_tod+0x25c>
<== 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 <rtems_clock_get_tod+0x114>
<== 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 <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0x15030>
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 <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0x15030>
/* 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 <RAM_END+0x26d9f361>
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 <rtems_clock_get_tod+0x11c>
<== 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 <rtems_clock_get_tod+0x240>
<== 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 <rtems_clock_get_tod+0x124>
<== 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 <rtems_clock_get_tod+0x124>
<== 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 <rtems_clock_get_tod+0x144>
<== 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 <rtems_clock_get_tod+0x210>
<== 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 <rtems_clock_get_tod+0x214>
<== 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 <rtems_clock_get_tod+0x254>
<== 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 <rtems_clock_get_tod+0x16c>
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 <RAM_END+0x11ab851f>
<== 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 <rtems_clock_get_tod+0x158>
<== 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 <rtems_clock_get_tod+0x15c>
<== 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 <rtems_clock_get_tod+0x264>
<== NOT EXECUTED
40043b24: 3b 10 02 0e sethi %hi(0x40083800), %i5
<== NOT EXECUTED
year_days += 1;
40043b28: 10 bf ff b6 b 40043a00 <rtems_clock_get_tod+0x124>
<== NOT EXECUTED
40043b2c: 82 00 60 01 inc %g1
<== NOT EXECUTED
40043b30: 10 bf ff ce b 40043a68 <rtems_clock_get_tod+0x18c>
<== 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 <rtems_clock_get_tod+0x15c>
<== NOT EXECUTED
40043b48: ba 17 63 1a or %i5, 0x31a, %i5
<== NOT EXECUTED
40043b4c <rtems_clock_get_tod_timeval>:
#include <rtems/score/todimpl.h>
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 <rtems_clock_get_tod_timeval+0x30>
<== 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 <rtems_clock_get_tod_timeval+0x28>
<== 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 <rtems_clock_get_uptime>:
* 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 <rtems_clock_get_uptime+0x30>
<== 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 <rtems_clock_get_uptime_nanoseconds>:
#include <rtems/rtems/clock.h>
#include <rtems/score/todimpl.h>
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 <RAM_SIZE+0x3b5aca00>
<== 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 <rtems_clock_set>:
#include <rtems/config.h>
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 <rtems_clock_set+0x74>
<== 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 <rtems_clock_set+0x74>
<== 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_receive>:
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 <rtems_event_receive+0x78>
<== 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 <rtems_event_receive+0x44>
<== 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_event_send>:
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 <rtems_event_send+0x34>
<== 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_system_receive>:
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 <rtems_event_system_receive+0x7c>
<== 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 <rtems_event_system_receive+0x44>
<== 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_event_system_send>:
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 <rtems_event_system_send+0x38>
<== 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 <rtems_get_current_processor>:
#include <rtems/score/smp.h>
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 <rtems_get_processor_count>:
#include <rtems/score/smp.h>
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_interrupt_catch>:
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 <rtems_interrupt_catch+0x34>
<== 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 <rtems_interrupt_catch+0x3c>
<== NEVER TAKEN
40006088: 80 a6 a0 00 cmp %i2, 0
4000608c: 02 80 00 08 be 400060ac <rtems_interrupt_catch+0x3c>
<== 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 <rtems_message_queue_delete>:
#include <rtems/rtems/attrimpl.h>
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 <rtems_message_queue_delete+0x5c>
<== 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_object_get_classic_name>:
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 <rtems_object_get_classic_name+0x34>
<== 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 <rtems_object_get_name>:
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_rate_monotonic_get_statistics>:
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 <rtems_rate_monotonic_get_statistics+0x114>
<== 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 <rtems_rate_monotonic_get_statistics+0x11c>
<== 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 <PROM_START>
<== 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_rate_monotonic_get_status>:
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 <rtems_rate_monotonic_get_status+0x78>
<== 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 <rtems_rate_monotonic_get_status+0xe8>
<== 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 <rtems_rate_monotonic_get_status+0x80>
<== 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 <rtems_rate_monotonic_get_status+0x6c>
<== 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 <rtems_rate_monotonic_get_status+0x6c>
<== 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 <rtems_rate_monotonic_report_statistics_with_plugin>:
#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 <rtems_printf>
<== 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 <rtems_printf>
<== 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 <rtems_printf>
<== 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 <rtems_printf>
<== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x22c>
<== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x1ac>
<== 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 <rtems_printf>
<== 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 <rtems_printf>
<== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x22c>
<== 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 <rtems_rate_monotonic_get_statistics>
<== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x198>
<== 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 <rtems_rate_monotonic_get_status>
<== 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 <rtems_object_get_name>
<== 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 <rtems_printf>
<== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x88>
<== 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 <rtems_printf>
<== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x1b0>
<== 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>:
/*
* 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 <rtems_rate_monotonic_reset_all_statistics+0x40>
<== 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 <rtems_rate_monotonic_reset_statistics>
<== 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 <rtems_rate_monotonic_reset_all_statistics+0x24>
<== 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 <rtems_rate_monotonic_reset_statistics>:
#include <rtems/rtems/ratemonimpl.h>
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 <rtems_rate_monotonic_reset_statistics+0x60>
<== 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 <memset>
<== 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 <PROM_START>
<== NOT EXECUTED
}
400440fc: 81 c7 e0 08 ret
<== NOT EXECUTED
40044100: 81 e8 00 00 restore
<== NOT EXECUTED
4000dc48 <rtems_semaphore_create>:
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 <rtems_semaphore_create+0xf4>
<== 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 <rtems_semaphore_create+0x1e4>
<== 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 <rtems_semaphore_create+0x64>
<== 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 <rtems_semaphore_create+0xf4>
<== 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 <rtems_semaphore_create+0xfc>
<== 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 <rtems_semaphore_create+0x1f0>
<== 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 <rtems_semaphore_create+0x208>
<== 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 <rtems_semaphore_create+0x5c>
<== NOT EXECUTED
4000dc98: 80 a0 a1 10 cmp %g2, 0x110
<== NOT EXECUTED
4000dc9c: 12 80 00 28 bne 4000dd3c <rtems_semaphore_create+0xf4>
<== NOT EXECUTED
4000dca0: 82 10 20 0b mov 0xb, %g1
<== NOT EXECUTED
4000dca4: 10 80 00 03 b 4000dcb0 <rtems_semaphore_create+0x68>
<== 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 <rtems_semaphore_create+0x1f8>
<== 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 <rtems_semaphore_create+0x104>
<== 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 <rtems_semaphore_create+0x118>
<== NOT EXECUTED
4000dcf8: c2 2f 60 38 stb %g1, [ %i5 + 0x38 ]
<== NOT EXECUTED
4000dcfc: 0a 80 00 45 bcs 4000de10 <rtems_semaphore_create+0x1c8>
<== NOT EXECUTED
4000dd00: 80 a0 a0 02 cmp %g2, 2
<== NOT EXECUTED
4000dd04: 02 80 00 43 be 4000de10 <rtems_semaphore_create+0x1c8>
<== 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 <rtems_semaphore_create+0x68>
<== 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 <rtems_semaphore_create+0xb4>
<== 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 <rtems_semaphore_create+0x210>
<== 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 <rtems_semaphore_create+0xcc>
<== 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 <rtems_semaphore_create+0x1a0>
<== NOT EXECUTED
4000ddc8: 01 00 00 00 nop
<== NOT EXECUTED
4000ddcc: 32 80 00 27 bne,a 4000de68 <rtems_semaphore_create+0x220>
<== 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 <rtems_semaphore_create+0x220>
<== 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 <rtems_semaphore_create+0xf4>
<== 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 <rtems_semaphore_create+0xcc>
<== 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 <rtems_semaphore_create+0xcc>
<== 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 <rtems_semaphore_create+0x68>
<== 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 <rtems_semaphore_create+0xf4>
<== 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 <rtems_semaphore_create+0x68>
<== 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 <rtems_semaphore_create+0x148>
<== NOT EXECUTED
4000de60: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000de64: 30 bf ff e5 b,a 4000ddf8 <rtems_semaphore_create+0x1b0>
<== 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 <rtems_semaphore_create+0x270>
<== 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 <rtems_semaphore_create+0xd0>
<== 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 <rtems_semaphore_create+0x298>
<== 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 <rtems_semaphore_create+0xd0>
<== 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 <rtems_semaphore_create+0x288>
<== NOT EXECUTED
4000def0: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
4000def4 <rtems_semaphore_delete>:
#include <rtems/rtems/statusimpl.h>
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 <rtems_semaphore_delete+0x12c>
<== 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 <rtems_semaphore_delete+0x4c>
<== 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 <rtems_semaphore_delete+0xdc>
<== 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 <rtems_semaphore_delete+0x9c>
<== 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 <rtems_semaphore_delete+0xf8>
<== 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_semaphore_obtain>:
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 <rtems_semaphore_obtain+0x1cc>
<== 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 <rtems_semaphore_obtain+0xb0>
<== 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 <rtems_semaphore_obtain+0xd4>
<== NOT EXECUTED
4000e080: 84 02 20 10 add %o0, 0x10, %g2
<== NOT EXECUTED
4000e084: 0a 80 00 42 bcs 4000e18c <rtems_semaphore_obtain+0x15c>
<== NOT EXECUTED
4000e088: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
4000e08c: 12 80 00 2d bne 4000e140 <rtems_semaphore_obtain+0x110>
<== 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 <rtems_semaphore_obtain+0x1a0>
<== 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 <rtems_semaphore_obtain+0x1b4>
<== NOT EXECUTED
4000e0b4: 80 a7 40 01 cmp %i5, %g1
<== NOT EXECUTED
if ( owner == executing ) {
4000e0b8: 12 80 00 74 bne 4000e288 <rtems_semaphore_obtain+0x258>
<== 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 <rtems_semaphore_obtain+0x54>
<== 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 <rtems_semaphore_obtain+0x20c>
<== 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 <rtems_semaphore_obtain+0x94>
<== 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 <rtems_semaphore_obtain+0x198>
<== 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 <rtems_semaphore_obtain+0x1fc>
<== 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 <rtems_semaphore_obtain+0x1d4>
<== 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 <rtems_semaphore_obtain+0x1dc>
<== 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 <rtems_semaphore_obtain+0x1b4>
<== NOT EXECUTED
4000e198: 80 a7 40 01 cmp %i5, %g1
<== NOT EXECUTED
if ( owner == executing ) {
4000e19c: 22 bf ff ca be,a 4000e0c4 <rtems_semaphore_obtain+0x94>
<== 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 <rtems_semaphore_obtain+0x130>
<== 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 <rtems_semaphore_obtain+0x204>
<== 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 <rtems_semaphore_obtain+0x78>
<== 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 <rtems_semaphore_obtain+0x98>
<== 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 <rtems_semaphore_obtain+0x130>
<== NOT EXECUTED
4000e230: 92 12 63 f4 or %o1, 0x3f4, %o1
<== NOT EXECUTED
4000e234: 10 bf ff 9d b 4000e0a8 <rtems_semaphore_obtain+0x78>
<== 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 <rtems_semaphore_obtain+0x244>
<== NOT EXECUTED
4000e254: 01 00 00 00 nop
<== NOT EXECUTED
4000e258: 32 80 00 12 bne,a 4000e2a0 <rtems_semaphore_obtain+0x270>
<== 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 <rtems_semaphore_obtain+0x270>
<== 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 <rtems_semaphore_obtain+0x2c4>
<== 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 <rtems_semaphore_obtain+0x2ec>
<== 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 <rtems_semaphore_obtain+0x2dc>
<== NOT EXECUTED
4000e32c: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
4000e330 <rtems_semaphore_release>:
#include <rtems/rtems/semimpl.h>
#include <rtems/rtems/statusimpl.h>
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 <rtems_semaphore_release+0x164>
<== 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 <rtems_semaphore_release+0xc4>
<== NOT EXECUTED
4000e368: b8 07 60 10 add %i5, 0x10, %i4
<== NOT EXECUTED
4000e36c: 0a 80 00 36 bcs 4000e444 <rtems_semaphore_release+0x114>
<== NOT EXECUTED
4000e370: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
4000e374: 02 80 00 16 be 4000e3cc <rtems_semaphore_release+0x9c>
<== NOT EXECUTED
4000e378: 80 a0 60 03 cmp %g1, 3
<== NOT EXECUTED
4000e37c: 12 80 00 0b bne 4000e3a8 <rtems_semaphore_release+0x78>
<== 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 <rtems_semaphore_release+0x230>
<== 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 <rtems_semaphore_release+0x28c>
<== 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 <rtems_semaphore_release+0x234>
<== 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 <rtems_semaphore_release+0x1b8>
<== 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 <rtems_semaphore_release+0x294>
<== 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 <rtems_semaphore_release+0x1bc>
<== 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 <rtems_semaphore_release+0x16c>
<== 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 <rtems_semaphore_release+0x284>
<== 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 <rtems_semaphore_release+0x170>
<== 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 <rtems_semaphore_release+0x100>
<== 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 <rtems_semaphore_release+0x29c>
<== 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 <rtems_semaphore_release+0x100>
<== 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 <rtems_semaphore_release+0xe8>
<== 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 <rtems_semaphore_release+0x200>
<== 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 <rtems_semaphore_release+0x100>
<== 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 <rtems_semaphore_release+0xe8>
<== 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 <rtems_semaphore_release+0x200>
<== 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 <rtems_semaphore_release+0x1e8>
<== 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 <rtems_semaphore_release+0x214>
<== 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 <rtems_semaphore_release+0x200>
<== 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 <rtems_semaphore_release+0x260>
<== 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 <rtems_semaphore_release+0x214>
<== 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 <rtems_semaphore_release+0x270>
<== 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 <rtems_semaphore_release+0x170>
<== NOT EXECUTED
4000e5b8: 98 13 23 f4 or %o4, 0x3f4, %o4
<== NOT EXECUTED
4000e5bc: 10 bf ff ea b 4000e564 <rtems_semaphore_release+0x234>
<== NOT EXECUTED
4000e5c0: b6 16 e3 f4 or %i3, 0x3f4, %i3
<== NOT EXECUTED
4000e5c4: 10 bf ff ca b 4000e4ec <rtems_semaphore_release+0x1bc>
<== 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 <rtems_semaphore_release+0x330>
<== 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 <rtems_semaphore_release+0x344>
<== 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 <rtems_semaphore_release+0x354>
<== 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 <rtems_semaphore_release+0x30c>
<== 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 <rtems_semaphore_release+0x37c>
<== 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 <rtems_semaphore_release+0x36c>
<== NOT EXECUTED
4000e6bc: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
4000d374 <rtems_status_code_to_errno>:
[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 <rtems_status_code_to_errno+0x3c>
<== 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 <rtems_status_code_to_errno+0x30>
<== 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 <status_code_to_errno>
<== 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 <rtems_status_text>:
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 <rtems_status_text+0x1c>
<== 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 <rtems_filesystem_default_pathconf+0x40>
<== NOT EXECUTED
40006120 <rtems_task_create>:
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 <rtems_task_create+0x148>
<== 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 <rtems_task_create+0x108>
<== 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 <rtems_task_create+0x11c>
<== 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 <rtems_task_create+0x110>
<== 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 <rtems_task_create+0x154>
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 <rtems_task_create+0x128>
<== 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 <rtems_task_create+0x58>
<== 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 <rtems_task_create+0x108>
<== 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 <rtems_task_create+0x108>
40006280: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
40006284 <rtems_task_delete>:
#include <rtems/score/threadimpl.h>
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 <rtems_task_delete+0xac>
<== 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 <rtems_task_delete+0x40>
<== 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 <PROM_START>
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 <rtems_task_delete+0x84>
<== 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 <rtems_task_delete+0xb4>
<== 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 <rtems_task_delete+0x9c>
<== NOT EXECUTED
40006348: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
4000634c <rtems_task_ident>:
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 <rtems_task_ident+0x58>
<== 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 <rtems_task_ident+0x2c>
<== 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 <rtems_task_iterate>:
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_task_mode>:
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 <rtems_task_mode+0x1e4>
<== 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 <rtems_task_mode+0x1a0>
<== 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 <rtems_task_mode+0x7c>
<== 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 <rtems_task_mode+0xa8>
<== 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 <rtems_task_mode+0x1d8>
<== 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 <Configuration+0x18>
<== 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 <rtems_task_mode+0xc4>
<== 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 <rtems_task_mode+0x14c>
<== 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 <rtems_task_mode+0x13c>
<== 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 <rtems_task_mode+0x13c>
<== 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 <rtems_task_mode+0x1f4>
<== 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 <rtems_task_mode+0x154>
<== 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 <rtems_task_mode+0x1ec>
<== 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 <PROM_START>
_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 <rtems_task_mode+0x7c>
<== 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 <rtems_task_mode+0x64>
<== 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 <rtems_task_mode+0xc0>
<== NOT EXECUTED
4000ec48: c0 27 20 90 clr [ %i4 + 0x90 ]
<== NOT EXECUTED
4000ec4c: 30 bf ff b4 b,a 4000eb1c <rtems_task_mode+0xb0>
<== 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 <rtems_task_mode+0x154>
<== NOT EXECUTED
4000eccc <rtems_task_set_priority>:
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 <rtems_task_set_priority+0x68>
<== 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 <rtems_task_set_priority+0x11c>
<== 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 <rtems_task_set_priority+0x70>
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 <rtems_task_set_priority+0xb0>
<== 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 <rtems_task_set_priority+0x108>
<== 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 <rtems_task_set_priority+0x128>
<== 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 <rtems_task_set_priority+0x54>
<== 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 <rtems_task_set_priority+0x50>
<== 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 <rtems_task_set_priority+0x150>
<== 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 <rtems_task_set_priority+0x50>
4000ee18: b8 10 20 00 clr %i4 ! 0 <PROM_START>
_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 <rtems_task_set_priority+0x140>
<== NOT EXECUTED
4000ee2c: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
400064a8 <rtems_task_start>:
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 <rtems_task_start+0x4c>
<== 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 <rtems_task_wake_after>:
#include <rtems/score/watchdogimpl.h>
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 <rtems_task_wake_after+0x8c>
<== 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 <PROM_START>
_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