400080a4 <_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();
400080a4: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
400080a8: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2
<== NOT EXECUTED
400080ac: 82 18 40 02 xor %g1, %g2, %g1
}
400080b0: 80 a0 00 01 cmp %g0, %g1
400080b4: 81 c3 e0 08 retl
400080b8: 90 60 3f ff subx %g0, -1, %o0
40007084 <_API_Mutex_Lock>:
#include <rtems/score/apimutex.h>
#include <rtems/score/threadimpl.h>
void _API_Mutex_Lock( API_Mutex_Control *the_mutex )
{
40007084: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Thread_Life_state previous_thread_life_state;
previous_thread_life_state =
40007088: 40 00 12 51 call 4000b9cc <_Thread_Set_life_protection>
4000708c: 90 10 20 01 mov 1, %o0
40007090: ba 10 00 08 mov %o0, %i5
_Thread_Set_life_protection( THREAD_LIFE_PROTECTED );
_Mutex_recursive_Acquire( &the_mutex->Mutex );
40007094: 40 00 06 f7 call 40008c70 <_Mutex_recursive_Acquire>
40007098: 90 10 00 18 mov %i0, %o0
if ( the_mutex->Mutex._nest_level == 0 ) {
4000709c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
400070a0: 80 a0 60 00 cmp %g1, 0
400070a4: 22 80 00 02 be,a 400070ac <_API_Mutex_Lock+0x28>
400070a8: fa 26 20 18 st %i5, [ %i0 + 0x18 ]
the_mutex->previous_thread_life_state = previous_thread_life_state;
}
}
400070ac: 81 c7 e0 08 ret
400070b0: 81 e8 00 00 restore
400070b4 <_API_Mutex_Unlock>:
#include <rtems/score/apimutex.h>
#include <rtems/score/threadimpl.h>
void _API_Mutex_Unlock( API_Mutex_Control *the_mutex )
{
400070b4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Thread_Life_state previous_thread_life_state;
bool restore_thread_life_protection;
previous_thread_life_state = the_mutex->previous_thread_life_state;
restore_thread_life_protection = the_mutex->Mutex._nest_level == 0;
400070b8: fa 06 20 14 ld [ %i0 + 0x14 ], %i5
<== NOT EXECUTED
{
400070bc: 90 10 00 18 mov %i0, %o0
_Mutex_recursive_Release( &the_mutex->Mutex );
400070c0: 40 00 07 11 call 40008d04 <_Mutex_recursive_Release>
400070c4: f0 06 20 18 ld [ %i0 + 0x18 ], %i0
if ( restore_thread_life_protection ) {
400070c8: 80 a7 60 00 cmp %i5, 0
400070cc: 02 80 00 04 be 400070dc <_API_Mutex_Unlock+0x28>
400070d0: 01 00 00 00 nop
_Thread_Set_life_protection( previous_thread_life_state );
}
}
400070d4: 81 c7 e0 08 ret
400070d8: 81 e8 00 00 restore
_Thread_Set_life_protection( previous_thread_life_state );
400070dc: 40 00 12 3c call 4000b9cc <_Thread_Set_life_protection>
400070e0: 81 e8 00 00 restore
400098f0 <_CORE_RWLock_Initialize>:
void _CORE_RWLock_Initialize(
CORE_RWLock_Control *the_rwlock
)
{
the_rwlock->number_of_readers = 0;
400098f0: c0 22 20 18 clr [ %o0 + 0x18 ]
<== NOT EXECUTED
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
400098f4: c0 22 20 14 clr [ %o0 + 0x14 ]
<== NOT EXECUTED
queue->heads = NULL;
400098f8: c0 22 20 08 clr [ %o0 + 8 ]
<== NOT EXECUTED
queue->owner = NULL;
400098fc: c0 22 20 0c clr [ %o0 + 0xc ]
<== NOT EXECUTED
_Thread_queue_Queue_initialize( &the_rwlock->Queue.Queue, NULL );
}
40009900: 81 c3 e0 08 retl
<== NOT EXECUTED
40009904: c0 22 20 10 clr [ %o0 + 0x10 ]
40009908 <_CORE_RWLock_Seize_for_reading>:
Status_Control _CORE_RWLock_Seize_for_reading(
CORE_RWLock_Control *the_rwlock,
bool wait,
Thread_queue_Context *queue_context
)
{
40009908: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000990c: 91 d0 20 09 ta 9
<== NOT EXECUTED
40009910: c2 26 80 00 st %g1, [ %i2 ]
* If any thread is waiting, then we wait.
*/
executing = _CORE_RWLock_Acquire( the_rwlock, queue_context );
switch ( the_rwlock->current_state ) {
40009914: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40009918: 80 a0 60 00 cmp %g1, 0
4000991c: 02 80 00 1f be 40009998 <_CORE_RWLock_Seize_for_reading+0x90>
40009920: 84 10 00 06 mov %g6, %g2
40009924: 80 a0 60 01 cmp %g1, 1
40009928: 12 80 00 06 bne 40009940 <_CORE_RWLock_Seize_for_reading+0x38>
4000992c: 80 a6 60 00 cmp %i1, 0
the_rwlock->number_of_readers += 1;
_CORE_RWLock_Release( the_rwlock, queue_context );
return STATUS_SUCCESSFUL;
case CORE_RWLOCK_LOCKED_FOR_READING:
if ( _Thread_queue_Is_empty( &the_rwlock->Queue.Queue ) ) {
40009930: c2 06 20 08 ld [ %i0 + 8 ], %g1
40009934: 80 a0 60 00 cmp %g1, 0
40009938: 02 80 00 23 be 400099c4 <_CORE_RWLock_Seize_for_reading+0xbc>
4000993c: 80 a6 60 00 cmp %i1, 0
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
40009940: 02 80 00 0f be 4000997c <_CORE_RWLock_Seize_for_reading+0x74>
40009944: 03 00 00 04 sethi %hi(0x1000), %g1
ISR_Level level;
Thread_Control *executing;
_Thread_queue_Context_ISR_disable( queue_context, level );
_Thread_queue_Context_set_ISR_level( queue_context, level );
executing = _Thread_Executing;
40009948: fa 00 a0 20 ld [ %g2 + 0x20 ], %i5
/*
* We need to wait to enter this critical section
*/
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
4000994c: c0 27 60 48 clr [ %i5 + 0x48 ]
queue_context->thread_state = thread_state;
40009950: c2 26 a0 04 st %g1, [ %i2 + 4 ]
_Thread_queue_Context_set_thread_state(
queue_context,
STATES_WAITING_FOR_RWLOCK
);
_Thread_queue_Enqueue(
40009954: 90 06 20 08 add %i0, 8, %o0
40009958: 96 10 00 1a mov %i2, %o3
4000995c: 94 10 00 1d mov %i5, %o2
40009960: 13 10 00 52 sethi %hi(0x40014800), %o1
CORE_RWLOCK_TQ_OPERATIONS,
executing,
queue_context
);
return _Thread_Wait_get_status( executing );
}
40009964: b0 10 20 00 clr %i0
_Thread_queue_Enqueue(
40009968: 40 00 11 a0 call 4000dfe8 <_Thread_queue_Enqueue>
4000996c: 92 12 61 54 or %o1, 0x154, %o1
40009970: f2 07 60 4c ld [ %i5 + 0x4c ], %i1
}
40009974: 81 c7 e0 08 ret
40009978: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000997c: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009980: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009984: 01 00 00 00 nop
return STATUS_UNAVAILABLE;
40009988: 33 00 00 04 sethi %hi(0x1000), %i1
4000998c: b2 16 60 0d or %i1, 0xd, %i1 ! 100d <_Configuration_Interrupt_stack_size+0xd>
}
40009990: 81 c7 e0 08 ret
40009994: 91 e8 20 00 restore %g0, 0, %o0
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
40009998: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
4000999c: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
<== NOT EXECUTED
the_rwlock->number_of_readers += 1;
400099a0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
400099a4: 82 00 60 01 inc %g1
<== NOT EXECUTED
the_rwlock->number_of_readers += 1;
400099a8: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400099ac: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400099b0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400099b4: 01 00 00 00 nop
return STATUS_SUCCESSFUL;
400099b8: b2 10 20 00 clr %i1 ! 0 <PROM_START>
}
400099bc: 81 c7 e0 08 ret
400099c0: 91 e8 20 00 restore %g0, 0, %o0
the_rwlock->number_of_readers += 1;
400099c4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
400099c8: 10 bf ff f8 b 400099a8 <_CORE_RWLock_Seize_for_reading+0xa0>
400099cc: 82 00 60 01 inc %g1
400099d0 <_CORE_RWLock_Seize_for_writing>:
Status_Control _CORE_RWLock_Seize_for_writing(
CORE_RWLock_Control *the_rwlock,
bool wait,
Thread_queue_Context *queue_context
)
{
400099d0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400099d4: 91 d0 20 09 ta 9
<== NOT EXECUTED
400099d8: c2 26 80 00 st %g1, [ %i2 ]
* If any thread is waiting, then we wait.
*/
executing = _CORE_RWLock_Acquire( the_rwlock, queue_context );
switch ( the_rwlock->current_state ) {
400099dc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
400099e0: 80 a0 60 00 cmp %g1, 0
400099e4: 02 80 00 19 be 40009a48 <_CORE_RWLock_Seize_for_writing+0x78>
400099e8: 80 a6 60 00 cmp %i1, 0
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
400099ec: 02 80 00 10 be 40009a2c <_CORE_RWLock_Seize_for_writing+0x5c>
400099f0: 82 10 20 01 mov 1, %g1
400099f4: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
/*
* We need to wait to enter this critical section
*/
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE;
400099f8: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
400099fc: 03 00 00 04 sethi %hi(0x1000), %g1
40009a00: c2 26 a0 04 st %g1, [ %i2 + 4 ]
_Thread_queue_Context_set_thread_state(
queue_context,
STATES_WAITING_FOR_RWLOCK
);
_Thread_queue_Enqueue(
40009a04: 90 06 20 08 add %i0, 8, %o0
40009a08: 96 10 00 1a mov %i2, %o3
40009a0c: 94 10 00 1d mov %i5, %o2
40009a10: 13 10 00 52 sethi %hi(0x40014800), %o1
CORE_RWLOCK_TQ_OPERATIONS,
executing,
queue_context
);
return _Thread_Wait_get_status( executing );
}
40009a14: b0 10 20 00 clr %i0
_Thread_queue_Enqueue(
40009a18: 40 00 11 74 call 4000dfe8 <_Thread_queue_Enqueue>
40009a1c: 92 12 61 54 or %o1, 0x154, %o1
40009a20: f2 07 60 4c ld [ %i5 + 0x4c ], %i1
}
40009a24: 81 c7 e0 08 ret
40009a28: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40009a2c: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009a30: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009a34: 01 00 00 00 nop
return STATUS_UNAVAILABLE;
40009a38: 33 00 00 04 sethi %hi(0x1000), %i1
40009a3c: b2 16 60 0d or %i1, 0xd, %i1 ! 100d <_Configuration_Interrupt_stack_size+0xd>
}
40009a40: 81 c7 e0 08 ret
40009a44: 91 e8 20 00 restore %g0, 0, %o0
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
40009a48: 82 10 20 02 mov 2, %g1
<== NOT EXECUTED
40009a4c: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40009a50: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009a54: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009a58: 01 00 00 00 nop
return STATUS_SUCCESSFUL;
40009a5c: b2 10 20 00 clr %i1 ! 0 <PROM_START>
}
40009a60: 81 c7 e0 08 ret
40009a64: 91 e8 20 00 restore %g0, 0, %o0
40009aec <_CORE_RWLock_Surrender>:
Status_Control _CORE_RWLock_Surrender( CORE_RWLock_Control *the_rwlock )
{
40009aec: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40009af0: 91 d0 20 09 ta 9
<== NOT EXECUTED
40009af4: c2 27 bf dc st %g1, [ %fp + -36 ]
*/
_Thread_queue_Context_initialize( &queue_context );
_CORE_RWLock_Acquire( the_rwlock, &queue_context );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
40009af8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40009afc: 80 a0 60 00 cmp %g1, 0
40009b00: 02 80 00 14 be 40009b50 <_CORE_RWLock_Surrender+0x64>
40009b04: 80 a0 60 01 cmp %g1, 1
/* This is an error at the caller site */
_CORE_RWLock_Release( the_rwlock, &queue_context );
return STATUS_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
40009b08: 32 80 00 08 bne,a 40009b28 <_CORE_RWLock_Surrender+0x3c>
40009b0c: c0 26 20 14 clr [ %i0 + 0x14 ]
the_rwlock->number_of_readers -= 1;
40009b10: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40009b14: 82 00 7f ff add %g1, -1, %g1
if ( the_rwlock->number_of_readers != 0 ) {
40009b18: 80 a0 60 00 cmp %g1, 0
40009b1c: 12 80 00 0d bne 40009b50 <_CORE_RWLock_Surrender+0x64>
40009b20: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
/*
* Implicitly transition to "unlocked" and find another thread interested
* in obtaining this rwlock.
*/
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
40009b24: c0 26 20 14 clr [ %i0 + 0x14 ]
_Thread_queue_Flush_critical(
40009b28: 96 07 bf dc add %fp, -36, %o3
40009b2c: 90 06 20 08 add %i0, 8, %o0
40009b30: 15 10 00 26 sethi %hi(0x40009800), %o2
40009b34: 13 10 00 52 sethi %hi(0x40014800), %o1
40009b38: 94 12 a2 68 or %o2, 0x268, %o2
40009b3c: 92 12 61 54 or %o1, 0x154, %o1
40009b40: 40 00 12 2b call 4000e3ec <_Thread_queue_Flush_critical>
40009b44: b0 10 20 00 clr %i0
CORE_RWLOCK_TQ_OPERATIONS,
_CORE_RWLock_Flush_filter,
&queue_context
);
return STATUS_SUCCESSFUL;
}
40009b48: 81 c7 e0 08 ret
40009b4c: 93 e8 20 00 restore %g0, 0, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40009b50: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009b54: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009b58: 01 00 00 00 nop
40009b5c: b0 10 20 00 clr %i0 ! 0 <PROM_START>
40009b60: 81 c7 e0 08 ret
40009b64: 93 e8 20 00 restore %g0, 0, %o1
4000effc <_CORE_barrier_Seize>:
CORE_barrier_Control *the_barrier,
Thread_Control *executing,
bool wait,
Thread_queue_Context *queue_context
)
{
4000effc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
uint32_t number_of_waiting_threads;
_CORE_barrier_Acquire_critical( the_barrier, queue_context );
number_of_waiting_threads = the_barrier->number_of_waiting_threads;
4000f000: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
++number_of_waiting_threads;
if (
4000f004: c4 06 20 0c ld [ %i0 + 0xc ], %g2
<== NOT EXECUTED
4000f008: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000f00c: 12 80 00 06 bne 4000f024 <_CORE_barrier_Seize+0x28>
<== NOT EXECUTED
4000f010: 82 00 60 01 inc %g1
_CORE_barrier_Is_automatic( &the_barrier->Attributes )
&& number_of_waiting_threads == the_barrier->Attributes.maximum_count
4000f014: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
4000f018: 80 a0 80 01 cmp %g2, %g1
4000f01c: 02 80 00 0e be 4000f054 <_CORE_barrier_Seize+0x58>
4000f020: 94 10 00 1b mov %i3, %o2
) {
_CORE_barrier_Surrender( the_barrier, queue_context );
return STATUS_BARRIER_AUTOMATICALLY_RELEASED;
} else {
the_barrier->number_of_waiting_threads = number_of_waiting_threads;
4000f024: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
queue_context->thread_state = thread_state;
4000f028: 82 10 28 00 mov 0x800, %g1
4000f02c: c2 26 e0 04 st %g1, [ %i3 + 4 ]
_Thread_queue_Context_set_thread_state(
queue_context,
STATES_WAITING_FOR_BARRIER
);
_Thread_queue_Enqueue(
4000f030: 94 10 00 19 mov %i1, %o2
4000f034: 96 10 00 1b mov %i3, %o3
4000f038: 90 10 00 18 mov %i0, %o0
4000f03c: 13 10 00 65 sethi %hi(0x40019400), %o1
4000f040: 7f ff ef 6b call 4000adec <_Thread_queue_Enqueue>
4000f044: 92 12 61 f8 or %o1, 0x1f8, %o1 ! 400195f8 <_Thread_queue_Operations_FIFO>
return (Status_Control) the_thread->Wait.return_code;
4000f048: f2 06 60 4c ld [ %i1 + 0x4c ], %i1
executing,
queue_context
);
return _Thread_Wait_get_status( executing );
}
}
4000f04c: 81 c7 e0 08 ret
4000f050: 91 e8 20 00 restore %g0, 0, %o0
4000f054: 90 10 00 18 mov %i0, %o0
4000f058: 13 10 00 3e sethi %hi(0x4000f800), %o1
return STATUS_BARRIER_AUTOMATICALLY_RELEASED;
4000f05c: b2 10 3f 00 mov -256, %i1
4000f060: 7f ff ff df call 4000efdc <_CORE_barrier_Do_flush>
4000f064: 92 12 62 bc or %o1, 0x2bc, %o1
4000f068: 30 bf ff f9 b,a 4000f04c <_CORE_barrier_Seize+0x50>
40009ed8 <_CORE_message_queue_Broadcast>:
const void *buffer,
size_t size,
uint32_t *count,
Thread_queue_Context *queue_context
)
{
40009ed8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Thread_Control *the_thread;
uint32_t number_broadcasted;
if ( size > the_message_queue->maximum_message_size ) {
40009edc: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
40009ee0: 80 a0 40 1a cmp %g1, %i2
<== NOT EXECUTED
40009ee4: 0a 80 00 2a bcs 40009f8c <_CORE_message_queue_Broadcast+0xb4>
<== NOT EXECUTED
40009ee8: 01 00 00 00 nop
*
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
40009eec: e0 06 20 14 ld [ %i0 + 0x14 ], %l0
40009ef0: 80 a4 20 00 cmp %l0, 0
40009ef4: 32 80 00 1f bne,a 40009f70 <_CORE_message_queue_Broadcast+0x98>
40009ef8: a0 10 20 00 clr %l0
40009efc: d0 06 00 00 ld [ %i0 ], %o0
const Thread_queue_Operations *operations
)
{
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
if ( heads != NULL ) {
40009f00: 80 a2 20 00 cmp %o0, 0
40009f04: 02 80 00 1b be 40009f70 <_CORE_message_queue_Broadcast+0x98>
40009f08: c2 06 20 0c ld [ %i0 + 0xc ], %g1
return ( *operations->first )( heads );
40009f0c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
40009f10: 9f c0 40 00 call %g1
40009f14: 01 00 00 00 nop
memcpy(destination, source, size);
40009f18: 92 10 00 19 mov %i1, %o1
40009f1c: ba 10 00 08 mov %o0, %i5
*/
the_thread = _Thread_queue_First_locked(
&the_message_queue->Wait_queue,
the_message_queue->operations
);
if ( the_thread == NULL ) {
40009f20: 80 a2 20 00 cmp %o0, 0
40009f24: 02 80 00 13 be 40009f70 <_CORE_message_queue_Broadcast+0x98> <== NEVER TAKEN
40009f28: 94 10 00 1a mov %i2, %o2
return NULL;
}
*(size_t *) the_thread->Wait.return_argument = size;
40009f2c: c2 02 20 40 ld [ %o0 + 0x40 ], %g1
40009f30: f4 20 40 00 st %i2, [ %g1 ]
0,
queue_context
)
)
) {
number_broadcasted += 1;
40009f34: a0 04 20 01 inc %l0
the_thread->Wait.count = (uint32_t) submit_type;
40009f38: c0 22 20 3c clr [ %o0 + 0x3c ]
memcpy(destination, source, size);
40009f3c: 40 00 21 6c call 400124ec <memcpy>
40009f40: d0 02 20 44 ld [ %o0 + 0x44 ], %o0
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
_Thread_queue_Extract_critical(
40009f44: d2 06 20 0c ld [ %i0 + 0xc ], %o1
40009f48: 96 10 00 1c mov %i4, %o3
40009f4c: 94 10 00 1d mov %i5, %o2
40009f50: 40 00 11 b9 call 4000e634 <_Thread_queue_Extract_critical>
40009f54: 90 10 00 18 mov %i0, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40009f58: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
40009f5c: c2 27 00 00 st %g1, [ %i4 ]
if ( the_message_queue->number_of_pending_messages != 0 ) {
40009f60: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40009f64: 80 a0 60 00 cmp %g1, 0
40009f68: 22 bf ff e6 be,a 40009f00 <_CORE_message_queue_Broadcast+0x28> <== ALWAYS TAKEN
40009f6c: d0 06 00 00 ld [ %i0 ], %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40009f70: c2 07 00 00 ld [ %i4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009f74: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009f78: 01 00 00 00 nop
}
_CORE_message_queue_Release( the_message_queue, queue_context );
*count = number_broadcasted;
return STATUS_SUCCESSFUL;
40009f7c: b0 10 20 00 clr %i0 ! 0 <PROM_START>
*count = number_broadcasted;
40009f80: e0 26 c0 00 st %l0, [ %i3 ]
}
40009f84: 81 c7 e0 08 ret
40009f88: 93 e8 20 00 restore %g0, 0, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40009f8c: c2 07 00 00 ld [ %i4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009f90: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009f94: 01 00 00 00 nop
return STATUS_MESSAGE_INVALID_SIZE;
40009f98: 33 00 00 1e sethi %hi(0x7800), %i1
40009f9c: b2 16 62 08 or %i1, 0x208, %i1 ! 7a08 <_Configuration_Interrupt_stack_size+0x6a08>
40009fa0: 81 c7 e0 08 ret
40009fa4: 91 e8 20 00 restore %g0, 0, %o0
40009fdc <_CORE_message_queue_Flush>:
uint32_t _CORE_message_queue_Flush(
CORE_message_queue_Control *the_message_queue,
Thread_queue_Context *queue_context
)
{
40009fdc: 82 10 00 08 mov %o0, %g1
<== NOT EXECUTED
* fixed execution time that only deals with pending messages.
*/
_CORE_message_queue_Acquire_critical( the_message_queue, queue_context );
count = the_message_queue->number_of_pending_messages;
40009fe0: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
<== NOT EXECUTED
if ( count != 0 ) {
40009fe4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40009fe8: 02 80 00 0f be 4000a024 <_CORE_message_queue_Flush+0x48>
<== NOT EXECUTED
40009fec: 96 00 60 30 add %g1, 0x30, %o3
return _Chain_Immutable_head( the_chain )->next;
40009ff0: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
the_message_queue->number_of_pending_messages = 0;
inactive_head = _Chain_Head( &the_message_queue->Inactive_messages );
inactive_first = inactive_head->next;
40009ff4: c6 00 60 30 ld [ %g1 + 0x30 ], %g3
return _Chain_Immutable_tail( the_chain )->previous;
40009ff8: c8 00 60 24 ld [ %g1 + 0x24 ], %g4
the_message_queue->number_of_pending_messages = 0;
40009ffc: c0 20 60 14 clr [ %g1 + 0x14 ]
message_queue_first = _Chain_First( &the_message_queue->Pending_messages );
message_queue_last = _Chain_Last( &the_message_queue->Pending_messages );
inactive_head->next = message_queue_first;
4000a000: c4 20 60 30 st %g2, [ %g1 + 0x30 ]
<== NOT EXECUTED
return &the_chain->Tail.Node;
4000a004: 9a 00 60 1c add %g1, 0x1c, %o5
<== NOT EXECUTED
message_queue_last->next = inactive_first;
4000a008: c6 21 00 00 st %g3, [ %g4 ]
<== NOT EXECUTED
4000a00c: 98 00 60 20 add %g1, 0x20, %o4
<== NOT EXECUTED
inactive_first->previous = message_queue_last;
4000a010: c8 20 e0 04 st %g4, [ %g3 + 4 ]
<== NOT EXECUTED
message_queue_first->previous = inactive_head;
4000a014: d6 20 a0 04 st %o3, [ %g2 + 4 ]
<== NOT EXECUTED
head->next = tail;
4000a018: d8 20 60 1c st %o4, [ %g1 + 0x1c ]
<== NOT EXECUTED
head->previous = NULL;
4000a01c: c0 20 60 20 clr [ %g1 + 0x20 ]
<== NOT EXECUTED
tail->previous = head;
4000a020: da 20 60 24 st %o5, [ %g1 + 0x24 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a024: c2 02 40 00 ld [ %o1 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a028: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000a02c: 01 00 00 00 nop
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
}
_CORE_message_queue_Release( the_message_queue, queue_context );
return count;
}
4000a030: 81 c3 e0 08 retl
4000a034: 01 00 00 00 nop
400108f8 <_CORE_message_queue_Initialize>:
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Disciplines discipline,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
400108f8: 9d e3 bf a0 save %sp, -96, %sp
size_t message_buffering_required = 0;
size_t aligned_message_size;
size_t align_mask;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
the_message_queue->number_of_pending_messages = 0;
400108fc: c0 26 20 14 clr [ %i0 + 0x14 ]
/*
* Align up the maximum message size to be an integral multiple of the
* pointer size.
*/
align_mask = sizeof(uintptr_t) - 1;
aligned_message_size = ( maximum_message_size + align_mask ) & ~align_mask;
40010900: 96 06 e0 03 add %i3, 3, %o3
the_message_queue->maximum_pending_messages = maximum_pending_messages;
40010904: f4 26 20 10 st %i2, [ %i0 + 0x10 ]
aligned_message_size = ( maximum_message_size + align_mask ) & ~align_mask;
40010908: 96 0a ff fc and %o3, -4, %o3
the_message_queue->maximum_message_size = maximum_message_size;
4001090c: f6 26 20 18 st %i3, [ %i0 + 0x18 ]
/*
* Check for an integer overflow. It can occur while aligning up the maximum
* message size.
*/
if (aligned_message_size < maximum_message_size)
40010910: 80 a6 c0 0b cmp %i3, %o3
40010914: 18 80 00 08 bgu 40010934 <_CORE_message_queue_Initialize+0x3c> <== NEVER TAKEN
40010918: c0 26 20 2c clr [ %i0 + 0x2c ]
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
if ( !size_t_mult32_with_overflow(
4001091c: ba 02 e0 14 add %o3, 0x14, %i5
long long x = (long long)a*b;
40010920: 86 56 80 1d umul %i2, %i5, %g3
40010924: 85 40 00 00 rd %y, %g2
if ( x > SIZE_MAX )
40010928: 80 a0 a0 00 cmp %g2, 0
4001092c: 04 80 00 06 ble 40010944 <_CORE_message_queue_Initialize+0x4c>
40010930: 01 00 00 00 nop
return false;
40010934: 82 10 20 00 clr %g1 ! 0 <PROM_START>
} else {
the_message_queue->operations = &_Thread_queue_Operations_FIFO;
}
return true;
}
40010938: b0 08 60 01 and %g1, 1, %i0
4001093c: 81 c7 e0 08 ret
40010940: 81 e8 00 00 restore
_Workspace_Allocate( message_buffering_required );
40010944: 40 00 1a 5a call 400172ac <_Workspace_Allocate>
40010948: 90 10 00 03 mov %g3, %o0
if (the_message_queue->message_buffers == 0)
4001094c: 80 a2 20 00 cmp %o0, 0
40010950: 02 bf ff f9 be 40010934 <_CORE_message_queue_Initialize+0x3c>
40010954: d0 26 20 28 st %o0, [ %i0 + 0x28 ]
_Chain_Initialize (
40010958: 92 10 00 08 mov %o0, %o1
4001095c: 96 10 00 1d mov %i5, %o3
40010960: 94 10 00 1a mov %i2, %o2
40010964: 7f ff ff 98 call 400107c4 <_Chain_Initialize>
40010968: 90 06 20 30 add %i0, 0x30, %o0
4001096c: 82 06 20 1c add %i0, 0x1c, %g1
40010970: 84 06 20 20 add %i0, 0x20, %g2
head->previous = NULL;
40010974: c0 26 20 20 clr [ %i0 + 0x20 ]
_Thread_queue_Object_initialize( &the_message_queue->Wait_queue );
40010978: 90 10 00 18 mov %i0, %o0
head->next = tail;
4001097c: c4 26 20 1c st %g2, [ %i0 + 0x1c ]
40010980: 40 00 13 2d call 40015634 <_Thread_queue_Object_initialize>
40010984: c2 26 20 24 st %g1, [ %i0 + 0x24 ]
if ( discipline == CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY ) {
40010988: 80 a6 60 01 cmp %i1, 1
4001098c: 02 80 00 07 be 400109a8 <_CORE_message_queue_Initialize+0xb0>
40010990: 05 10 00 6e sethi %hi(0x4001b800), %g2
the_message_queue->operations = &_Thread_queue_Operations_FIFO;
40010994: 03 10 00 6e sethi %hi(0x4001b800), %g1
40010998: 82 10 61 34 or %g1, 0x134, %g1 ! 4001b934 <_Thread_queue_Operations_FIFO>
4001099c: c2 26 20 0c st %g1, [ %i0 + 0xc ]
return true;
400109a0: 10 bf ff e6 b 40010938 <_CORE_message_queue_Initialize+0x40>
400109a4: 82 10 20 01 mov 1, %g1
400109a8: 82 10 20 01 mov 1, %g1
the_message_queue->operations = &_Thread_queue_Operations_priority;
400109ac: 84 10 a1 20 or %g2, 0x120, %g2
400109b0: 10 bf ff e2 b 40010938 <_CORE_message_queue_Initialize+0x40>
400109b4: c4 26 20 0c st %g2, [ %i0 + 0xc ]
400109b8 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Thread_queue_Context *queue_context
)
{
400109b8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
400109bc: e0 06 20 1c ld [ %i0 + 0x1c ], %l0
<== NOT EXECUTED
return &the_chain->Tail.Node;
400109c0: 82 06 20 20 add %i0, 0x20, %g1
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
400109c4: 80 a4 00 01 cmp %l0, %g1
<== NOT EXECUTED
400109c8: 02 80 00 33 be 40010a94 <_CORE_message_queue_Seize+0xdc>
<== NOT EXECUTED
400109cc: 86 06 20 1c add %i0, 0x1c, %g3
new_first = old_first->next;
400109d0: c4 04 00 00 ld [ %l0 ], %g2
head->next = new_first;
400109d4: c4 26 20 1c st %g2, [ %i0 + 0x1c ]
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
400109d8: 92 04 20 10 add %l0, 0x10, %o1
CORE_message_queue_Buffer_control *the_message;
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
400109dc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
new_first->previous = head;
400109e0: c6 20 a0 04 st %g3, [ %g2 + 4 ]
400109e4: 82 00 7f ff add %g1, -1, %g1
*size_p = the_message->Contents.size;
400109e8: c4 04 20 0c ld [ %l0 + 0xc ], %g2
the_message_queue->number_of_pending_messages -= 1;
400109ec: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
400109f0: 94 10 00 02 mov %g2, %o2
*size_p = the_message->Contents.size;
400109f4: c4 26 c0 00 st %g2, [ %i3 ]
400109f8: 90 10 00 1a mov %i2, %o0
executing->Wait.count =
400109fc: c2 04 20 08 ld [ %l0 + 8 ], %g1
40010a00: 40 00 21 7e call 40018ff8 <memcpy>
40010a04: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
40010a08: d0 06 00 00 ld [ %i0 ], %o0
if ( heads != NULL ) {
40010a0c: 80 a2 20 00 cmp %o0, 0
40010a10: 02 80 00 15 be 40010a64 <_CORE_message_queue_Seize+0xac>
40010a14: c2 06 20 0c ld [ %i0 + 0xc ], %g1
return ( *operations->first )( heads );
40010a18: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
40010a1c: 9f c0 40 00 call %g1
40010a20: 01 00 00 00 nop
*/
the_thread = _Thread_queue_First_locked(
&the_message_queue->Wait_queue,
the_message_queue->operations
);
if ( the_thread == NULL ) {
40010a24: b8 92 20 00 orcc %o0, 0, %i4
40010a28: 02 80 00 0f be 40010a64 <_CORE_message_queue_Seize+0xac> <== NEVER TAKEN
40010a2c: 92 10 00 10 mov %l0, %o1
/*
* There was a thread waiting to send a message. This code
* puts the messages in the message queue on behalf of the
* waiting task.
*/
_CORE_message_queue_Insert_message(
40010a30: d8 07 20 3c ld [ %i4 + 0x3c ], %o4
40010a34: d6 07 20 48 ld [ %i4 + 0x48 ], %o3
40010a38: d4 07 20 44 ld [ %i4 + 0x44 ], %o2
40010a3c: 40 00 1f d1 call 40018980 <_CORE_message_queue_Insert_message>
40010a40: 90 10 00 18 mov %i0, %o0
the_message,
the_thread->Wait.return_argument_second.immutable_object,
(size_t) the_thread->Wait.option,
(CORE_message_queue_Submit_types) the_thread->Wait.count
);
_Thread_queue_Extract_critical(
40010a44: d2 06 20 0c ld [ %i0 + 0xc ], %o1
40010a48: 90 10 00 18 mov %i0, %o0
40010a4c: 96 10 00 1d mov %i5, %o3
40010a50: 94 10 00 1c mov %i4, %o2
40010a54: 40 00 11 fe call 4001524c <_Thread_queue_Extract_critical>
40010a58: b2 10 20 00 clr %i1
the_message_queue->operations,
executing,
queue_context
);
return _Thread_Wait_get_status( executing );
}
40010a5c: 81 c7 e0 08 ret
40010a60: 91 e8 20 00 restore %g0, 0, %o0
old_last = tail->previous;
40010a64: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
return &the_chain->Tail.Node;
40010a68: 84 06 20 34 add %i0, 0x34, %g2
the_node->next = tail;
40010a6c: c4 24 00 00 st %g2, [ %l0 ]
tail->previous = the_node;
40010a70: e0 26 20 38 st %l0, [ %i0 + 0x38 ]
old_last->next = the_node;
40010a74: e0 20 40 00 st %l0, [ %g1 ]
the_node->previous = old_last;
40010a78: c2 24 20 04 st %g1, [ %l0 + 4 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40010a7c: c2 07 40 00 ld [ %i5 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40010a80: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40010a84: 01 00 00 00 nop
return STATUS_SUCCESSFUL;
40010a88: b2 10 20 00 clr %i1 ! 0 <PROM_START>
}
40010a8c: 81 c7 e0 08 ret
40010a90: 91 e8 20 00 restore %g0, 0, %o0
if ( !wait ) {
40010a94: 80 a7 20 00 cmp %i4, 0
40010a98: 32 80 00 08 bne,a 40010ab8 <_CORE_message_queue_Seize+0x100>
40010a9c: f4 26 60 44 st %i2, [ %i1 + 0x44 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40010aa0: c2 07 40 00 ld [ %i5 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40010aa4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40010aa8: 01 00 00 00 nop
return STATUS_UNSATISFIED;
40010aac: b2 10 2b 0d mov 0xb0d, %i1 ! b0d <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0x9bd>
}
40010ab0: 81 c7 e0 08 ret
40010ab4: 91 e8 20 00 restore %g0, 0, %o0
queue_context->thread_state = thread_state;
40010ab8: 82 10 20 10 mov 0x10, %g1
executing->Wait.return_argument = size_p;
40010abc: f6 26 60 40 st %i3, [ %i1 + 0x40 ]
_Thread_queue_Enqueue(
40010ac0: 94 10 00 19 mov %i1, %o2
40010ac4: c2 27 60 04 st %g1, [ %i5 + 4 ]
40010ac8: 90 10 00 18 mov %i0, %o0
40010acc: d2 06 20 0c ld [ %i0 + 0xc ], %o1
40010ad0: 96 10 00 1d mov %i5, %o3
40010ad4: 40 00 11 68 call 40015074 <_Thread_queue_Enqueue>
40010ad8: b0 10 20 00 clr %i0
return (Status_Control) the_thread->Wait.return_code;
40010adc: f2 06 60 4c ld [ %i1 + 0x4c ], %i1
}
40010ae0: 81 c7 e0 08 ret
40010ae4: 81 e8 00 00 restore
40010ae8 <_CORE_message_queue_Submit>:
size_t size,
CORE_message_queue_Submit_types submit_type,
bool wait,
Thread_queue_Context *queue_context
)
{
40010ae8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
40010aec: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
40010af0: 80 a0 40 1b cmp %g1, %i3
<== NOT EXECUTED
40010af4: 0a 80 00 1e bcs 40010b6c <_CORE_message_queue_Submit+0x84>
<== NOT EXECUTED
40010af8: 01 00 00 00 nop
*
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
40010afc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40010b00: 80 a0 60 00 cmp %g1, 0
40010b04: 32 80 00 23 bne,a 40010b90 <_CORE_message_queue_Submit+0xa8>
40010b08: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
40010b0c: d0 06 00 00 ld [ %i0 ], %o0
if ( heads != NULL ) {
40010b10: 80 a2 20 00 cmp %o0, 0
40010b14: 02 80 00 1e be 40010b8c <_CORE_message_queue_Submit+0xa4>
40010b18: c2 06 20 0c ld [ %i0 + 0xc ], %g1
return ( *operations->first )( heads );
40010b1c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
40010b20: 9f c0 40 00 call %g1
40010b24: 01 00 00 00 nop
*/
the_thread = _Thread_queue_First_locked(
&the_message_queue->Wait_queue,
the_message_queue->operations
);
if ( the_thread == NULL ) {
40010b28: a0 92 20 00 orcc %o0, 0, %l0
40010b2c: 02 80 00 18 be 40010b8c <_CORE_message_queue_Submit+0xa4> <== NEVER TAKEN
40010b30: 92 10 00 1a mov %i2, %o1
return NULL;
}
*(size_t *) the_thread->Wait.return_argument = size;
40010b34: c2 04 20 40 ld [ %l0 + 0x40 ], %g1
40010b38: f6 20 40 00 st %i3, [ %g1 ]
the_thread->Wait.count = (uint32_t) submit_type;
40010b3c: f8 24 20 3c st %i4, [ %l0 + 0x3c ]
memcpy(destination, source, size);
40010b40: 94 10 00 1b mov %i3, %o2
40010b44: 40 00 21 2d call 40018ff8 <memcpy>
40010b48: d0 04 20 44 ld [ %l0 + 0x44 ], %o0
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
_Thread_queue_Extract_critical(
40010b4c: d6 07 a0 5c ld [ %fp + 0x5c ], %o3
40010b50: d2 06 20 0c ld [ %i0 + 0xc ], %o1
40010b54: 94 10 00 10 mov %l0, %o2
40010b58: 90 10 00 18 mov %i0, %o0
40010b5c: 40 00 11 bc call 4001524c <_Thread_queue_Extract_critical>
40010b60: b2 10 20 00 clr %i1
executing,
queue_context
);
return _Thread_Wait_get_status( executing );
#endif
}
40010b64: 81 c7 e0 08 ret
40010b68: 91 e8 20 00 restore %g0, 0, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40010b6c: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
<== NOT EXECUTED
40010b70: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40010b74: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40010b78: 01 00 00 00 nop
return STATUS_MESSAGE_INVALID_SIZE;
40010b7c: 33 00 00 1e sethi %hi(0x7800), %i1
40010b80: b2 16 62 08 or %i1, 0x208, %i1 ! 7a08 <_Configuration_Interrupt_stack_size+0x6a08>
}
40010b84: 81 c7 e0 08 ret
40010b88: 91 e8 20 00 restore %g0, 0, %o0
return _Chain_Immutable_head( the_chain )->next;
40010b8c: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
return &the_chain->Tail.Node;
40010b90: 82 06 20 34 add %i0, 0x34, %g1
if ( !_Chain_Is_empty(the_chain))
40010b94: 80 a2 40 01 cmp %o1, %g1
40010b98: 02 80 00 14 be 40010be8 <_CORE_message_queue_Submit+0x100>
40010b9c: 84 06 20 30 add %i0, 0x30, %g2
new_first = old_first->next;
40010ba0: c2 02 40 00 ld [ %o1 ], %g1
head->next = new_first;
40010ba4: c2 26 20 30 st %g1, [ %i0 + 0x30 ]
_CORE_message_queue_Insert_message(
40010ba8: 98 10 00 1c mov %i4, %o4
new_first->previous = head;
40010bac: c4 20 60 04 st %g2, [ %g1 + 4 ]
40010bb0: 96 10 00 1b mov %i3, %o3
40010bb4: 94 10 00 1a mov %i2, %o2
40010bb8: 40 00 1f 72 call 40018980 <_CORE_message_queue_Insert_message>
40010bbc: 90 10 00 18 mov %i0, %o0
if (
40010bc0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40010bc4: 80 a0 60 01 cmp %g1, 1
40010bc8: 22 80 00 1c be,a 40010c38 <_CORE_message_queue_Submit+0x150>
40010bcc: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40010bd0: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
<== NOT EXECUTED
40010bd4: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40010bd8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40010bdc: 01 00 00 00 nop
return STATUS_SUCCESSFUL;
40010be0: 10 bf ff e1 b 40010b64 <_CORE_message_queue_Submit+0x7c>
40010be4: b2 10 20 00 clr %i1 ! 0 <PROM_START>
if ( !wait ) {
40010be8: 80 a7 60 00 cmp %i5, 0
40010bec: 02 80 00 0d be 40010c20 <_CORE_message_queue_Submit+0x138>
40010bf0: 01 00 00 00 nop
if ( _ISR_Is_in_progress() ) {
40010bf4: 40 00 05 93 call 40012240 <_ISR_Is_in_progress>
40010bf8: 01 00 00 00 nop
40010bfc: 80 a2 20 00 cmp %o0, 0
40010c00: 22 80 00 15 be,a 40010c54 <_CORE_message_queue_Submit+0x16c>
40010c04: f4 26 60 44 st %i2, [ %i1 + 0x44 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40010c08: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
<== NOT EXECUTED
40010c0c: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40010c10: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40010c14: 01 00 00 00 nop
return STATUS_MESSAGE_QUEUE_WAIT_IN_ISR;
40010c18: 10 bf ff d3 b 40010b64 <_CORE_message_queue_Submit+0x7c> 40010c1c: b2 10 2c 0d mov 0xc0d, %i1 ! c0d <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0xabd>
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40010c20: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
<== NOT EXECUTED
40010c24: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40010c28: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40010c2c: 01 00 00 00 nop
return STATUS_TOO_MANY;
40010c30: 10 bf ff cd b 40010b64 <_CORE_message_queue_Submit+0x7c> 40010c34: b2 10 2b 05 mov 0xb05, %i1 ! b05 <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0x9b5>
&& the_message_queue->notify_handler != NULL
40010c38: 80 a0 60 00 cmp %g1, 0
40010c3c: 02 bf ff e5 be 40010bd0 <_CORE_message_queue_Submit+0xe8>
40010c40: d2 07 a0 5c ld [ %fp + 0x5c ], %o1
( *the_message_queue->notify_handler )(
40010c44: 90 10 00 18 mov %i0, %o0
40010c48: 9f c0 40 00 call %g1
40010c4c: b2 10 20 00 clr %i1
40010c50: 30 bf ff c5 b,a 40010b64 <_CORE_message_queue_Submit+0x7c>
queue_context->thread_state = thread_state;
40010c54: 82 10 20 10 mov 0x10, %g1
executing->Wait.option = (uint32_t) size;
40010c58: f6 26 60 48 st %i3, [ %i1 + 0x48 ]
_Thread_queue_Enqueue(
40010c5c: 94 10 00 19 mov %i1, %o2
executing->Wait.count = submit_type;
40010c60: f8 26 60 3c st %i4, [ %i1 + 0x3c ]
_Thread_queue_Enqueue(
40010c64: 90 10 00 18 mov %i0, %o0
40010c68: d6 07 a0 5c ld [ %fp + 0x5c ], %o3
40010c6c: c2 22 e0 04 st %g1, [ %o3 + 4 ]
40010c70: 40 00 11 01 call 40015074 <_Thread_queue_Enqueue>
40010c74: d2 06 20 0c ld [ %i0 + 0xc ], %o1
return _Thread_Wait_get_status( executing );
40010c78: 10 bf ff bb b 40010b64 <_CORE_message_queue_Submit+0x7c>
40010c7c: f2 06 60 4c ld [ %i1 + 0x4c ], %i1
4000cb84 <_CORE_mutex_Seize_slow>:
const Thread_queue_Operations *operations,
Thread_Control *executing,
bool wait,
Thread_queue_Context *queue_context
)
{
4000cb84: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( wait ) {
4000cb88: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
4000cb8c: 02 80 00 0f be 4000cbc8 <_CORE_mutex_Seize_slow+0x44>
<== NOT EXECUTED
4000cb90: 82 10 20 01 mov 1, %g1
4000cb94: c2 27 20 04 st %g1, [ %i4 + 4 ]
queue_context->deadlock_callout = deadlock_callout;
4000cb98: 03 10 00 43 sethi %hi(0x40010c00), %g1
4000cb9c: 82 10 62 b8 or %g1, 0x2b8, %g1 ! 40010eb8 <_Thread_queue_Deadlock_status>
4000cba0: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
);
_Thread_queue_Context_set_deadlock_callout(
queue_context,
_Thread_queue_Deadlock_status
);
_Thread_queue_Enqueue(
4000cba4: 92 10 00 19 mov %i1, %o1
4000cba8: 90 10 00 18 mov %i0, %o0
4000cbac: 96 10 00 1c mov %i4, %o3
4000cbb0: 94 10 00 1a mov %i2, %o2
4000cbb4: 40 00 10 c9 call 40010ed8 <_Thread_queue_Enqueue>
4000cbb8: b0 10 20 00 clr %i0
return (Status_Control) the_thread->Wait.return_code;
4000cbbc: f2 06 a0 4c ld [ %i2 + 0x4c ], %i1
return _Thread_Wait_get_status( executing );
} else {
_CORE_mutex_Release( the_mutex, queue_context );
return STATUS_UNAVAILABLE;
}
}
4000cbc0: 81 c7 e0 08 ret
4000cbc4: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000cbc8: c2 07 00 00 ld [ %i4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000cbcc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000cbd0: 01 00 00 00 nop
return STATUS_UNAVAILABLE;
4000cbd4: 33 00 00 04 sethi %hi(0x1000), %i1
4000cbd8: b2 16 60 0d or %i1, 0xd, %i1 ! 100d <_Configuration_Interrupt_stack_size+0xd>
}
4000cbdc: 81 c7 e0 08 ret
4000cbe0: 91 e8 20 00 restore %g0, 0, %o0
4000cbe4 <_CORE_semaphore_Initialize>:
void _CORE_semaphore_Initialize(
CORE_semaphore_Control *the_semaphore,
uint32_t initial_value
)
{
the_semaphore->count = initial_value;
4000cbe4: d2 22 20 0c st %o1, [ %o0 + 0xc ]
<== NOT EXECUTED
_Thread_queue_Object_initialize( &the_semaphore->Wait_queue );
4000cbe8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000cbec: 40 00 12 2b call 40011498 <_Thread_queue_Object_initialize>
<== NOT EXECUTED
4000cbf0: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40009bb0 <_Chain_Node_count_unprotected>:
return _Chain_Immutable_head( the_chain )->next;
40009bb0: c2 02 00 00 ld [ %o0 ], %g1
return &the_chain->Tail.Node;
40009bb4: 84 02 20 04 add %o0, 4, %g2
{
size_t count = 0;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
40009bb8: 80 a0 80 01 cmp %g2, %g1
40009bbc: 02 80 00 06 be 40009bd4 <_Chain_Node_count_unprotected+0x24> <== NEVER TAKEN
40009bc0: 90 10 20 00 clr %o0
40009bc4: c2 00 40 00 ld [ %g1 ], %g1
40009bc8: 80 a0 80 01 cmp %g2, %g1
40009bcc: 12 bf ff fe bne 40009bc4 <_Chain_Node_count_unprotected+0x14>
40009bd0: 90 02 20 01 inc %o0
40009bd4: 81 c3 e0 08 retl
40009bd8: 01 00 00 00 nop
40014154 <_Condition_Broadcast>:
_Condition_Wake( _condition, 1 );
}
void _Condition_Broadcast( struct _Condition_Control *_condition )
{
_Condition_Wake( _condition, INT_MAX );
40014154: 13 1f ff ff sethi %hi(0x7ffffc00), %o1
<== NOT EXECUTED
40014158: 92 12 63 ff or %o1, 0x3ff, %o1 ! 7fffffff <RAM_END+0x3fbfffff>
<== NOT EXECUTED
4001415c: 82 13 c0 00 mov %o7, %g1
40014160: 7f ff ff d5 call 400140b4 <_Condition_Wake>
40014164: 9e 10 40 00 mov %g1, %o7
4001005c <_Condition_Signal>:
void _Condition_Signal( struct _Condition_Control *_condition )
{
_Condition_Wake( _condition, 1 );
4001005c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
40010060: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40010064: 7f ff ff b9 call 4000ff48 <_Condition_Wake>
<== NOT EXECUTED
40010068: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40014108 <_Condition_Wait>:
{
40014108: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
queue_context->enqueue_callout = enqueue_callout;
4001410c: 03 10 00 50 sethi %hi(0x40014000), %g1
<== NOT EXECUTED
context->mutex = _mutex;
40014110: f2 27 bf fc st %i1, [ %fp + -4 ]
<== NOT EXECUTED
40014114: 82 10 60 a4 or %g1, 0xa4, %g1
<== NOT EXECUTED
40014118: c2 27 bf e0 st %g1, [ %fp + -32 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001411c: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &context->Base.Lock_context.Lock_context );
40014120: c2 27 bf d8 st %g1, [ %fp + -40 ]
queue_context->thread_state = thread_state;
40014124: 82 10 20 20 mov 0x20, %g1
_Thread_queue_Enqueue(
40014128: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
4001412c: 90 06 20 08 add %i0, 8, %o0
40014130: 96 07 bf d8 add %fp, -40, %o3
40014134: c2 27 bf dc st %g1, [ %fp + -36 ]
40014138: 13 10 00 8d sethi %hi(0x40023400), %o1
4001413c: 7f ff e5 bd call 4000d830 <_Thread_queue_Enqueue>
40014140: 92 12 61 b8 or %o1, 0x1b8, %o1 ! 400235b8 <_Thread_queue_Operations_FIFO>
_Mutex_Acquire( _mutex );
40014144: 7f ff de 0a call 4000b96c <_Mutex_Acquire>
40014148: 90 10 00 19 mov %i1, %o0
}
4001414c: 81 c7 e0 08 ret
40014150: 81 e8 00 00 restore
400578a4 <_Condition_Wait_recursive>:
{
400578a4: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
_Thread_queue_Context_set_enqueue_callout(
Thread_queue_Context *queue_context,
Thread_queue_Enqueue_callout enqueue_callout
)
{
queue_context->enqueue_callout = enqueue_callout;
400578a8: 03 10 01 5e sethi %hi(0x40057800), %g1
<== NOT EXECUTED
nest_level = _mutex->_nest_level;
400578ac: fa 06 60 14 ld [ %i1 + 0x14 ], %i5
<== NOT EXECUTED
400578b0: 82 10 60 40 or %g1, 0x40, %g1
<== NOT EXECUTED
_mutex->_nest_level = 0;
400578b4: c0 26 60 14 clr [ %i1 + 0x14 ]
<== NOT EXECUTED
400578b8: c2 27 bf e0 st %g1, [ %fp + -32 ]
<== NOT EXECUTED
context->mutex = _mutex;
400578bc: f2 27 bf fc st %i1, [ %fp + -4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400578c0: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &context->Base.Lock_context.Lock_context );
400578c4: c2 27 bf d8 st %g1, [ %fp + -40 ]
queue_context->thread_state = thread_state;
400578c8: 82 10 20 20 mov 0x20, %g1
_Thread_queue_Enqueue(
400578cc: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
400578d0: 96 07 bf d8 add %fp, -40, %o3
400578d4: 90 06 20 08 add %i0, 8, %o0
400578d8: c2 27 bf dc st %g1, [ %fp + -36 ]
400578dc: 13 10 02 46 sethi %hi(0x40091800), %o1
400578e0: 40 00 0d e5 call 4005b074 <_Thread_queue_Enqueue>
400578e4: 92 12 63 b8 or %o1, 0x3b8, %o1 ! 40091bb8 <_Thread_queue_Operations_FIFO>
_Mutex_recursive_Acquire( _mutex );
400578e8: 40 00 06 14 call 40059138 <_Mutex_recursive_Acquire>
400578ec: 90 10 00 19 mov %i1, %o0
_mutex->_nest_level = nest_level;
400578f0: fa 26 60 14 st %i5, [ %i1 + 0x14 ]
}
400578f4: 81 c7 e0 08 ret
400578f8: 81 e8 00 00 restore
4000fff4 <_Condition_Wait_recursive_timed>:
{
4000fff4: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
queue_context->enqueue_callout = enqueue_callout;
4000fff8: 03 10 00 3f sethi %hi(0x4000fc00), %g1
<== NOT EXECUTED
nest_level = _mutex->_nest_level;
4000fffc: f8 06 60 14 ld [ %i1 + 0x14 ], %i4
<== NOT EXECUTED
40010000: 82 10 63 24 or %g1, 0x324, %g1
<== NOT EXECUTED
queue_context->Timeout.arg = arg;
40010004: f4 27 bf e4 st %i2, [ %fp + -28 ]
<== NOT EXECUTED
queue_context->enqueue_callout = enqueue_callout;
40010008: c2 27 bf e0 st %g1, [ %fp + -32 ]
<== NOT EXECUTED
_mutex->_nest_level = 0;
4001000c: c0 26 60 14 clr [ %i1 + 0x14 ]
<== NOT EXECUTED
context->mutex = _mutex;
40010010: f2 27 bf fc st %i1, [ %fp + -4 ]
<== NOT EXECUTED
40010014: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &context->Base.Lock_context.Lock_context );
40010018: c2 27 bf d8 st %g1, [ %fp + -40 ]
queue_context->thread_state = thread_state;
4001001c: 82 10 20 20 mov 0x20, %g1
executing = _Thread_Executing;
40010020: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
_Thread_queue_Enqueue(
40010024: 96 07 bf d8 add %fp, -40, %o3
40010028: 94 10 00 1d mov %i5, %o2
4001002c: 90 06 20 08 add %i0, 8, %o0
40010030: c2 27 bf dc st %g1, [ %fp + -36 ]
40010034: 13 10 00 4a sethi %hi(0x40012800), %o1
40010038: 7f ff ee 7a call 4000ba20 <_Thread_queue_Enqueue>
4001003c: 92 12 63 14 or %o1, 0x314, %o1 ! 40012b14 <_Thread_queue_Operations_FIFO>
eno = STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) );
40010040: f0 07 60 4c ld [ %i5 + 0x4c ], %i0
_Mutex_recursive_Acquire( _mutex );
40010044: 90 10 00 19 mov %i1, %o0
40010048: 7f ff e5 c3 call 40009754 <_Mutex_recursive_Acquire>
4001004c: b1 3e 20 08 sra %i0, 8, %i0
_mutex->_nest_level = nest_level;
40010050: f8 26 60 14 st %i4, [ %i1 + 0x14 ]
}
40010054: 81 c7 e0 08 ret
40010058: 81 e8 00 00 restore
4000837c <_Condition_Wait_timed>:
{
4000837c: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
queue_context->enqueue_callout = enqueue_callout;
40008380: 03 10 00 20 sethi %hi(0x40008000), %g1
<== NOT EXECUTED
queue_context->Timeout.arg = arg;
40008384: f4 27 bf e4 st %i2, [ %fp + -28 ]
<== NOT EXECUTED
queue_context->enqueue_callout = enqueue_callout;
40008388: 82 10 62 b8 or %g1, 0x2b8, %g1
<== NOT EXECUTED
context->mutex = _mutex;
4000838c: f2 27 bf fc st %i1, [ %fp + -4 ]
<== NOT EXECUTED
40008390: c2 27 bf e0 st %g1, [ %fp + -32 ]
<== NOT EXECUTED
40008394: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &context->Base.Lock_context.Lock_context );
40008398: c2 27 bf d8 st %g1, [ %fp + -40 ]
queue_context->thread_state = thread_state;
4000839c: 82 10 20 20 mov 0x20, %g1
executing = _Thread_Executing;
400083a0: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
_Thread_queue_Enqueue(
400083a4: 90 06 20 08 add %i0, 8, %o0
400083a8: 96 07 bf d8 add %fp, -40, %o3
400083ac: 94 10 00 1d mov %i5, %o2
400083b0: c2 27 bf dc st %g1, [ %fp + -36 ]
400083b4: 13 10 00 49 sethi %hi(0x40012400), %o1
400083b8: 40 00 10 c4 call 4000c6c8 <_Thread_queue_Enqueue>
400083bc: 92 12 63 10 or %o1, 0x310, %o1 ! 40012710 <_Thread_queue_Operations_FIFO>
eno = STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) );
400083c0: f0 07 60 4c ld [ %i5 + 0x4c ], %i0
400083c4: b1 3e 20 08 sra %i0, 8, %i0
_Mutex_Acquire( _mutex );
400083c8: 40 00 07 89 call 4000a1ec <_Mutex_Acquire>
400083cc: 90 10 00 19 mov %i1, %o0
}
400083d0: 81 c7 e0 08 ret
400083d4: 81 e8 00 00 restore
40007168 <_Freechain_Get>:
Freechain_Control *freechain,
Freechain_Allocator allocator,
size_t number_nodes_to_extend,
size_t node_size
)
{
40007168: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
4000716c: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40007170: f0 06 00 00 ld [ %i0 ], %i0
return &the_chain->Tail.Node;
40007174: b8 07 60 04 add %i5, 4, %i4
_Assert( node_size >= sizeof( Chain_Node ) );
if ( _Chain_Is_empty( &freechain->Free ) && number_nodes_to_extend > 0 ) {
40007178: 80 a6 00 1c cmp %i0, %i4
4000717c: 12 80 00 04 bne 4000718c <_Freechain_Get+0x24>
<== ALWAYS TAKEN
40007180: 80 a6 a0 00 cmp %i2, 0
40007184: 12 80 00 0a bne 400071ac <_Freechain_Get+0x44>
40007188: 01 00 00 00 nop
if ( !_Chain_Is_empty(the_chain))
4000718c: 80 a7 00 18 cmp %i4, %i0
40007190: 02 80 00 12 be 400071d8 <_Freechain_Get+0x70>
40007194: 01 00 00 00 nop
new_first = old_first->next;
40007198: c2 06 00 00 ld [ %i0 ], %g1
head->next = new_first;
4000719c: c2 27 40 00 st %g1, [ %i5 ]
new_first->previous = head;
400071a0: fa 20 60 04 st %i5, [ %g1 + 4 ]
400071a4: 81 c7 e0 08 ret
400071a8: 81 e8 00 00 restore
void *starting_address;
starting_address = ( *allocator )( number_nodes_to_extend * node_size );
400071ac: 9f c6 40 00 call %i1
400071b0: 90 5e 80 1b smul %i2, %i3, %o0
number_nodes_to_extend *= ( starting_address != NULL );
400071b4: 80 a0 00 08 cmp %g0, %o0
starting_address = ( *allocator )( number_nodes_to_extend * node_size );
400071b8: 92 10 00 08 mov %o0, %o1
number_nodes_to_extend *= ( starting_address != NULL );
400071bc: 94 40 20 00 addx %g0, 0, %o2
_Chain_Initialize(
400071c0: 96 10 00 1b mov %i3, %o3
400071c4: 94 5a 80 1a smul %o2, %i2, %o2
400071c8: 7f ff ff c7 call 400070e4 <_Chain_Initialize>
400071cc: 90 10 00 1d mov %i5, %o0
400071d0: 10 bf ff ef b 4000718c <_Freechain_Get+0x24>
400071d4: f0 07 40 00 ld [ %i5 ], %i0
node_size
);
}
return _Chain_Get_unprotected( &freechain->Free );
}
400071d8: 81 c7 e0 08 ret
400071dc: 91 e8 20 00 restore %g0, 0, %o0
400071e0 <_Freechain_Put>:
void _Freechain_Put( Freechain_Control *freechain, void *node )
{
if ( node != NULL ) {
400071e0: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
400071e4: 02 80 00 07 be 40007200 <_Freechain_Put+0x20>
<== NOT EXECUTED
400071e8: 01 00 00 00 nop
the_node->previous = after_node;
400071ec: d0 22 60 04 st %o0, [ %o1 + 4 ]
before_node = after_node->next;
400071f0: c2 02 00 00 ld [ %o0 ], %g1
after_node->next = the_node;
400071f4: d2 22 00 00 st %o1, [ %o0 ]
the_node->next = before_node;
400071f8: c2 22 40 00 st %g1, [ %o1 ]
before_node->previous = the_node;
400071fc: d2 20 60 04 st %o1, [ %g1 + 4 ]
_Chain_Initialize_node( node );
_Chain_Prepend_unprotected( &freechain->Free, node );
}
}
40007200: 81 c3 e0 08 retl
40007204: 01 00 00 00 nop
400085b0 <_Futex_Wait>:
{
400085b0: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
400085b4: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
400085b8: 86 10 00 01 mov %g1, %g3
if ( *uaddr == val ) {
400085bc: c4 06 40 00 ld [ %i1 ], %g2
400085c0: 80 a0 80 1a cmp %g2, %i2
400085c4: 22 80 00 06 be,a 400085dc <_Futex_Wait+0x2c>
400085c8: 82 10 20 40 mov 0x40, %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400085cc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400085d0: 01 00 00 00 nop
}
400085d4: 81 c7 e0 08 ret
400085d8: 91 e8 20 0b restore %g0, 0xb, %o0
executing = _Thread_Executing;
400085dc: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
400085e0: c2 27 bf e0 st %g1, [ %fp + -32 ]
RTEMS_INLINE_ROUTINE void
_Thread_queue_Context_set_enqueue_do_nothing_extra(
Thread_queue_Context *queue_context
)
{
queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;
400085e4: 03 10 00 31 sethi %hi(0x4000c400), %g1
400085e8: 82 10 62 b0 or %g1, 0x2b0, %g1 ! 4000c6b0 <_Thread_queue_Enqueue_do_nothing_extra>
_Thread_queue_Enqueue(
400085ec: 90 06 20 08 add %i0, 8, %o0
)
{
#if defined( RTEMS_SMP )
context->Lock_context.isr_level = level;
#else
context->isr_level = level;
400085f0: c6 27 bf dc st %g3, [ %fp + -36 ]
400085f4: 96 07 bf dc add %fp, -36, %o3
400085f8: c2 27 bf e4 st %g1, [ %fp + -28 ]
400085fc: 13 10 00 49 sethi %hi(0x40012400), %o1
eno = 0;
40008600: b0 10 20 00 clr %i0
_Thread_queue_Enqueue(
40008604: 40 00 10 31 call 4000c6c8 <_Thread_queue_Enqueue>
40008608: 92 12 63 10 or %o1, 0x310, %o1
4000860c: 81 c7 e0 08 ret
40008610: 81 e8 00 00 restore
40008614 <_Futex_Wake>:
int _Futex_Wake( struct _Futex_Control *_futex, int count )
{
40008614: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008618: 91 d0 20 09 ta 9
<== NOT EXECUTED
/*
* For some synchronization objects like barriers the _Futex_Wake() must be
* called in the fast path. Normally there are no threads on the queue, so
* check this condition early.
*/
if ( __predict_true( _Thread_queue_Is_empty( &futex->Queue.Queue ) ) ) {
4000861c: c4 06 20 08 ld [ %i0 + 8 ], %g2
40008620: 80 a0 a0 00 cmp %g2, 0
40008624: 32 80 00 06 bne,a 4000863c <_Futex_Wake+0x28>
40008628: f2 27 bf fc st %i1, [ %fp + -4 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000862c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008630: 01 00 00 00 nop
_Futex_Queue_release( futex, level, &context.Base );
return 0;
40008634: 81 c7 e0 08 ret
40008638: 91 e8 20 00 restore %g0, 0, %o0
}
context.count = count;
_Thread_queue_Context_set_ISR_level( &context.Base, level );
return (int) _Thread_queue_Flush_critical(
4000863c: 96 07 bf d8 add %fp, -40, %o3
40008640: c2 27 bf d8 st %g1, [ %fp + -40 ]
40008644: 90 06 20 08 add %i0, 8, %o0
40008648: 15 10 00 21 sethi %hi(0x40008400), %o2
4000864c: 13 10 00 49 sethi %hi(0x40012400), %o1
40008650: 94 12 a1 90 or %o2, 0x190, %o2
40008654: 40 00 11 1e call 4000cacc <_Thread_queue_Flush_critical>
40008658: 92 12 63 10 or %o1, 0x310, %o1
&futex->Queue.Queue,
FUTEX_TQ_OPERATIONS,
_Futex_Flush_filter,
&context.Base
);
}
4000865c: 81 c7 e0 08 ret
40008660: 91 e8 00 08 restore %g0, %o0, %o0
40007208 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
40007208: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
4000720c: 88 06 60 04 add %i1, 4, %g4
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
40007210: 80 a6 7f fc cmp %i1, -4
40007214: 1a 80 00 8a bcc 4000743c <_Heap_Allocate_aligned_with_boundary+0x234> <== NEVER TAKEN
40007218: da 06 20 10 ld [ %i0 + 0x10 ], %o5
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
4000721c: 80 a6 e0 00 cmp %i3, 0
40007220: 12 80 00 81 bne 40007424 <_Heap_Allocate_aligned_with_boundary+0x21c>
40007224: 80 a6 40 1b cmp %i1, %i3
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
40007228: d2 06 20 08 ld [ %i0 + 8 ], %o1
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
4000722c: 80 a6 00 09 cmp %i0, %o1
40007230: 02 80 00 78 be 40007410 <_Heap_Allocate_aligned_with_boundary+0x208>
40007234: ba 10 20 00 clr %i5
uintptr_t alloc_begin = alloc_end - alloc_size;
40007238: 9e 10 20 04 mov 4, %o7
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
4000723c: 96 03 60 07 add %o5, 7, %o3
uintptr_t alloc_begin = alloc_end - alloc_size;
40007240: 9e 23 c0 19 sub %o7, %i1, %o7
uintptr_t const free_size = alloc_block_begin - block_begin;
40007244: 10 80 00 09 b 40007268 <_Heap_Allocate_aligned_with_boundary+0x60>
40007248: 94 10 3f f8 mov -8, %o2
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
4000724c: 80 a7 20 00 cmp %i4, 0
40007250: 32 80 00 5b bne,a 400073bc <_Heap_Allocate_aligned_with_boundary+0x1b4> <== ALWAYS TAKEN
40007254: 96 10 00 19 mov %i1, %o3
break;
}
block = block->next;
40007258: d2 02 60 08 ld [ %o1 + 8 ], %o1
while ( block != free_list_tail ) {
4000725c: 80 a6 00 09 cmp %i0, %o1
40007260: 22 80 00 6d be,a 40007414 <_Heap_Allocate_aligned_with_boundary+0x20c>
40007264: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
if ( block->size_and_flag > block_size_floor ) {
40007268: c2 02 60 04 ld [ %o1 + 4 ], %g1
4000726c: 80 a0 40 04 cmp %g1, %g4
40007270: 08 bf ff fa bleu 40007258 <_Heap_Allocate_aligned_with_boundary+0x50>
40007274: ba 07 60 01 inc %i5
if ( alignment == 0 ) {
40007278: 80 a6 a0 00 cmp %i2, 0
4000727c: 02 bf ff f4 be 4000724c <_Heap_Allocate_aligned_with_boundary+0x44>
40007280: b8 02 60 08 add %o1, 8, %i4
40007284: d8 06 20 14 ld [ %i0 + 0x14 ], %o4
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40007288: 82 08 7f fe and %g1, -2, %g1
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
4000728c: 86 22 c0 0c sub %o3, %o4, %g3
uintptr_t const block_end = block_begin + block_size;
40007290: 82 00 40 09 add %g1, %o1, %g1
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
40007294: 86 00 c0 01 add %g3, %g1, %g3
uintptr_t alloc_begin = alloc_end - alloc_size;
40007298: 82 03 c0 01 add %o7, %g1, %g1
return value - (value % alignment);
4000729c: 81 80 20 00 wr %g0, %y
400072a0: 01 00 00 00 nop
400072a4: 01 00 00 00 nop
400072a8: 01 00 00 00 nop
400072ac: 84 70 40 1a udiv %g1, %i2, %g2
400072b0: 84 58 80 1a smul %g2, %i2, %g2
if ( alloc_begin > alloc_begin_ceiling ) {
400072b4: 80 a0 c0 02 cmp %g3, %g2
400072b8: 1a 80 00 08 bcc 400072d8 <_Heap_Allocate_aligned_with_boundary+0xd0>
400072bc: 80 a6 e0 00 cmp %i3, 0
400072c0: 81 80 20 00 wr %g0, %y
400072c4: 01 00 00 00 nop
400072c8: 01 00 00 00 nop
400072cc: 01 00 00 00 nop
400072d0: 84 70 c0 1a udiv %g3, %i2, %g2
400072d4: 84 58 80 1a smul %g2, %i2, %g2
if ( boundary != 0 ) {
400072d8: 02 80 00 26 be 40007370 <_Heap_Allocate_aligned_with_boundary+0x168>
400072dc: 80 a7 00 02 cmp %i4, %g2
alloc_end = alloc_begin + alloc_size;
400072e0: 86 06 40 02 add %i1, %g2, %g3
400072e4: 81 80 20 00 wr %g0, %y
400072e8: 01 00 00 00 nop
400072ec: 01 00 00 00 nop
400072f0: 01 00 00 00 nop
400072f4: 82 70 c0 1b udiv %g3, %i3, %g1
400072f8: 82 58 40 1b smul %g1, %i3, %g1
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
400072fc: 80 a0 40 03 cmp %g1, %g3
40007300: 1a 80 00 1b bcc 4000736c <_Heap_Allocate_aligned_with_boundary+0x164>
40007304: 90 06 40 1c add %i1, %i4, %o0
40007308: 80 a0 80 01 cmp %g2, %g1
4000730c: 2a 80 00 06 bcs,a 40007324 <_Heap_Allocate_aligned_with_boundary+0x11c>
40007310: 80 a2 00 01 cmp %o0, %g1
if ( alloc_begin >= alloc_begin_floor ) {
40007314: 10 80 00 17 b 40007370 <_Heap_Allocate_aligned_with_boundary+0x168>
40007318: 80 a7 00 02 cmp %i4, %g2
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
4000731c: 1a 80 00 14 bcc 4000736c <_Heap_Allocate_aligned_with_boundary+0x164>
40007320: 80 a2 00 01 cmp %o0, %g1
if ( boundary_line < boundary_floor ) {
40007324: 18 bf ff cd bgu 40007258 <_Heap_Allocate_aligned_with_boundary+0x50>
40007328: 82 20 40 19 sub %g1, %i1, %g1
4000732c: 81 80 20 00 wr %g0, %y
40007330: 01 00 00 00 nop
40007334: 01 00 00 00 nop
40007338: 01 00 00 00 nop
4000733c: 84 70 40 1a udiv %g1, %i2, %g2
40007340: 84 58 80 1a smul %g2, %i2, %g2
alloc_end = alloc_begin + alloc_size;
40007344: 86 06 40 02 add %i1, %g2, %g3
40007348: 81 80 20 00 wr %g0, %y
4000734c: 01 00 00 00 nop
40007350: 01 00 00 00 nop
40007354: 01 00 00 00 nop
40007358: 82 70 c0 1b udiv %g3, %i3, %g1
4000735c: 82 58 40 1b smul %g1, %i3, %g1
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
40007360: 80 a0 80 01 cmp %g2, %g1
40007364: 0a bf ff ee bcs 4000731c <_Heap_Allocate_aligned_with_boundary+0x114>
40007368: 80 a0 40 03 cmp %g1, %g3
if ( alloc_begin >= alloc_begin_floor ) {
4000736c: 80 a7 00 02 cmp %i4, %g2
40007370: 18 bf ff ba bgu 40007258 <_Heap_Allocate_aligned_with_boundary+0x50>
40007374: 82 22 80 09 sub %o2, %o1, %g1
40007378: 81 80 20 00 wr %g0, %y
4000737c: 01 00 00 00 nop
40007380: 01 00 00 00 nop
40007384: 01 00 00 00 nop
40007388: 86 70 80 0d udiv %g2, %o5, %g3
4000738c: 86 58 c0 0d smul %g3, %o5, %g3
uintptr_t const free_size = alloc_block_begin - block_begin;
40007390: 82 00 40 03 add %g1, %g3, %g1
if ( free_size >= min_block_size || free_size == 0 ) {
40007394: 80 a0 40 0c cmp %g1, %o4
40007398: 1a 80 00 04 bcc 400073a8 <_Heap_Allocate_aligned_with_boundary+0x1a0>
4000739c: 80 a0 60 00 cmp %g1, 0
400073a0: 32 bf ff af bne,a 4000725c <_Heap_Allocate_aligned_with_boundary+0x54>
400073a4: d2 02 60 08 ld [ %o1 + 8 ], %o1
400073a8: b8 10 00 02 mov %g2, %i4
if ( alloc_begin != 0 ) {
400073ac: 80 a7 20 00 cmp %i4, 0
400073b0: 22 bf ff ab be,a 4000725c <_Heap_Allocate_aligned_with_boundary+0x54> <== NEVER TAKEN
400073b4: d2 02 60 08 ld [ %o1 + 8 ], %o1
<== NOT EXECUTED
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
400073b8: 96 10 00 19 mov %i1, %o3
400073bc: 94 10 00 1c mov %i4, %o2
400073c0: 40 00 00 d3 call 4000770c <_Heap_Block_allocate>
400073c4: 90 10 00 18 mov %i0, %o0
alignment,
boundary
);
/* Statistics */
++stats->allocs;
400073c8: f6 06 20 58 ld [ %i0 + 0x58 ], %i3
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
400073cc: c8 02 20 04 ld [ %o0 + 4 ], %g4
stats->searches += search_count;
stats->lifetime_allocated += _Heap_Block_size( block );
400073d0: c4 1e 20 28 ldd [ %i0 + 0x28 ], %g2
stats->searches += search_count;
400073d4: c2 06 20 54 ld [ %i0 + 0x54 ], %g1
++stats->allocs;
400073d8: b6 06 e0 01 inc %i3
stats->searches += search_count;
400073dc: 82 00 40 1d add %g1, %i5, %g1
400073e0: 88 09 3f fe and %g4, -2, %g4
++stats->allocs;
400073e4: f6 26 20 58 st %i3, [ %i0 + 0x58 ]
stats->lifetime_allocated += _Heap_Block_size( block );
400073e8: b6 80 c0 04 addcc %g3, %g4, %i3
stats->searches += search_count;
400073ec: c2 26 20 54 st %g1, [ %i0 + 0x54 ]
stats->lifetime_allocated += _Heap_Block_size( block );
400073f0: b4 40 a0 00 addx %g2, 0, %i2
400073f4: f4 3e 20 28 std %i2, [ %i0 + 0x28 ]
/* Statistics */
++stats->failed_allocs;
}
/* Statistics */
if ( stats->max_search < search_count ) {
400073f8: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
400073fc: 80 a0 40 1d cmp %g1, %i5
40007400: 2a 80 00 02 bcs,a 40007408 <_Heap_Allocate_aligned_with_boundary+0x200>
40007404: fa 26 20 50 st %i5, [ %i0 + 0x50 ]
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
40007408: 81 c7 e0 08 ret
4000740c: 91 e8 00 1c restore %g0, %i4, %o0
++stats->failed_allocs;
40007410: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
40007414: 82 00 60 01 inc %g1
40007418: b8 10 20 00 clr %i4
4000741c: 10 bf ff f7 b 400073f8 <_Heap_Allocate_aligned_with_boundary+0x1f0>
40007420: c2 26 20 5c st %g1, [ %i0 + 0x5c ]
if ( boundary < alloc_size ) {
40007424: 18 80 00 06 bgu 4000743c <_Heap_Allocate_aligned_with_boundary+0x234>
40007428: 80 a6 a0 00 cmp %i2, 0
if ( alignment == 0 ) {
4000742c: 22 bf ff 7f be,a 40007228 <_Heap_Allocate_aligned_with_boundary+0x20>
40007430: b4 10 00 0d mov %o5, %i2
return _Heap_Free_list_head(heap)->next;
40007434: 10 bf ff 7e b 4000722c <_Heap_Allocate_aligned_with_boundary+0x24>
40007438: d2 06 20 08 ld [ %i0 + 8 ], %o1
return NULL;
4000743c: b8 10 20 00 clr %i4
}
40007440: 81 c7 e0 08 ret
40007444: 91 e8 00 1c restore %g0, %i4, %o0
4000770c <_Heap_Block_allocate>:
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
4000770c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40007710: c2 06 60 04 ld [ %i1 + 4 ], %g1
<== NOT EXECUTED
40007714: 82 08 7f fe and %g1, -2, %g1
<== NOT EXECUTED
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40007718: 84 06 40 01 add %i1, %g1, %g2
<== NOT EXECUTED
4000771c: c4 00 a0 04 ld [ %g2 + 4 ], %g2
40007720: ba 10 00 18 mov %i0, %i5
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
40007724: 80 88 a0 01 btst 1, %g2
40007728: b0 06 bf f8 add %i2, -8, %i0
return &heap->free_list;
4000772c: 94 10 00 1d mov %i5, %o2
40007730: 12 80 00 0f bne 4000776c <_Heap_Block_allocate+0x60>
<== NEVER TAKEN
40007734: 96 26 00 19 sub %i0, %i1, %o3
40007738: c4 06 60 08 ld [ %i1 + 8 ], %g2
free_list_anchor = block->prev;
4000773c: d4 06 60 0c ld [ %i1 + 0xc ], %o2
prev->next = next;
40007740: c4 22 a0 08 st %g2, [ %o2 + 8 ]
next->prev = prev;
40007744: d4 20 a0 0c st %o2, [ %g2 + 0xc ]
_Heap_Free_list_remove( block );
/* Statistics */
--stats->free_blocks;
40007748: f8 07 60 44 ld [ %i5 + 0x44 ], %i4
++stats->used_blocks;
4000774c: c8 07 60 4c ld [ %i5 + 0x4c ], %g4
stats->free_size -= _Heap_Block_size( block );
40007750: c4 07 60 3c ld [ %i5 + 0x3c ], %g2
--stats->free_blocks;
40007754: b8 07 3f ff add %i4, -1, %i4
++stats->used_blocks;
40007758: 88 01 20 01 inc %g4
stats->free_size -= _Heap_Block_size( block );
4000775c: 82 20 80 01 sub %g2, %g1, %g1
--stats->free_blocks;
40007760: f8 27 60 44 st %i4, [ %i5 + 0x44 ]
++stats->used_blocks;
40007764: c8 27 60 4c st %g4, [ %i5 + 0x4c ]
stats->free_size -= _Heap_Block_size( block );
40007768: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
} else {
free_list_anchor = _Heap_Free_list_head( heap );
}
if ( alloc_area_offset < heap->page_size ) {
4000776c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
40007770: 80 a0 80 0b cmp %g2, %o3
40007774: 28 80 00 0e bleu,a 400077ac <_Heap_Block_allocate+0xa0>
40007778: c6 07 60 3c ld [ %i5 + 0x3c ], %g3
_Heap_Block_split( heap, block, free_list_anchor, alloc_size );
4000777c: 96 02 c0 1b add %o3, %i3, %o3
40007780: 92 10 00 19 mov %i1, %o1
40007784: 90 10 00 1d mov %i5, %o0
40007788: 7f ff ff 30 call 40007448 <_Heap_Block_split>
4000778c: b0 10 00 19 mov %i1, %i0
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
40007790: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
40007794: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
40007798: 80 a0 80 01 cmp %g2, %g1
4000779c: 38 80 00 02 bgu,a 400077a4 <_Heap_Block_allocate+0x98>
400077a0: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
400077a4: 81 c7 e0 08 ret
400077a8: 81 e8 00 00 restore
return value - (value % alignment);
400077ac: 81 80 20 00 wr %g0, %y
400077b0: 01 00 00 00 nop
400077b4: 01 00 00 00 nop
400077b8: 01 00 00 00 nop
400077bc: 88 76 80 02 udiv %i2, %g2, %g4
400077c0: 84 59 00 02 smul %g4, %g2, %g2
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
400077c4: c2 06 60 04 ld [ %i1 + 4 ], %g1
return value - (value % alignment);
400077c8: b4 26 80 02 sub %i2, %g2, %i2
- HEAP_BLOCK_HEADER_SIZE);
400077cc: b0 26 00 1a sub %i0, %i2, %i0
block_size = block_end - block_begin;
400077d0: 84 26 00 19 sub %i0, %i1, %g2
stats->free_size += block_size;
400077d4: 86 00 c0 02 add %g3, %g2, %g3
400077d8: c6 27 60 3c st %g3, [ %i5 + 0x3c ]
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
400077dc: 82 08 7f fe and %g1, -2, %g1
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
400077e0: c6 06 60 04 ld [ %i1 + 4 ], %g3
uintptr_t block_end = block_begin + block_size;
400077e4: 82 06 40 01 add %i1, %g1, %g1
if ( _Heap_Is_prev_used( block ) ) {
400077e8: 80 88 e0 01 btst 1, %g3
400077ec: 12 80 00 11 bne 40007830 <_Heap_Block_allocate+0x124>
400077f0: 82 20 40 18 sub %g1, %i0, %g1
return (Heap_Block *) ((uintptr_t) block - block->prev_size);
400077f4: c6 06 40 00 ld [ %i1 ], %g3
400077f8: b2 26 40 03 sub %i1, %g3, %i1
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
400077fc: c6 06 60 04 ld [ %i1 + 4 ], %g3
40007800: 86 08 ff fe and %g3, -2, %g3
block_size += prev_block_size;
40007804: 84 00 80 03 add %g2, %g3, %g2
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
40007808: 86 10 a0 01 or %g2, 1, %g3
4000780c: c6 26 60 04 st %g3, [ %i1 + 4 ]
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
40007810: 96 10 00 1b mov %i3, %o3
new_block->prev_size = block_size;
40007814: c4 26 00 00 st %g2, [ %i0 ]
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
40007818: 92 10 00 18 mov %i0, %o1
new_block->size_and_flag = new_block_size;
4000781c: c2 26 20 04 st %g1, [ %i0 + 4 ]
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
40007820: 7f ff ff 0a call 40007448 <_Heap_Block_split>
40007824: 90 10 00 1d mov %i5, %o0
if ( stats->min_free_size > stats->free_size ) {
40007828: 10 bf ff db b 40007794 <_Heap_Block_allocate+0x88>
4000782c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
Heap_Block *next = block_before->next;
40007830: c8 02 a0 08 ld [ %o2 + 8 ], %g4
new_block->next = next;
40007834: c8 26 60 08 st %g4, [ %i1 + 8 ]
new_block->prev = block_before;
40007838: d4 26 60 0c st %o2, [ %i1 + 0xc ]
block_before->next = new_block;
4000783c: f2 22 a0 08 st %i1, [ %o2 + 8 ]
++stats->free_blocks;
40007840: 94 10 00 19 mov %i1, %o2
40007844: c6 07 60 44 ld [ %i5 + 0x44 ], %g3
next->prev = new_block;
40007848: f2 21 20 0c st %i1, [ %g4 + 0xc ]
4000784c: 86 00 e0 01 inc %g3
40007850: 10 bf ff ee b 40007808 <_Heap_Block_allocate+0xfc>
40007854: c6 27 60 44 st %g3, [ %i5 + 0x44 ]
4000d6bc <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused RTEMS_UNUSED
)
{
4000d6bc: 9d e3 bf 98 save %sp, -104, %sp
Heap_Block *start_block = first_block;
Heap_Block *merge_below_block = NULL;
Heap_Block *merge_above_block = NULL;
Heap_Block *link_below_block = NULL;
Heap_Block *link_above_block = NULL;
Heap_Block *extend_first_block = NULL;
4000d6c0: c0 27 bf f8 clr [ %fp + -8 ]
{
4000d6c4: ba 10 00 18 mov %i0, %i5
Heap_Block *extend_last_block = NULL;
4000d6c8: c0 27 bf fc clr [ %fp + -4 ]
4000d6cc: b6 86 40 1a addcc %i1, %i2, %i3
Heap_Block *const first_block = heap->first_block;
4000d6d0: 0a 80 00 83 bcs 4000d8dc <_Heap_Extend+0x220>
4000d6d4: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
uintptr_t const page_size = heap->page_size;
4000d6d8: f8 06 20 10 ld [ %i0 + 0x10 ], %i4
if ( extend_area_end < extend_area_begin ) {
return 0;
}
extend_area_ok = _Heap_Get_first_and_last_block(
4000d6dc: d6 06 20 14 ld [ %i0 + 0x14 ], %o3
4000d6e0: 9a 07 bf fc add %fp, -4, %o5
uintptr_t const free_size = stats->free_size;
4000d6e4: f0 06 20 3c ld [ %i0 + 0x3c ], %i0
extend_area_ok = _Heap_Get_first_and_last_block(
4000d6e8: 98 07 bf f8 add %fp, -8, %o4
4000d6ec: 94 10 00 1c mov %i4, %o2
4000d6f0: 92 10 00 1a mov %i2, %o1
4000d6f4: 7f ff e5 e1 call 40006e78 <_Heap_Get_first_and_last_block>
4000d6f8: 90 10 00 19 mov %i1, %o0
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
4000d6fc: 80 a2 20 00 cmp %o0, 0
4000d700: 02 80 00 77 be 4000d8dc <_Heap_Extend+0x220>
4000d704: 82 10 00 10 mov %l0, %g1
Heap_Block *link_above_block = NULL;
4000d708: a4 10 20 00 clr %l2
Heap_Block *link_below_block = NULL;
4000d70c: 9e 10 20 00 clr %o7
Heap_Block *merge_above_block = NULL;
4000d710: b4 10 20 00 clr %i2
Heap_Block *merge_below_block = NULL;
4000d714: a2 10 20 00 clr %l1
return 0;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
4000d718: 80 a0 40 10 cmp %g1, %l0
4000d71c: 02 80 00 7f be 4000d918 <_Heap_Extend+0x25c>
4000d720: 88 10 00 01 mov %g1, %g4
uintptr_t const sub_area_end = start_block->prev_size;
4000d724: c6 00 40 00 ld [ %g1 ], %g3
return value - (value % alignment);
4000d728: 81 80 20 00 wr %g0, %y
4000d72c: 01 00 00 00 nop
4000d730: 01 00 00 00 nop
4000d734: 01 00 00 00 nop
4000d738: 84 70 c0 1c udiv %g3, %i4, %g2
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
4000d73c: 80 a6 40 03 cmp %i1, %g3
4000d740: 84 58 80 1c smul %g2, %i4, %g2
4000d744: 1a 80 00 05 bcc 4000d758 <_Heap_Extend+0x9c>
4000d748: 84 00 bf f8 add %g2, -8, %g2
4000d74c: 80 a1 00 1b cmp %g4, %i3
4000d750: 0a 80 00 63 bcs 4000d8dc <_Heap_Extend+0x220>
4000d754: 01 00 00 00 nop
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return 0;
}
if ( extend_area_end == sub_area_begin ) {
4000d758: 80 a1 00 1b cmp %g4, %i3
4000d75c: 02 80 00 6d be 4000d910 <_Heap_Extend+0x254>
4000d760: 80 a6 c0 03 cmp %i3, %g3
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
4000d764: 0a 80 00 60 bcs 4000d8e4 <_Heap_Extend+0x228>
4000d768: 80 a6 40 03 cmp %i1, %g3
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
4000d76c: 80 a6 40 03 cmp %i1, %g3
4000d770: 22 80 00 60 be,a 4000d8f0 <_Heap_Extend+0x234>
4000d774: f6 20 40 00 st %i3, [ %g1 ]
start_block->prev_size = extend_area_end;
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
4000d778: 38 80 00 02 bgu,a 4000d780 <_Heap_Extend+0xc4>
4000d77c: a4 10 00 02 mov %g2, %l2
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000d780: c2 00 a0 04 ld [ %g2 + 4 ], %g1
4000d784: 82 08 7f fe and %g1, -2, %g1
return (Heap_Block *) ((uintptr_t) block + offset);
4000d788: 82 00 40 02 add %g1, %g2, %g1
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
4000d78c: 80 a4 00 01 cmp %l0, %g1
4000d790: 12 bf ff e3 bne 4000d71c <_Heap_Extend+0x60>
4000d794: 80 a0 40 10 cmp %g1, %l0
if ( extend_area_begin < heap->area_begin ) {
4000d798: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000d79c: 80 a0 40 19 cmp %g1, %i1
4000d7a0: 38 80 00 06 bgu,a 4000d7b8 <_Heap_Extend+0xfc>
4000d7a4: f2 27 60 18 st %i1, [ %i5 + 0x18 ]
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
4000d7a8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000d7ac: 80 a0 40 1b cmp %g1, %i3
4000d7b0: 2a 80 00 02 bcs,a 4000d7b8 <_Heap_Extend+0xfc>
4000d7b4: f6 27 60 1c st %i3, [ %i5 + 0x1c ]
heap->area_end = extend_area_end;
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
4000d7b8: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000d7bc: c4 07 bf fc ld [ %fp + -4 ], %g2
extend_first_block_size =
4000d7c0: 86 20 80 01 sub %g2, %g1, %g3
extend_first_block->prev_size = extend_area_end;
4000d7c4: f6 20 40 00 st %i3, [ %g1 ]
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
4000d7c8: 88 10 e0 01 or %g3, 1, %g4
extend_first_block->size_and_flag =
4000d7cc: c8 20 60 04 st %g4, [ %g1 + 4 ]
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
4000d7d0: c6 20 80 00 st %g3, [ %g2 ]
extend_last_block->size_and_flag = 0;
4000d7d4: c0 20 a0 04 clr [ %g2 + 4 ]
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
4000d7d8: c6 07 60 20 ld [ %i5 + 0x20 ], %g3
4000d7dc: 80 a0 c0 01 cmp %g3, %g1
4000d7e0: 28 80 00 50 bleu,a 4000d920 <_Heap_Extend+0x264>
4000d7e4: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
heap->first_block = extend_first_block;
4000d7e8: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
4000d7ec: 80 a4 60 00 cmp %l1, 0
4000d7f0: 02 80 00 51 be 4000d934 <_Heap_Extend+0x278>
4000d7f4: b2 06 60 08 add %i1, 8, %i1
uintptr_t const page_size = heap->page_size;
4000d7f8: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
uintptr_t remainder = value % alignment;
4000d7fc: 81 80 20 00 wr %g0, %y
4000d800: 01 00 00 00 nop
4000d804: 01 00 00 00 nop
4000d808: 01 00 00 00 nop
4000d80c: 82 76 40 02 udiv %i1, %g2, %g1
4000d810: 82 58 40 02 smul %g1, %g2, %g1
if ( remainder != 0 ) {
4000d814: 82 a6 40 01 subcc %i1, %g1, %g1
4000d818: 22 80 00 05 be,a 4000d82c <_Heap_Extend+0x170>
4000d81c: c2 04 40 00 ld [ %l1 ], %g1
return value - remainder + alignment;
4000d820: b2 00 80 19 add %g2, %i1, %i1
4000d824: b2 26 40 01 sub %i1, %g1, %i1
new_first_block->prev_size = first_block->prev_size;
4000d828: c2 04 40 00 ld [ %l1 ], %g1
4000d82c: c2 26 7f f8 st %g1, [ %i1 + -8 ]
uintptr_t const new_first_block_begin =
4000d830: 92 06 7f f8 add %i1, -8, %o1
uintptr_t const new_first_block_size =
4000d834: 82 24 40 09 sub %l1, %o1, %g1
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
4000d838: 82 10 60 01 or %g1, 1, %g1
4000d83c: c2 22 60 04 st %g1, [ %o1 + 4 ]
_Heap_Free_block( heap, new_first_block );
4000d840: 7f ff ff 89 call 4000d664 <_Heap_Free_block>
4000d844: 90 10 00 1d mov %i5, %o0
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
4000d848: 80 a6 a0 00 cmp %i2, 0
4000d84c: 02 80 00 40 be 4000d94c <_Heap_Extend+0x290>
4000d850: b6 06 ff f8 add %i3, -8, %i3
return value - (value % alignment);
4000d854: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
(last_block->size_and_flag - last_block_new_size)
4000d858: c6 06 a0 04 ld [ %i2 + 4 ], %g3
uintptr_t const last_block_new_size = _Heap_Align_down(
4000d85c: b6 26 c0 1a sub %i3, %i2, %i3
4000d860: 81 80 20 00 wr %g0, %y
4000d864: 01 00 00 00 nop
4000d868: 01 00 00 00 nop
4000d86c: 01 00 00 00 nop
4000d870: 82 76 c0 02 udiv %i3, %g2, %g1
4000d874: 84 58 40 02 smul %g1, %g2, %g2
new_last_block->size_and_flag =
4000d878: 88 06 80 02 add %i2, %g2, %g4
(last_block->size_and_flag - last_block_new_size)
4000d87c: 82 20 c0 02 sub %g3, %g2, %g1
| HEAP_PREV_BLOCK_USED;
4000d880: 82 10 60 01 or %g1, 1, %g1
new_last_block->size_and_flag =
4000d884: c2 21 20 04 st %g1, [ %g4 + 4 ]
_Heap_Free_block( heap, last_block );
4000d888: 92 10 00 1a mov %i2, %o1
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000d88c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4000d890: 82 08 60 01 and %g1, 1, %g1
block->size_and_flag = size | flag;
4000d894: 82 10 40 02 or %g1, %g2, %g1
4000d898: c2 26 a0 04 st %g1, [ %i2 + 4 ]
4000d89c: 7f ff ff 72 call 4000d664 <_Heap_Free_block>
4000d8a0: 90 10 00 1d mov %i5, %o0
4000d8a4: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000d8a8: c6 00 a0 04 ld [ %g2 + 4 ], %g3
_Heap_Block_set_size(
4000d8ac: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000d8b0: 82 20 40 02 sub %g1, %g2, %g1
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000d8b4: 86 08 e0 01 and %g3, 1, %g3
block->size_and_flag = size | flag;
4000d8b8: 82 10 40 03 or %g1, %g3, %g1
4000d8bc: c2 20 a0 04 st %g1, [ %g2 + 4 ]
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
/* Statistics */
stats->size += extended_size;
4000d8c0: c4 07 60 38 ld [ %i5 + 0x38 ], %g2
extended_size = stats->free_size - free_size;
4000d8c4: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
4000d8c8: b0 20 40 18 sub %g1, %i0, %i0
stats->size += extended_size;
4000d8cc: 82 00 80 18 add %g2, %i0, %g1
4000d8d0: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
return extended_size;
}
4000d8d4: 81 c7 e0 08 ret
4000d8d8: 81 e8 00 00 restore
return 0;
4000d8dc: 81 c7 e0 08 ret
4000d8e0: 91 e8 20 00 restore %g0, 0, %o0
if ( sub_area_end == extend_area_begin ) {
4000d8e4: 12 bf ff a5 bne 4000d778 <_Heap_Extend+0xbc>
<== ALWAYS TAKEN
4000d8e8: 9e 10 00 01 mov %g1, %o7
start_block->prev_size = extend_area_end;
4000d8ec: f6 20 40 00 st %i3, [ %g1 ]
<== NOT EXECUTED
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000d8f0: c2 00 a0 04 ld [ %g2 + 4 ], %g1
4000d8f4: 82 08 7f fe and %g1, -2, %g1
return (Heap_Block *) ((uintptr_t) block + offset);
4000d8f8: 82 00 40 02 add %g1, %g2, %g1
} while ( start_block != first_block );
4000d8fc: 80 a4 00 01 cmp %l0, %g1
4000d900: 12 bf ff 86 bne 4000d718 <_Heap_Extend+0x5c>
<== NEVER TAKEN
4000d904: b4 10 00 02 mov %g2, %i2
if ( extend_area_begin < heap->area_begin ) {
4000d908: 10 bf ff a5 b 4000d79c <_Heap_Extend+0xe0>
4000d90c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000d910: 10 bf ff 97 b 4000d76c <_Heap_Extend+0xb0>
4000d914: a2 10 00 01 mov %g1, %l1
4000d918: 10 bf ff 83 b 4000d724 <_Heap_Extend+0x68>
4000d91c: c8 07 60 18 ld [ %i5 + 0x18 ], %g4
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
4000d920: 80 a0 40 02 cmp %g1, %g2
4000d924: 2a bf ff b2 bcs,a 4000d7ec <_Heap_Extend+0x130>
4000d928: c4 27 60 24 st %g2, [ %i5 + 0x24 ]
if ( merge_below_block != NULL ) {
4000d92c: 10 bf ff b1 b 4000d7f0 <_Heap_Extend+0x134>
4000d930: 80 a4 60 00 cmp %l1, 0
} else if ( link_below_block != NULL ) {
4000d934: 80 a3 e0 00 cmp %o7, 0
4000d938: 02 bf ff c4 be 4000d848 <_Heap_Extend+0x18c>
4000d93c: 9e 23 c0 02 sub %o7, %g2, %o7
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
4000d940: 9e 13 e0 01 or %o7, 1, %o7
last_block->size_and_flag =
4000d944: 10 bf ff c1 b 4000d848 <_Heap_Extend+0x18c>
4000d948: de 20 a0 04 st %o7, [ %g2 + 4 ]
} else if ( link_above_block != NULL ) {
4000d94c: 80 a4 a0 00 cmp %l2, 0
4000d950: 02 80 00 0b be 4000d97c <_Heap_Extend+0x2c0>
4000d954: c2 07 bf f8 ld [ %fp + -8 ], %g1
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000d958: c4 04 a0 04 ld [ %l2 + 4 ], %g2
4000d95c: 84 08 a0 01 and %g2, 1, %g2
_Heap_Block_set_size( link, first_block_begin - link_begin );
4000d960: 82 20 40 12 sub %g1, %l2, %g1
block->size_and_flag = size | flag;
4000d964: 82 10 40 02 or %g1, %g2, %g1
4000d968: c2 24 a0 04 st %g1, [ %l2 + 4 ]
_Heap_Link_above(
4000d96c: c4 07 bf fc ld [ %fp + -4 ], %g2
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
4000d970: c2 00 a0 04 ld [ %g2 + 4 ], %g1
4000d974: 82 10 60 01 or %g1, 1, %g1
4000d978: c2 20 a0 04 st %g1, [ %g2 + 4 ]
if ( merge_below_block == NULL && merge_above_block == NULL ) {
4000d97c: 80 a4 60 00 cmp %l1, 0
4000d980: 12 bf ff c9 bne 4000d8a4 <_Heap_Extend+0x1e8>
4000d984: d2 07 bf f8 ld [ %fp + -8 ], %o1
_Heap_Free_block( heap, extend_first_block );
4000d988: 7f ff ff 37 call 4000d664 <_Heap_Free_block>
4000d98c: 90 10 00 1d mov %i5, %o0
4000d990: 10 bf ff c6 b 4000d8a8 <_Heap_Extend+0x1ec>
4000d994: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
4000dcdc <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
4000dcdc: 9d e3 bf a0 save %sp, -96, %sp
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
4000dce0: 80 a6 60 00 cmp %i1, 0
4000dce4: 02 80 00 41 be 4000dde8 <_Heap_Free+0x10c>
4000dce8: 84 10 20 01 mov 1, %g2
return value - (value % alignment);
4000dcec: c8 06 20 10 ld [ %i0 + 0x10 ], %g4
return (uintptr_t) block >= (uintptr_t) heap->first_block
4000dcf0: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
return value - (value % alignment);
4000dcf4: 81 80 20 00 wr %g0, %y
4000dcf8: 01 00 00 00 nop
4000dcfc: 01 00 00 00 nop
4000dd00: 01 00 00 00 nop
4000dd04: 82 76 40 04 udiv %i1, %g4, %g1
4000dd08: 82 58 40 04 smul %g1, %g4, %g1
- HEAP_BLOCK_HEADER_SIZE);
4000dd0c: 82 00 7f f8 add %g1, -8, %g1
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000dd10: 80 a0 40 03 cmp %g1, %g3
4000dd14: 0a 80 00 35 bcs 4000dde8 <_Heap_Free+0x10c>
4000dd18: 84 10 20 00 clr %g2
4000dd1c: f6 06 20 24 ld [ %i0 + 0x24 ], %i3
4000dd20: 80 a0 40 1b cmp %g1, %i3
4000dd24: 38 80 00 32 bgu,a 4000ddec <_Heap_Free+0x110>
4000dd28: b0 08 a0 ff and %g2, 0xff, %i0
4000dd2c: fa 00 60 04 ld [ %g1 + 4 ], %i5
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000dd30: b8 0f 7f fe and %i5, -2, %i4
return (Heap_Block *) ((uintptr_t) block + offset);
4000dd34: 88 00 40 1c add %g1, %i4, %g4
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000dd38: 80 a0 c0 04 cmp %g3, %g4
4000dd3c: 38 80 00 2c bgu,a 4000ddec <_Heap_Free+0x110>
<== NEVER TAKEN
4000dd40: b0 08 a0 ff and %g2, 0xff, %i0
<== NOT EXECUTED
4000dd44: 80 a6 c0 04 cmp %i3, %g4
4000dd48: 2a 80 00 29 bcs,a 4000ddec <_Heap_Free+0x110>
4000dd4c: b0 08 a0 ff and %g2, 0xff, %i0
4000dd50: f4 01 20 04 ld [ %g4 + 4 ], %i2
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
4000dd54: 80 8e a0 01 btst 1, %i2
4000dd58: 02 80 00 24 be 4000dde8 <_Heap_Free+0x10c>
<== NEVER TAKEN
4000dd5c: b4 0e bf fe and %i2, -2, %i2
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
4000dd60: 80 a6 c0 04 cmp %i3, %g4
4000dd64: 02 80 00 24 be 4000ddf4 <_Heap_Free+0x118>
4000dd68: ba 0f 60 01 and %i5, 1, %i5
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000dd6c: 84 01 00 1a add %g4, %i2, %g2
4000dd70: c4 00 a0 04 ld [ %g2 + 4 ], %g2
4000dd74: 80 88 a0 01 btst 1, %g2
4000dd78: 12 80 00 20 bne 4000ddf8 <_Heap_Free+0x11c>
4000dd7c: 80 a7 60 00 cmp %i5, 0
if ( !_Heap_Is_prev_used( block ) ) {
4000dd80: 02 80 00 20 be 4000de00 <_Heap_Free+0x124>
4000dd84: 9e 10 20 01 mov 1, %o7
4000dd88: c6 01 20 08 ld [ %g4 + 8 ], %g3
4000dd8c: c4 01 20 0c ld [ %g4 + 0xc ], %g2
new_block->prev = prev;
4000dd90: c4 20 60 0c st %g2, [ %g1 + 0xc ]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
4000dd94: b4 07 00 1a add %i4, %i2, %i2
new_block->next = next;
4000dd98: c6 20 60 08 st %g3, [ %g1 + 8 ]
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000dd9c: 88 16 a0 01 or %i2, 1, %g4
next->prev = new_block;
4000dda0: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
prev->next = new_block;
4000dda4: c2 20 a0 08 st %g1, [ %g2 + 8 ]
4000dda8: c8 20 60 04 st %g4, [ %g1 + 4 ]
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
4000ddac: f4 20 40 1a st %i2, [ %g1 + %i2 ]
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
stats->lifetime_freed += block_size;
return( true );
4000ddb0: 84 10 20 01 mov 1, %g2
stats->lifetime_freed += block_size;
4000ddb4: f4 1e 20 30 ldd [ %i0 + 0x30 ], %i2
--stats->used_blocks;
4000ddb8: c8 06 20 4c ld [ %i0 + 0x4c ], %g4
++stats->frees;
4000ddbc: c6 06 20 60 ld [ %i0 + 0x60 ], %g3
stats->free_size += block_size;
4000ddc0: c2 06 20 3c ld [ %i0 + 0x3c ], %g1
stats->lifetime_freed += block_size;
4000ddc4: 9a 86 c0 1c addcc %i3, %i4, %o5
--stats->used_blocks;
4000ddc8: 88 01 3f ff add %g4, -1, %g4
++stats->frees;
4000ddcc: 86 00 e0 01 inc %g3
stats->free_size += block_size;
4000ddd0: 82 00 40 1c add %g1, %i4, %g1
stats->lifetime_freed += block_size;
4000ddd4: 98 46 a0 00 addx %i2, 0, %o4
--stats->used_blocks;
4000ddd8: c8 26 20 4c st %g4, [ %i0 + 0x4c ]
++stats->frees;
4000dddc: c6 26 20 60 st %g3, [ %i0 + 0x60 ]
stats->free_size += block_size;
4000dde0: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
stats->lifetime_freed += block_size;
4000dde4: d8 3e 20 30 std %o4, [ %i0 + 0x30 ]
4000dde8: b0 08 a0 ff and %g2, 0xff, %i0
}
4000ddec: 81 c7 e0 08 ret
4000ddf0: 81 e8 00 00 restore
if ( !_Heap_Is_prev_used( block ) ) {
4000ddf4: 80 a7 60 00 cmp %i5, 0
4000ddf8: 12 80 00 1c bne 4000de68 <_Heap_Free+0x18c>
4000ddfc: 9e 10 20 00 clr %o7
uintptr_t const prev_size = block->prev_size;
4000de00: f2 00 40 00 ld [ %g1 ], %i1
4000de04: ba 20 40 19 sub %g1, %i1, %i5
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000de08: 80 a7 40 03 cmp %i5, %g3
4000de0c: 0a bf ff f7 bcs 4000dde8 <_Heap_Free+0x10c>
<== NEVER TAKEN
4000de10: 84 10 20 00 clr %g2
4000de14: 80 a7 40 1b cmp %i5, %i3
4000de18: 38 bf ff f5 bgu,a 4000ddec <_Heap_Free+0x110>
<== NEVER TAKEN
4000de1c: b0 08 a0 ff and %g2, 0xff, %i0
<== NOT EXECUTED
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000de20: c6 07 60 04 ld [ %i5 + 4 ], %g3
if ( !_Heap_Is_prev_used ( prev_block) ) {
4000de24: 80 88 e0 01 btst 1, %g3
4000de28: 02 bf ff f0 be 4000dde8 <_Heap_Free+0x10c>
<== NEVER TAKEN
4000de2c: 80 a3 e0 00 cmp %o7, 0
if ( next_is_free ) { /* coalesce both */
4000de30: 02 80 00 22 be 4000deb8 <_Heap_Free+0x1dc>
4000de34: b2 06 40 1c add %i1, %i4, %i1
4000de38: c4 01 20 08 ld [ %g4 + 8 ], %g2
4000de3c: c6 01 20 0c ld [ %g4 + 0xc ], %g3
prev->next = next;
4000de40: c4 20 e0 08 st %g2, [ %g3 + 8 ]
uintptr_t const size = block_size + prev_size + next_block_size;
4000de44: b4 06 80 19 add %i2, %i1, %i2
stats->free_blocks -= 1;
4000de48: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
next->prev = prev;
4000de4c: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
4000de50: 82 00 7f ff add %g1, -1, %g1
4000de54: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000de58: 82 16 a0 01 or %i2, 1, %g1
4000de5c: c2 27 60 04 st %g1, [ %i5 + 4 ]
4000de60: 10 bf ff d4 b 4000ddb0 <_Heap_Free+0xd4>
4000de64: f4 27 40 1a st %i2, [ %i5 + %i2 ]
Heap_Block *next = block_before->next;
4000de68: c6 06 20 08 ld [ %i0 + 8 ], %g3
new_block->next = next;
4000de6c: c6 20 60 08 st %g3, [ %g1 + 8 ]
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
4000de70: 84 17 20 01 or %i4, 1, %g2
new_block->prev = block_before;
4000de74: f0 20 60 0c st %i0, [ %g1 + 0xc ]
block_before->next = new_block;
4000de78: c2 26 20 08 st %g1, [ %i0 + 8 ]
next->prev = new_block;
4000de7c: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
4000de80: c4 20 60 04 st %g2, [ %g1 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000de84: c4 01 20 04 ld [ %g4 + 4 ], %g2
4000de88: 84 08 bf fe and %g2, -2, %g2
4000de8c: c4 21 20 04 st %g2, [ %g4 + 4 ]
++stats->free_blocks;
4000de90: c4 06 20 44 ld [ %i0 + 0x44 ], %g2
next_block->prev_size = block_size;
4000de94: f8 20 40 1c st %i4, [ %g1 + %i4 ]
++stats->free_blocks;
4000de98: 82 00 a0 01 add %g2, 1, %g1
4000de9c: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
if ( stats->max_free_blocks < stats->free_blocks ) {
4000dea0: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
4000dea4: 80 a0 40 02 cmp %g1, %g2
4000dea8: 38 bf ff c2 bgu,a 4000ddb0 <_Heap_Free+0xd4>
4000deac: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
return( true );
4000deb0: 10 bf ff c1 b 4000ddb4 <_Heap_Free+0xd8>
4000deb4: 84 10 20 01 mov 1, %g2
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000deb8: 84 16 60 01 or %i1, 1, %g2
4000debc: c4 27 60 04 st %g2, [ %i5 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000dec0: c4 01 20 04 ld [ %g4 + 4 ], %g2
4000dec4: 84 08 bf fe and %g2, -2, %g2
4000dec8: c4 21 20 04 st %g2, [ %g4 + 4 ]
next_block->prev_size = size;
4000decc: 10 bf ff b9 b 4000ddb0 <_Heap_Free+0xd4>
4000ded0: f2 20 40 1c st %i1, [ %g1 + %i4 ]
40006e78 <_Heap_Get_first_and_last_block>:
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
40006e78: 84 02 20 08 add %o0, 8, %g2
<== NOT EXECUTED
uintptr_t remainder = value % alignment;
40006e7c: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40006e80: 01 00 00 00 nop
<== NOT EXECUTED
40006e84: 01 00 00 00 nop
<== NOT EXECUTED
40006e88: 01 00 00 00 nop
<== NOT EXECUTED
40006e8c: 82 70 80 0a udiv %g2, %o2, %g1
<== NOT EXECUTED
40006e90: 82 58 40 0a smul %g1, %o2, %g1
<== NOT EXECUTED
if ( remainder != 0 ) {
40006e94: 82 a0 80 01 subcc %g2, %g1, %g1
<== NOT EXECUTED
40006e98: 02 80 00 1a be 40006f00 <_Heap_Get_first_and_last_block+0x88>
<== NOT EXECUTED
40006e9c: 88 02 00 09 add %o0, %o1, %g4
<== NOT EXECUTED
40006ea0: 86 02 bf f8 add %o2, -8, %g3
<== NOT EXECUTED
40006ea4: 84 00 c0 02 add %g3, %g2, %g2
<== NOT EXECUTED
40006ea8: 82 20 80 01 sub %g2, %g1, %g1
<== NOT EXECUTED
40006eac: 84 20 40 08 sub %g1, %o0, %g2
<== NOT EXECUTED
40006eb0: 84 00 a0 08 add %g2, 8, %g2
<== NOT EXECUTED
heap_area_end < heap_area_begin
40006eb4: 80 a1 00 08 cmp %g4, %o0
<== NOT EXECUTED
40006eb8: 88 40 20 00 addx %g0, 0, %g4
<== NOT EXECUTED
|| heap_area_size <= overhead
40006ebc: 80 a0 80 09 cmp %g2, %o1
<== NOT EXECUTED
_Heap_Align_down( heap_area_size - overhead, page_size );
40006ec0: 92 22 40 02 sub %o1, %g2, %o1
<== NOT EXECUTED
|| heap_area_size <= overhead
40006ec4: 86 60 3f ff subx %g0, -1, %g3
<== NOT EXECUTED
return value - (value % alignment);
40006ec8: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40006ecc: 01 00 00 00 nop
<== NOT EXECUTED
40006ed0: 01 00 00 00 nop
<== NOT EXECUTED
40006ed4: 01 00 00 00 nop
<== NOT EXECUTED
40006ed8: 84 72 40 0a udiv %o1, %o2, %g2
<== NOT EXECUTED
|| first_block_size < min_block_size
40006edc: 80 91 00 03 orcc %g4, %g3, %g0
<== NOT EXECUTED
40006ee0: 12 80 00 05 bne 40006ef4 <_Heap_Get_first_and_last_block+0x7c>
<== NOT EXECUTED
40006ee4: 94 58 80 0a smul %g2, %o2, %o2
<== NOT EXECUTED
40006ee8: 80 a2 80 0b cmp %o2, %o3
<== NOT EXECUTED
40006eec: 3a 80 00 08 bcc,a 40006f0c <_Heap_Get_first_and_last_block+0x94>
<== NOT EXECUTED
40006ef0: c2 23 00 00 st %g1, [ %o4 ]
<== NOT EXECUTED
return false;
40006ef4: 90 10 20 00 clr %o0
<== NOT EXECUTED
}
40006ef8: 81 c3 e0 08 retl
<== NOT EXECUTED
40006efc: 90 0a 20 01 and %o0, 1, %o0
<== NOT EXECUTED
40006f00: 82 10 00 08 mov %o0, %g1
<== NOT EXECUTED
40006f04: 10 bf ff ec b 40006eb4 <_Heap_Get_first_and_last_block+0x3c>
<== NOT EXECUTED
40006f08: 84 10 20 08 mov 8, %g2
<== NOT EXECUTED
return (Heap_Block *) ((uintptr_t) block + offset);
40006f0c: 94 02 80 01 add %o2, %g1, %o2
<== NOT EXECUTED
return true;
40006f10: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
*last_block_ptr = last_block;
40006f14: d4 23 40 00 st %o2, [ %o5 ]
<== NOT EXECUTED
}
40006f18: 81 c3 e0 08 retl
<== NOT EXECUTED
40006f1c: 90 0a 20 01 and %o0, 1, %o0
<== NOT EXECUTED
400123c4 <_Heap_Get_free_information>:
)
{
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
400123c4: c0 22 40 00 clr [ %o1 ]
<== NOT EXECUTED
info->largest = 0;
400123c8: c0 22 60 04 clr [ %o1 + 4 ]
<== NOT EXECUTED
info->total = 0;
400123cc: c0 22 60 08 clr [ %o1 + 8 ]
<== NOT EXECUTED
return _Heap_Free_list_head(heap)->next;
400123d0: c4 02 20 08 ld [ %o0 + 8 ], %g2
<== NOT EXECUTED
for(the_block = _Heap_Free_list_first(the_heap);
400123d4: 80 a2 00 02 cmp %o0, %g2
<== NOT EXECUTED
400123d8: 02 80 00 12 be 40012420 <_Heap_Get_free_information+0x5c>
<== NOT EXECUTED
400123dc: 88 10 20 01 mov 1, %g4
400123e0: 9a 10 20 00 clr %o5
400123e4: 10 80 00 03 b 400123f0 <_Heap_Get_free_information+0x2c>
400123e8: 86 10 20 00 clr %g3
400123ec: da 02 60 04 ld [ %o1 + 4 ], %o5
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
400123f0: c2 00 a0 04 ld [ %g2 + 4 ], %g1
400123f4: 82 08 7f fe and %g1, -2, %g1
uint32_t const the_size = _Heap_Block_size(the_block);
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
400123f8: c8 22 40 00 st %g4, [ %o1 ]
info->total += the_size;
400123fc: 86 00 c0 01 add %g3, %g1, %g3
if ( info->largest < the_size )
40012400: 80 a0 40 0d cmp %g1, %o5
40012404: 08 80 00 03 bleu 40012410 <_Heap_Get_free_information+0x4c>
40012408: c6 22 60 08 st %g3, [ %o1 + 8 ]
info->largest = the_size;
4001240c: c2 22 60 04 st %g1, [ %o1 + 4 ]
the_block = the_block->next)
40012410: c4 00 a0 08 ld [ %g2 + 8 ], %g2
for(the_block = _Heap_Free_list_first(the_heap);
40012414: 80 a2 00 02 cmp %o0, %g2
40012418: 12 bf ff f5 bne 400123ec <_Heap_Get_free_information+0x28>
4001241c: 88 01 20 01 inc %g4
}
}
40012420: 81 c3 e0 08 retl
40012424: 01 00 00 00 nop
400087fc <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
400087fc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Heap_Block *current;
size_t i;
_Heap_Protection_free_all_delayed_blocks( heap );
for (i = 0; i < block_count; ++i) {
40008800: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40008804: 02 80 00 3a be 400088ec <_Heap_Greedy_allocate+0xf0>
<== NOT EXECUTED
40008808: ba 10 00 18 mov %i0, %i5
4000880c: b5 2e a0 02 sll %i2, 2, %i2
Heap_Block *allocated_blocks = NULL;
40008810: b8 10 20 00 clr %i4
40008814: b4 06 40 1a add %i1, %i2, %i2
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
40008818: d2 06 40 00 ld [ %i1 ], %o1
4000881c: 96 10 20 00 clr %o3
40008820: 94 10 20 00 clr %o2
40008824: 7f ff ff 47 call 40008540 <_Heap_Allocate_aligned_with_boundary>
40008828: 90 10 00 1d mov %i5, %o0
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
4000882c: 80 a2 20 00 cmp %o0, 0
40008830: 02 80 00 0c be 40008860 <_Heap_Greedy_allocate+0x64>
40008834: b2 06 60 04 add %i1, 4, %i1
return value - (value % alignment);
40008838: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4000883c: 81 80 20 00 wr %g0, %y
40008840: 01 00 00 00 nop
40008844: 01 00 00 00 nop
40008848: 01 00 00 00 nop
4000884c: 82 72 00 02 udiv %o0, %g2, %g1
40008850: 82 58 40 02 smul %g1, %g2, %g1
Heap_Block *next_block = _Heap_Block_of_alloc_area(
(uintptr_t) next,
heap->page_size
);
next_block->next = allocated_blocks;
40008854: f8 20 40 00 st %i4, [ %g1 ]
- HEAP_BLOCK_HEADER_SIZE);
40008858: 82 00 7f f8 add %g1, -8, %g1
4000885c: b8 10 00 01 mov %g1, %i4
for (i = 0; i < block_count; ++i) {
40008860: 80 a6 80 19 cmp %i2, %i1
40008864: 32 bf ff ee bne,a 4000881c <_Heap_Greedy_allocate+0x20>
40008868: d2 06 40 00 ld [ %i1 ], %o1
return _Heap_Free_list_head(heap)->next;
4000886c: f0 07 60 08 ld [ %i5 + 8 ], %i0
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
40008870: 80 a7 40 18 cmp %i5, %i0
40008874: 22 80 00 19 be,a 400088d8 <_Heap_Greedy_allocate+0xdc>
40008878: b0 10 20 00 clr %i0
Heap_Block *allocated_blocks = NULL;
4000887c: 10 80 00 03 b 40008888 <_Heap_Greedy_allocate+0x8c>
40008880: b6 10 20 00 clr %i3
40008884: b0 10 00 01 mov %g1, %i0
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40008888: d6 06 20 04 ld [ %i0 + 4 ], %o3
4000888c: 96 0a ff fe and %o3, -2, %o3
_Heap_Block_allocate(
40008890: 94 06 20 08 add %i0, 8, %o2
40008894: 92 10 00 18 mov %i0, %o1
40008898: 96 02 ff f8 add %o3, -8, %o3
4000889c: 40 00 00 f0 call 40008c5c <_Heap_Block_allocate>
400088a0: 90 10 00 1d mov %i5, %o0
current,
_Heap_Alloc_area_of_block( current ),
_Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE
);
current->next = blocks;
400088a4: f6 26 20 08 st %i3, [ %i0 + 8 ]
return _Heap_Free_list_head(heap)->next;
400088a8: c2 07 60 08 ld [ %i5 + 8 ], %g1
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
400088ac: 80 a7 40 01 cmp %i5, %g1
400088b0: 12 bf ff f5 bne 40008884 <_Heap_Greedy_allocate+0x88>
400088b4: b6 10 00 18 mov %i0, %i3
blocks = current;
}
while ( allocated_blocks != NULL ) {
400088b8: 80 a7 20 00 cmp %i4, 0
400088bc: 02 80 00 0a be 400088e4 <_Heap_Greedy_allocate+0xe8>
400088c0: 01 00 00 00 nop
current = allocated_blocks;
allocated_blocks = allocated_blocks->next;
400088c4: f6 07 20 08 ld [ %i4 + 8 ], %i3
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
400088c8: 92 07 20 08 add %i4, 8, %o1
400088cc: 90 10 00 1d mov %i5, %o0
400088d0: 40 00 19 eb call 4000f07c <_Heap_Free>
400088d4: b8 10 00 1b mov %i3, %i4
while ( allocated_blocks != NULL ) {
400088d8: 80 a7 20 00 cmp %i4, 0
400088dc: 32 bf ff fb bne,a 400088c8 <_Heap_Greedy_allocate+0xcc>
400088e0: f6 07 20 08 ld [ %i4 + 8 ], %i3
}
return blocks;
}
400088e4: 81 c7 e0 08 ret
400088e8: 81 e8 00 00 restore
400088ec: f0 06 20 08 ld [ %i0 + 8 ], %i0
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
400088f0: 80 a7 40 18 cmp %i5, %i0
400088f4: 12 bf ff e2 bne 4000887c <_Heap_Greedy_allocate+0x80>
<== ALWAYS TAKEN
400088f8: b8 10 20 00 clr %i4
Heap_Block *blocks = NULL;
400088fc: 81 c7 e0 08 ret
<== NOT EXECUTED
40008900: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
40006ab0 <_Heap_Greedy_allocate_all_except_largest>:
Heap_Block *_Heap_Greedy_allocate_all_except_largest(
Heap_Control *heap,
uintptr_t *allocatable_size
)
{
40006ab0: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
Heap_Information info;
_Heap_Get_free_information( heap, &info );
40006ab4: 92 07 bf f4 add %fp, -12, %o1
<== NOT EXECUTED
40006ab8: 40 00 1a 76 call 4000d490 <_Heap_Get_free_information>
<== NOT EXECUTED
40006abc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( info.largest > 0 ) {
40006ac0: c2 07 bf f8 ld [ %fp + -8 ], %g1
40006ac4: 80 a0 60 00 cmp %g1, 0
40006ac8: 12 80 00 08 bne 40006ae8 <_Heap_Greedy_allocate_all_except_largest+0x38> <== ALWAYS TAKEN
40006acc: 94 10 20 01 mov 1, %o2
*allocatable_size = info.largest - HEAP_BLOCK_HEADER_SIZE + HEAP_ALLOC_BONUS;
} else {
*allocatable_size = 0;
40006ad0: c0 26 40 00 clr [ %i1 ]
<== NOT EXECUTED
}
return _Heap_Greedy_allocate( heap, allocatable_size, 1 );
40006ad4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40006ad8: 7f ff ff b4 call 400069a8 <_Heap_Greedy_allocate>
<== NOT EXECUTED
40006adc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
40006ae0: 81 c7 e0 08 ret
<== NOT EXECUTED
40006ae4: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
*allocatable_size = info.largest - HEAP_BLOCK_HEADER_SIZE + HEAP_ALLOC_BONUS;
40006ae8: 82 00 7f fc add %g1, -4, %g1
40006aec: c2 26 40 00 st %g1, [ %i1 ]
return _Heap_Greedy_allocate( heap, allocatable_size, 1 );
40006af0: 92 10 00 19 mov %i1, %o1
40006af4: 7f ff ff ad call 400069a8 <_Heap_Greedy_allocate>
40006af8: 90 10 00 18 mov %i0, %o0
}
40006afc: 81 c7 e0 08 ret
40006b00: 91 e8 00 08 restore %g0, %o0, %o0
40008904 <_Heap_Greedy_free>:
void _Heap_Greedy_free(
Heap_Control *heap,
Heap_Block *blocks
)
{
40008904: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
while ( blocks != NULL ) {
40008908: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000890c: 02 80 00 09 be 40008930 <_Heap_Greedy_free+0x2c>
<== NOT EXECUTED
40008910: 01 00 00 00 nop
Heap_Block *current = blocks;
blocks = blocks->next;
40008914: fa 06 60 08 ld [ %i1 + 8 ], %i5
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
40008918: 92 06 60 08 add %i1, 8, %o1
4000891c: 40 00 19 d8 call 4000f07c <_Heap_Free>
40008920: 90 10 00 18 mov %i0, %o0
while ( blocks != NULL ) {
40008924: b2 97 60 00 orcc %i5, 0, %i1
40008928: 32 bf ff fc bne,a 40008918 <_Heap_Greedy_free+0x14>
4000892c: fa 06 60 08 ld [ %i1 + 8 ], %i5
}
}
40008930: 81 c7 e0 08 ret
40008934: 81 e8 00 00 restore
40007580 <_Heap_Initialize>:
{
40007580: 9d e3 bf a0 save %sp, -96, %sp
40007584: a2 86 40 1a addcc %i1, %i2, %l1
40007588: 84 40 20 00 addx %g0, 0, %g2
if ( page_size == 0 ) {
4000758c: 80 a6 e0 00 cmp %i3, 0
40007590: 22 80 00 33 be,a 4000765c <_Heap_Initialize+0xdc>
40007594: b6 10 20 08 mov 8, %i3
if ( remainder != 0 ) {
40007598: 82 8e e0 07 andcc %i3, 7, %g1
4000759c: 02 80 00 05 be 400075b0 <_Heap_Initialize+0x30>
400075a0: 80 a6 e0 07 cmp %i3, 7
return value - remainder + alignment;
400075a4: b6 06 e0 08 add %i3, 8, %i3
400075a8: b6 26 c0 01 sub %i3, %g1, %i3
if ( page_size < CPU_ALIGNMENT ) {
400075ac: 80 a6 e0 07 cmp %i3, 7
400075b0: 08 80 00 29 bleu 40007654 <_Heap_Initialize+0xd4>
400075b4: ba 10 20 00 clr %i5
uintptr_t remainder = value % alignment;
400075b8: 82 10 20 10 mov 0x10, %g1
400075bc: 81 80 20 00 wr %g0, %y
400075c0: 01 00 00 00 nop
400075c4: 01 00 00 00 nop
400075c8: 01 00 00 00 nop
400075cc: 86 70 40 1b udiv %g1, %i3, %g3
400075d0: 86 58 c0 1b smul %g3, %i3, %g3
if ( remainder != 0 ) {
400075d4: 82 a0 40 03 subcc %g1, %g3, %g1
400075d8: 02 80 00 22 be 40007660 <_Heap_Initialize+0xe0>
400075dc: a0 10 20 10 mov 0x10, %l0
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
400075e0: b8 06 60 08 add %i1, 8, %i4
return value - remainder + alignment;
400075e4: a0 06 e0 10 add %i3, 0x10, %l0
400075e8: a0 24 00 01 sub %l0, %g1, %l0
uintptr_t remainder = value % alignment;
400075ec: 81 80 20 00 wr %g0, %y
400075f0: 01 00 00 00 nop
400075f4: 01 00 00 00 nop
400075f8: 01 00 00 00 nop
400075fc: 82 77 00 1b udiv %i4, %i3, %g1
40007600: 82 58 40 1b smul %g1, %i3, %g1
if ( remainder != 0 ) {
40007604: 82 a7 00 01 subcc %i4, %g1, %g1
40007608: 12 80 00 21 bne 4000768c <_Heap_Initialize+0x10c>
<== ALWAYS TAKEN
4000760c: b8 06 40 1b add %i1, %i3, %i4
uintptr_t const heap_area_begin = (uintptr_t) heap_area_begin_ptr;
40007610: b8 10 00 19 mov %i1, %i4
<== NOT EXECUTED
40007614: 82 10 20 08 mov 8, %g1
|| heap_area_size <= overhead
40007618: 80 a0 40 1a cmp %g1, %i2
_Heap_Align_down( heap_area_size - overhead, page_size );
4000761c: b4 26 80 01 sub %i2, %g1, %i2
|| heap_area_size <= overhead
40007620: 82 60 3f ff subx %g0, -1, %g1
return value - (value % alignment);
40007624: 81 80 20 00 wr %g0, %y
40007628: 01 00 00 00 nop
4000762c: 01 00 00 00 nop
40007630: 01 00 00 00 nop
40007634: ba 76 80 1b udiv %i2, %i3, %i5
|| first_block_size < min_block_size
40007638: 80 90 80 01 orcc %g2, %g1, %g0
4000763c: 12 80 00 05 bne 40007650 <_Heap_Initialize+0xd0>
40007640: ba 5f 40 1b smul %i5, %i3, %i5
40007644: 80 a7 40 10 cmp %i5, %l0
40007648: 1a 80 00 15 bcc 4000769c <_Heap_Initialize+0x11c>
4000764c: 94 10 20 68 mov 0x68, %o2
return 0;
40007650: ba 10 20 00 clr %i5
}
40007654: 81 c7 e0 08 ret
40007658: 91 e8 00 1d restore %g0, %i5, %o0
} else {
return value;
4000765c: a0 10 20 10 mov 0x10, %l0
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
40007660: b8 06 60 08 add %i1, 8, %i4
uintptr_t remainder = value % alignment;
40007664: 81 80 20 00 wr %g0, %y
40007668: 01 00 00 00 nop
4000766c: 01 00 00 00 nop
40007670: 01 00 00 00 nop
40007674: 82 77 00 1b udiv %i4, %i3, %g1
40007678: 82 58 40 1b smul %g1, %i3, %g1
if ( remainder != 0 ) {
4000767c: 82 a7 00 01 subcc %i4, %g1, %g1
40007680: 22 bf ff e5 be,a 40007614 <_Heap_Initialize+0x94>
40007684: b8 10 00 19 mov %i1, %i4
40007688: b8 06 40 1b add %i1, %i3, %i4
4000768c: b8 27 00 01 sub %i4, %g1, %i4
40007690: 82 27 00 19 sub %i4, %i1, %g1
40007694: 10 bf ff e1 b 40007618 <_Heap_Initialize+0x98>
40007698: 82 00 60 08 add %g1, 8, %g1
memset(heap, 0, sizeof(*heap));
4000769c: 92 10 20 00 clr %o1
400076a0: 40 00 1e d8 call 4000f200 <memset>
400076a4: 90 10 00 18 mov %i0, %o0
first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED;
400076a8: 82 17 60 01 or %i5, 1, %g1
first_block->next = _Heap_Free_list_tail( heap );
400076ac: f0 27 20 08 st %i0, [ %i4 + 8 ]
return (Heap_Block *) ((uintptr_t) block + offset);
400076b0: 86 07 40 1c add %i5, %i4, %g3
first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED;
400076b4: c2 27 20 04 st %g1, [ %i4 + 4 ]
_Heap_Block_set_size(
400076b8: 82 20 00 1d neg %i5, %g1
first_block->prev = _Heap_Free_list_head( heap );
400076bc: f0 27 20 0c st %i0, [ %i4 + 0xc ]
stats->free_blocks = 1;
400076c0: 84 10 20 01 mov 1, %g2
first_block->prev_size = heap_area_end;
400076c4: e2 27 00 00 st %l1, [ %i4 ]
heap->page_size = page_size;
400076c8: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
heap->min_block_size = min_block_size;
400076cc: e0 26 20 14 st %l0, [ %i0 + 0x14 ]
heap->area_begin = heap_area_begin;
400076d0: f2 26 20 18 st %i1, [ %i0 + 0x18 ]
heap->area_end = heap_area_end;
400076d4: e2 26 20 1c st %l1, [ %i0 + 0x1c ]
heap->first_block = first_block;
400076d8: f8 26 20 20 st %i4, [ %i0 + 0x20 ]
heap->last_block = last_block;
400076dc: c6 26 20 24 st %g3, [ %i0 + 0x24 ]
_Heap_Free_list_head( heap )->next = first_block;
400076e0: f8 26 20 08 st %i4, [ %i0 + 8 ]
_Heap_Free_list_tail( heap )->prev = first_block;
400076e4: f8 26 20 0c st %i4, [ %i0 + 0xc ]
last_block->prev_size = first_block_size;
400076e8: fa 27 40 1c st %i5, [ %i5 + %i4 ]
block->size_and_flag = size | flag;
400076ec: c2 20 e0 04 st %g1, [ %g3 + 4 ]
stats->size = first_block_size;
400076f0: fa 26 20 38 st %i5, [ %i0 + 0x38 ]
stats->free_size = first_block_size;
400076f4: fa 26 20 3c st %i5, [ %i0 + 0x3c ]
stats->min_free_size = first_block_size;
400076f8: fa 26 20 40 st %i5, [ %i0 + 0x40 ]
stats->free_blocks = 1;
400076fc: c4 26 20 44 st %g2, [ %i0 + 0x44 ]
stats->max_free_blocks = 1;
40007700: c4 26 20 48 st %g2, [ %i0 + 0x48 ]
}
40007704: 81 c7 e0 08 ret
40007708: 91 e8 00 1d restore %g0, %i5, %o0
40009fbc <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
40009fbc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Heap_Block *current = heap->first_block;
40009fc0: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
<== NOT EXECUTED
Heap_Block *end = heap->last_block;
40009fc4: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
<== NOT EXECUTED
bool stop = false;
while ( !stop && current != end ) {
40009fc8: 80 a0 40 1c cmp %g1, %i4
<== NOT EXECUTED
40009fcc: 32 80 00 07 bne,a 40009fe8 <_Heap_Iterate+0x2c>
<== NOT EXECUTED
40009fd0: d2 00 60 04 ld [ %g1 + 4 ], %o1
40009fd4: 30 80 00 10 b,a 4000a014 <_Heap_Iterate+0x58>
<== NOT EXECUTED
40009fd8: 80 a7 00 1d cmp %i4, %i5
40009fdc: 02 80 00 0e be 4000a014 <_Heap_Iterate+0x58>
40009fe0: 01 00 00 00 nop
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40009fe4: d2 00 60 04 ld [ %g1 + 4 ], %o1
40009fe8: 92 0a 7f fe and %o1, -2, %o1
return (Heap_Block *) ((uintptr_t) block + offset);
40009fec: ba 00 40 09 add %g1, %o1, %i5
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40009ff0: d4 07 60 04 ld [ %i5 + 4 ], %o2
uintptr_t size = _Heap_Block_size( current );
Heap_Block *next = _Heap_Block_at( current, size );
bool used = _Heap_Is_prev_used( next );
stop = (*visitor)( current, size, used, visitor_arg );
40009ff4: 90 10 00 01 mov %g1, %o0
40009ff8: 96 10 00 1a mov %i2, %o3
40009ffc: 9f c6 40 00 call %i1
4000a000: 94 0a a0 01 and %o2, 1, %o2
while ( !stop && current != end ) {
4000a004: 90 1a 20 01 xor %o0, 1, %o0
4000a008: 80 8a 20 ff btst 0xff, %o0
4000a00c: 12 bf ff f3 bne 40009fd8 <_Heap_Iterate+0x1c>
<== ALWAYS TAKEN
4000a010: 82 10 00 1d mov %i5, %g1
current = next;
}
}
4000a014: 81 c7 e0 08 ret
4000a018: 81 e8 00 00 restore
4000a600 <_Heap_No_extend>:
uintptr_t unused_2 RTEMS_UNUSED,
uintptr_t unused_3 RTEMS_UNUSED
)
{
return 0;
}
4000a600: 81 c3 e0 08 retl
<== NOT EXECUTED
4000a604: 90 10 20 00 clr %o0
40018a28 <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
40018a28: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
return value - (value % alignment);
40018a2c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
<== NOT EXECUTED
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *const block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
*old_size = 0;
40018a30: c0 26 c0 00 clr [ %i3 ]
<== NOT EXECUTED
40018a34: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40018a38: 01 00 00 00 nop
<== NOT EXECUTED
40018a3c: 01 00 00 00 nop
<== NOT EXECUTED
40018a40: 01 00 00 00 nop
<== NOT EXECUTED
40018a44: 92 76 40 01 udiv %i1, %g1, %o1
<== NOT EXECUTED
*new_size = 0;
40018a48: c0 27 00 00 clr [ %i4 ]
<== NOT EXECUTED
40018a4c: 92 5a 40 01 smul %o1, %g1, %o1
<== NOT EXECUTED
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40018a50: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
<== NOT EXECUTED
{
40018a54: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
40018a58: 92 02 7f f8 add %o1, -8, %o1
<== NOT EXECUTED
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40018a5c: 80 a0 40 09 cmp %g1, %o1
<== NOT EXECUTED
40018a60: 18 80 00 3a bgu 40018b48 <_Heap_Resize_block+0x120>
<== NOT EXECUTED
40018a64: b0 10 20 02 mov 2, %i0
40018a68: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40018a6c: 80 a0 40 09 cmp %g1, %o1
40018a70: 0a 80 00 36 bcs 40018b48 <_Heap_Resize_block+0x120>
40018a74: 90 10 20 04 mov 4, %o0
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40018a78: c2 02 60 04 ld [ %o1 + 4 ], %g1
40018a7c: 82 08 7f fe and %g1, -2, %g1
uintptr_t block_end = block_begin + block_size;
40018a80: 86 02 40 01 add %o1, %g1, %g3
40018a84: c4 00 e0 04 ld [ %g3 + 4 ], %g2
40018a88: 84 08 bf fe and %g2, -2, %g2
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40018a8c: b0 00 c0 02 add %g3, %g2, %i0
40018a90: a0 22 00 19 sub %o0, %i1, %l0
40018a94: f0 06 20 04 ld [ %i0 + 4 ], %i0
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
40018a98: 88 00 c0 10 add %g3, %l0, %g4
if ( next_block_is_free ) {
40018a9c: 80 8e 20 01 btst 1, %i0
40018aa0: 12 80 00 27 bne 40018b3c <_Heap_Resize_block+0x114>
40018aa4: c8 26 c0 00 st %g4, [ %i3 ]
alloc_size += next_block_size;
40018aa8: 88 01 00 02 add %g4, %g2, %g4
if ( new_alloc_size > alloc_size ) {
40018aac: 80 a6 80 04 cmp %i2, %g4
40018ab0: 18 80 00 26 bgu 40018b48 <_Heap_Resize_block+0x120>
40018ab4: b0 10 20 01 mov 1, %i0
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
40018ab8: c8 02 60 04 ld [ %o1 + 4 ], %g4
40018abc: f6 00 e0 08 ld [ %g3 + 8 ], %i3
40018ac0: f0 00 e0 0c ld [ %g3 + 0xc ], %i0
block_size += next_block_size;
40018ac4: 82 00 40 02 add %g1, %g2, %g1
40018ac8: 86 09 20 01 and %g4, 1, %g3
block->size_and_flag = size | flag;
40018acc: 86 10 c0 01 or %g3, %g1, %g3
40018ad0: c6 22 60 04 st %g3, [ %o1 + 4 ]
return (Heap_Block *) ((uintptr_t) block + offset);
40018ad4: 82 02 40 01 add %o1, %g1, %g1
prev->next = next;
40018ad8: f6 26 20 08 st %i3, [ %i0 + 8 ]
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
40018adc: c8 00 60 04 ld [ %g1 + 4 ], %g4
next->prev = prev;
40018ae0: f0 26 e0 0c st %i0, [ %i3 + 0xc ]
40018ae4: 88 11 20 01 or %g4, 1, %g4
--stats->free_blocks;
40018ae8: c6 07 60 44 ld [ %i5 + 0x44 ], %g3
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
40018aec: c8 20 60 04 st %g4, [ %g1 + 4 ]
--stats->free_blocks;
40018af0: 86 00 ff ff add %g3, -1, %g3
stats->free_size -= next_block_size;
40018af4: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
40018af8: 84 20 40 02 sub %g1, %g2, %g2
--stats->free_blocks;
40018afc: c6 27 60 44 st %g3, [ %i5 + 0x44 ]
stats->free_size -= next_block_size;
40018b00: c4 27 60 3c st %g2, [ %i5 + 0x3c ]
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
40018b04: 96 10 00 1a mov %i2, %o3
40018b08: 94 10 00 19 mov %i1, %o2
40018b0c: 7f ff bb 00 call 4000770c <_Heap_Block_allocate>
40018b10: 90 10 00 1d mov %i5, %o0
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40018b14: c2 02 20 04 ld [ %o0 + 4 ], %g1
++stats->resizes;
40018b18: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
40018b1c: 82 08 7f fe and %g1, -2, %g1
*new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS;
40018b20: 90 02 00 10 add %o0, %l0, %o0
40018b24: 90 00 40 08 add %g1, %o0, %o0
40018b28: d0 27 00 00 st %o0, [ %i4 ]
++stats->resizes;
40018b2c: 82 00 a0 01 add %g2, 1, %g1
40018b30: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
return HEAP_RESIZE_SUCCESSFUL;
40018b34: 81 c7 e0 08 ret
40018b38: 91 e8 20 00 restore %g0, 0, %o0
if ( new_alloc_size > alloc_size ) {
40018b3c: 80 a6 80 04 cmp %i2, %g4
40018b40: 08 bf ff f1 bleu 40018b04 <_Heap_Resize_block+0xdc>
40018b44: b0 10 20 01 mov 1, %i0
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
}
40018b48: 81 c7 e0 08 ret
40018b4c: 81 e8 00 00 restore
400085c0 <_Heap_Size_of_alloc_area>:
return value - (value % alignment);
400085c0: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
<== NOT EXECUTED
return (uintptr_t) block >= (uintptr_t) heap->first_block
400085c4: c8 02 20 20 ld [ %o0 + 0x20 ], %g4
<== NOT EXECUTED
return value - (value % alignment);
400085c8: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
400085cc: 01 00 00 00 nop
<== NOT EXECUTED
400085d0: 01 00 00 00 nop
<== NOT EXECUTED
400085d4: 01 00 00 00 nop
<== NOT EXECUTED
400085d8: 82 72 40 02 udiv %o1, %g2, %g1
<== NOT EXECUTED
400085dc: 82 58 40 02 smul %g1, %g2, %g1
<== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
400085e0: 82 00 7f f8 add %g1, -8, %g1
<== NOT EXECUTED
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
400085e4: 80 a1 00 01 cmp %g4, %g1
<== NOT EXECUTED
400085e8: 18 80 00 15 bgu 4000863c <_Heap_Size_of_alloc_area+0x7c>
<== NOT EXECUTED
400085ec: 86 10 20 00 clr %g3
400085f0: da 02 20 24 ld [ %o0 + 0x24 ], %o5
400085f4: 80 a3 40 01 cmp %o5, %g1
400085f8: 0a 80 00 11 bcs 4000863c <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
400085fc: 01 00 00 00 nop
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40008600: c4 00 60 04 ld [ %g1 + 4 ], %g2
40008604: 84 08 bf fe and %g2, -2, %g2
return (Heap_Block *) ((uintptr_t) block + offset);
40008608: 82 00 80 01 add %g2, %g1, %g1
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000860c: 80 a1 00 01 cmp %g4, %g1
40008610: 18 80 00 0b bgu 4000863c <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
40008614: 80 a3 40 01 cmp %o5, %g1
40008618: 0a 80 00 09 bcs 4000863c <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
4000861c: 01 00 00 00 nop
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40008620: c4 00 60 04 ld [ %g1 + 4 ], %g2
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
40008624: 80 88 a0 01 btst 1, %g2
40008628: 02 80 00 05 be 4000863c <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
4000862c: 82 20 40 09 sub %g1, %o1, %g1
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
40008630: 82 00 60 04 add %g1, 4, %g1
40008634: c2 22 80 00 st %g1, [ %o2 ]
return true;
40008638: 86 10 20 01 mov 1, %g3
}
4000863c: 81 c3 e0 08 retl
40008640: 90 08 e0 ff and %g3, 0xff, %o0
4000777c <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
4000777c: 9d e3 bf 78 save %sp, -136, %sp
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
40007780: 80 a6 a0 00 cmp %i2, 0
40007784: 02 80 00 0b be 400077b0 <_Heap_Walk+0x34>
40007788: 03 10 00 54 sethi %hi(0x40015000), %g1
if ( !_System_state_Is_up( _System_state_Get() ) ) {
4000778c: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 ! 4001503c <_System_state_Current>
_Heap_Walk_print : _Heap_Walk_print_nothing;
40007790: 21 10 00 1d sethi %hi(0x40007400), %l0
if ( !_System_state_Is_up( _System_state_Get() ) ) {
40007794: 80 a0 60 02 cmp %g1, 2
40007798: 02 80 00 0b be 400077c4 <_Heap_Walk+0x48>
<== ALWAYS TAKEN
4000779c: a0 14 23 18 or %l0, 0x318, %l0
return true;
400077a0: b4 10 20 01 mov 1, %i2
400077a4: b0 0e a0 ff and %i2, 0xff, %i0
block = next_block;
} while ( block != first_block );
return true;
}
400077a8: 81 c7 e0 08 ret
400077ac: 81 e8 00 00 restore
if ( !_System_state_Is_up( _System_state_Get() ) ) {
400077b0: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
_Heap_Walk_print : _Heap_Walk_print_nothing;
400077b4: 21 10 00 1d sethi %hi(0x40007400), %l0
if ( !_System_state_Is_up( _System_state_Get() ) ) {
400077b8: 80 a0 60 02 cmp %g1, 2
400077bc: 12 bf ff f9 bne 400077a0 <_Heap_Walk+0x24>
400077c0: a0 14 23 10 or %l0, 0x310, %l0
Heap_Block *const first_block = heap->first_block;
400077c4: e4 06 20 20 ld [ %i0 + 0x20 ], %l2
Heap_Block *const last_block = heap->last_block;
400077c8: e2 06 20 24 ld [ %i0 + 0x24 ], %l1
(*printer)(
400077cc: c6 06 20 0c ld [ %i0 + 0xc ], %g3
400077d0: c4 06 20 08 ld [ %i0 + 8 ], %g2
400077d4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
400077d8: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
400077dc: 15 10 00 43 sethi %hi(0x40010c00), %o2
400077e0: c6 23 a0 6c st %g3, [ %sp + 0x6c ]
400077e4: 94 12 a2 60 or %o2, 0x260, %o2
400077e8: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
400077ec: 92 10 20 00 clr %o1
400077f0: e2 23 a0 64 st %l1, [ %sp + 0x64 ]
400077f4: 90 10 00 19 mov %i1, %o0
400077f8: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
uintptr_t const page_size = heap->page_size;
400077fc: ec 06 20 10 ld [ %i0 + 0x10 ], %l6
uintptr_t const min_block_size = heap->min_block_size;
40007800: e6 06 20 14 ld [ %i0 + 0x14 ], %l3
(*printer)(
40007804: da 06 20 18 ld [ %i0 + 0x18 ], %o5
40007808: 98 10 00 13 mov %l3, %o4
4000780c: 9f c4 00 00 call %l0
40007810: 96 10 00 16 mov %l6, %o3
if ( page_size == 0 ) {
40007814: 80 a5 a0 00 cmp %l6, 0
40007818: 12 80 00 0a bne 40007840 <_Heap_Walk+0xc4>
4000781c: 92 10 20 01 mov 1, %o1
(*printer)( source, true, "page size is zero\n" );
40007820: 90 10 00 19 mov %i1, %o0
return false;
40007824: b4 10 20 00 clr %i2
(*printer)( source, true, "page size is zero\n" );
40007828: 15 10 00 43 sethi %hi(0x40010c00), %o2
4000782c: b0 0e a0 ff and %i2, 0xff, %i0
40007830: 9f c4 00 00 call %l0
40007834: 94 12 a2 f8 or %o2, 0x2f8, %o2
}
40007838: 81 c7 e0 08 ret
4000783c: 81 e8 00 00 restore
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
40007840: 80 8d a0 07 btst 7, %l6
40007844: 02 80 00 0b be 40007870 <_Heap_Walk+0xf4>
40007848: 96 10 00 16 mov %l6, %o3
(*printer)(
4000784c: 92 10 20 01 mov 1, %o1
40007850: 15 10 00 43 sethi %hi(0x40010c00), %o2
40007854: 90 10 00 19 mov %i1, %o0
40007858: 94 12 a3 10 or %o2, 0x310, %o2
4000785c: 9f c4 00 00 call %l0
40007860: b4 10 20 00 clr %i2
40007864: b0 0e a0 ff and %i2, 0xff, %i0
40007868: 81 c7 e0 08 ret
4000786c: 81 e8 00 00 restore
return (value % alignment) == 0;
40007870: 81 80 20 00 wr %g0, %y
40007874: 01 00 00 00 nop
40007878: 01 00 00 00 nop
4000787c: 01 00 00 00 nop
40007880: 82 74 c0 16 udiv %l3, %l6, %g1
40007884: 82 58 40 16 smul %g1, %l6, %g1
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
40007888: 80 a4 c0 01 cmp %l3, %g1
4000788c: 02 80 00 0b be 400078b8 <_Heap_Walk+0x13c>
40007890: 96 10 00 13 mov %l3, %o3
(*printer)(
40007894: 92 10 20 01 mov 1, %o1
40007898: 15 10 00 43 sethi %hi(0x40010c00), %o2
4000789c: 90 10 00 19 mov %i1, %o0
400078a0: 94 12 a3 30 or %o2, 0x330, %o2
400078a4: 9f c4 00 00 call %l0
400078a8: b4 10 20 00 clr %i2
400078ac: b0 0e a0 ff and %i2, 0xff, %i0
400078b0: 81 c7 e0 08 ret
400078b4: 81 e8 00 00 restore
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
400078b8: 86 04 a0 08 add %l2, 8, %g3
return (value % alignment) == 0;
400078bc: 81 80 20 00 wr %g0, %y
400078c0: 01 00 00 00 nop
400078c4: 01 00 00 00 nop
400078c8: 01 00 00 00 nop
400078cc: 82 70 c0 16 udiv %g3, %l6, %g1
400078d0: 82 58 40 16 smul %g1, %l6, %g1
if (
400078d4: 80 a0 c0 01 cmp %g3, %g1
400078d8: 02 80 00 0b be 40007904 <_Heap_Walk+0x188>
400078dc: 96 10 00 12 mov %l2, %o3
(*printer)(
400078e0: 92 10 20 01 mov 1, %o1
400078e4: 15 10 00 43 sethi %hi(0x40010c00), %o2
400078e8: 90 10 00 19 mov %i1, %o0
400078ec: 94 12 a3 58 or %o2, 0x358, %o2
400078f0: 9f c4 00 00 call %l0
400078f4: b4 10 20 00 clr %i2
400078f8: b0 0e a0 ff and %i2, 0xff, %i0
400078fc: 81 c7 e0 08 ret
40007900: 81 e8 00 00 restore
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40007904: c2 04 a0 04 ld [ %l2 + 4 ], %g1
if ( !_Heap_Is_prev_used( first_block ) ) {
40007908: 80 88 60 01 btst 1, %g1
4000790c: 12 80 00 0a bne 40007934 <_Heap_Walk+0x1b8>
40007910: 92 10 20 01 mov 1, %o1
(*printer)(
40007914: 15 10 00 43 sethi %hi(0x40010c00), %o2
40007918: 90 10 00 19 mov %i1, %o0
4000791c: 94 12 a3 90 or %o2, 0x390, %o2
40007920: 9f c4 00 00 call %l0
40007924: b4 10 20 00 clr %i2
40007928: b0 0e a0 ff and %i2, 0xff, %i0
4000792c: 81 c7 e0 08 ret
40007930: 81 e8 00 00 restore
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40007934: c2 04 60 04 ld [ %l1 + 4 ], %g1
40007938: 82 08 7f fe and %g1, -2, %g1
return (Heap_Block *) ((uintptr_t) block + offset);
4000793c: 82 04 40 01 add %l1, %g1, %g1
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40007940: c6 00 60 04 ld [ %g1 + 4 ], %g3
if ( _Heap_Is_free( last_block ) ) {
40007944: 80 88 e0 01 btst 1, %g3
40007948: 12 80 00 09 bne 4000796c <_Heap_Walk+0x1f0>
4000794c: 15 10 00 43 sethi %hi(0x40010c00), %o2
(*printer)(
40007950: 90 10 00 19 mov %i1, %o0
40007954: 94 12 a3 c0 or %o2, 0x3c0, %o2
40007958: 9f c4 00 00 call %l0
4000795c: b4 10 20 00 clr %i2
40007960: b0 0e a0 ff and %i2, 0xff, %i0
40007964: 81 c7 e0 08 ret
40007968: 81 e8 00 00 restore
if (
4000796c: 80 a4 80 01 cmp %l2, %g1
40007970: 02 80 00 0a be 40007998 <_Heap_Walk+0x21c>
40007974: 92 10 20 01 mov 1, %o1
(*printer)(
40007978: 15 10 00 43 sethi %hi(0x40010c00), %o2
4000797c: 90 10 00 19 mov %i1, %o0
40007980: 94 12 a3 d8 or %o2, 0x3d8, %o2
40007984: 9f c4 00 00 call %l0
40007988: b4 10 20 00 clr %i2
4000798c: b0 0e a0 ff and %i2, 0xff, %i0
40007990: 81 c7 e0 08 ret
40007994: 81 e8 00 00 restore
uintptr_t const page_size = heap->page_size;
40007998: fa 06 20 10 ld [ %i0 + 0x10 ], %i5
return _Heap_Free_list_head(heap)->next;
4000799c: e8 06 20 08 ld [ %i0 + 8 ], %l4
400079a0: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
const Heap_Block *prev_block = free_list_tail;
400079a4: 88 10 00 18 mov %i0, %g4
while ( free_block != free_list_tail ) {
400079a8: 80 a6 00 14 cmp %i0, %l4
400079ac: 02 80 00 1f be 40007a28 <_Heap_Walk+0x2ac>
400079b0: 80 a5 00 03 cmp %l4, %g3
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
400079b4: 0a 80 00 f9 bcs 40007d98 <_Heap_Walk+0x61c>
400079b8: 96 10 00 14 mov %l4, %o3
400079bc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
400079c0: 80 a0 40 14 cmp %g1, %l4
400079c4: 0a 80 00 f6 bcs 40007d9c <_Heap_Walk+0x620>
<== NEVER TAKEN
400079c8: 92 10 20 01 mov 1, %o1
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
400079cc: b8 05 20 08 add %l4, 8, %i4
return (value % alignment) == 0;
400079d0: 81 80 20 00 wr %g0, %y
400079d4: 01 00 00 00 nop
400079d8: 01 00 00 00 nop
400079dc: 01 00 00 00 nop
400079e0: 82 77 00 1d udiv %i4, %i5, %g1
400079e4: 82 58 40 1d smul %g1, %i5, %g1
if (
400079e8: 80 a7 00 01 cmp %i4, %g1
400079ec: 12 80 00 e4 bne 40007d7c <_Heap_Walk+0x600>
400079f0: 15 10 00 44 sethi %hi(0x40011000), %o2
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
400079f4: c2 05 20 04 ld [ %l4 + 4 ], %g1
400079f8: 82 08 7f fe and %g1, -2, %g1
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
400079fc: 82 05 00 01 add %l4, %g1, %g1
40007a00: c2 00 60 04 ld [ %g1 + 4 ], %g1
if ( _Heap_Is_used( free_block ) ) {
40007a04: 80 88 60 01 btst 1, %g1
40007a08: 12 80 00 d6 bne 40007d60 <_Heap_Walk+0x5e4>
40007a0c: 15 10 00 44 sethi %hi(0x40011000), %o2
if ( free_block->prev != prev_block ) {
40007a10: d8 05 20 0c ld [ %l4 + 0xc ], %o4
40007a14: 80 a3 00 04 cmp %o4, %g4
40007a18: 12 80 00 c9 bne 40007d3c <_Heap_Walk+0x5c0>
40007a1c: 88 10 00 14 mov %l4, %g4
free_block = free_block->next;
40007a20: 10 bf ff e2 b 400079a8 <_Heap_Walk+0x22c>
40007a24: e8 05 20 08 ld [ %l4 + 8 ], %l4
(*printer)(
40007a28: 2f 10 00 43 sethi %hi(0x40010c00), %l7
40007a2c: 82 15 e2 40 or %l7, 0x240, %g1 ! 40010e40 <_Objects_Information_table+0x60>
40007a30: c2 27 bf fc st %g1, [ %fp + -4 ]
: (block->next == free_list_tail ? " (= tail)" : "")
40007a34: 03 10 00 43 sethi %hi(0x40010c00), %g1
40007a38: 82 10 62 50 or %g1, 0x250, %g1 ! 40010e50 <_Objects_Information_table+0x70>
40007a3c: c2 27 bf f4 st %g1, [ %fp + -12 ]
(*printer)(
40007a40: 03 10 00 43 sethi %hi(0x40010c00), %g1
40007a44: 82 10 62 20 or %g1, 0x220, %g1 ! 40010e20 <_Objects_Information_table+0x40>
40007a48: c2 27 bf f8 st %g1, [ %fp + -8 ]
: (block->prev == free_list_head ? " (= head)" : ""),
40007a4c: 03 10 00 43 sethi %hi(0x40010c00), %g1
40007a50: 82 10 62 30 or %g1, 0x230, %g1 ! 40010e30 <_Objects_Information_table+0x50>
40007a54: c2 27 bf f0 st %g1, [ %fp + -16 ]
: (block->next == free_list_tail ? " (= tail)" : "")
40007a58: 2b 10 00 44 sethi %hi(0x40011000), %l5
while ( free_block != free_list_tail ) {
40007a5c: ba 10 00 12 mov %l2, %i5
: (block->next == free_list_tail ? " (= tail)" : "")
40007a60: aa 15 61 98 or %l5, 0x198, %l5
40007a64: c2 07 60 04 ld [ %i5 + 4 ], %g1
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40007a68: b6 08 7f fe and %g1, -2, %i3
return (Heap_Block *) ((uintptr_t) block + offset);
40007a6c: b8 07 40 1b add %i5, %i3, %i4
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40007a70: 80 a0 c0 1c cmp %g3, %i4
40007a74: 18 80 00 06 bgu 40007a8c <_Heap_Walk+0x310>
<== NEVER TAKEN
40007a78: ae 08 60 01 and %g1, 1, %l7
40007a7c: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
40007a80: 80 a0 c0 1c cmp %g3, %i4
40007a84: 1a 80 00 0d bcc 40007ab8 <_Heap_Walk+0x33c>
40007a88: 01 00 00 00 nop
(*printer)(
40007a8c: 98 10 00 1c mov %i4, %o4
40007a90: 96 10 00 1d mov %i5, %o3
40007a94: 92 10 20 01 mov 1, %o1
40007a98: 90 10 00 19 mov %i1, %o0
return false;
40007a9c: b4 10 20 00 clr %i2
(*printer)(
40007aa0: 15 10 00 44 sethi %hi(0x40011000), %o2
40007aa4: b0 0e a0 ff and %i2, 0xff, %i0
40007aa8: 9f c4 00 00 call %l0
40007aac: 94 12 a2 30 or %o2, 0x230, %o2
}
40007ab0: 81 c7 e0 08 ret
40007ab4: 81 e8 00 00 restore
return (value % alignment) == 0;
40007ab8: 81 80 20 00 wr %g0, %y
40007abc: 01 00 00 00 nop
40007ac0: 01 00 00 00 nop
40007ac4: 01 00 00 00 nop
40007ac8: 86 76 c0 16 udiv %i3, %l6, %g3
40007acc: 86 58 c0 16 smul %g3, %l6, %g3
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
40007ad0: 80 a6 c0 03 cmp %i3, %g3
40007ad4: 02 80 00 17 be 40007b30 <_Heap_Walk+0x3b4>
40007ad8: 86 1f 40 11 xor %i5, %l1, %g3
40007adc: 80 a7 40 11 cmp %i5, %l1
40007ae0: 12 80 00 79 bne 40007cc4 <_Heap_Walk+0x548>
40007ae4: 98 10 00 1b mov %i3, %o4
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40007ae8: c6 07 20 04 ld [ %i4 + 4 ], %g3
if ( !_Heap_Is_prev_used( next_block ) ) {
40007aec: 80 88 e0 01 btst 1, %g3
40007af0: 02 80 00 30 be 40007bb0 <_Heap_Walk+0x434>
40007af4: 80 a5 e0 00 cmp %l7, 0
} else if (prev_used) {
40007af8: 22 80 00 25 be,a 40007b8c <_Heap_Walk+0x410>
40007afc: da 07 40 00 ld [ %i5 ], %o5
(*printer)(
40007b00: 15 10 00 44 sethi %hi(0x40011000), %o2
40007b04: 98 10 00 1b mov %i3, %o4
40007b08: 96 10 00 1d mov %i5, %o3
40007b0c: 94 12 a1 d0 or %o2, 0x1d0, %o2
40007b10: 92 10 20 00 clr %o1
40007b14: 9f c4 00 00 call %l0
40007b18: 90 10 00 19 mov %i1, %o0
} while ( block != first_block );
40007b1c: 80 a4 80 1c cmp %l2, %i4
40007b20: 02 bf ff 20 be 400077a0 <_Heap_Walk+0x24>
40007b24: ba 10 00 1c mov %i4, %i5
40007b28: 10 bf ff cf b 40007a64 <_Heap_Walk+0x2e8>
40007b2c: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
bool const is_not_last_block = block != last_block;
40007b30: 80 a0 00 03 cmp %g0, %g3
40007b34: 88 40 20 00 addx %g0, 0, %g4
if ( block_size < min_block_size && is_not_last_block ) {
40007b38: 80 a6 c0 13 cmp %i3, %l3
40007b3c: 86 40 20 00 addx %g0, 0, %g3
40007b40: 86 09 00 03 and %g4, %g3, %g3
40007b44: 80 a0 e0 00 cmp %g3, 0
40007b48: 12 80 00 53 bne 40007c94 <_Heap_Walk+0x518>
40007b4c: b4 10 00 03 mov %g3, %i2
if ( next_block_begin <= block_begin && is_not_last_block ) {
40007b50: 80 a7 40 1c cmp %i5, %i4
40007b54: 0a bf ff e5 bcs 40007ae8 <_Heap_Walk+0x36c>
40007b58: 80 a1 20 00 cmp %g4, 0
40007b5c: 22 bf ff e4 be,a 40007aec <_Heap_Walk+0x370>
40007b60: c6 07 20 04 ld [ %i4 + 4 ], %g3
(*printer)(
40007b64: 98 10 00 1c mov %i4, %o4
40007b68: 96 10 00 1d mov %i5, %o3
40007b6c: 15 10 00 44 sethi %hi(0x40011000), %o2
40007b70: 92 10 20 01 mov 1, %o1
40007b74: 94 12 a0 f0 or %o2, 0xf0, %o2
40007b78: 9f c4 00 00 call %l0
40007b7c: 90 10 00 19 mov %i1, %o0
40007b80: b0 0e a0 ff and %i2, 0xff, %i0
40007b84: 81 c7 e0 08 ret
40007b88: 81 e8 00 00 restore
(*printer)(
40007b8c: 98 10 00 1b mov %i3, %o4
40007b90: 96 10 00 1d mov %i5, %o3
40007b94: 15 10 00 44 sethi %hi(0x40011000), %o2
40007b98: 92 10 20 00 clr %o1
40007b9c: 94 12 a1 e8 or %o2, 0x1e8, %o2
40007ba0: 9f c4 00 00 call %l0
40007ba4: 90 10 00 19 mov %i1, %o0
} while ( block != first_block );
40007ba8: 10 bf ff de b 40007b20 <_Heap_Walk+0x3a4>
40007bac: 80 a4 80 1c cmp %l2, %i4
(*printer)(
40007bb0: da 07 60 0c ld [ %i5 + 0xc ], %o5
40007bb4: c6 06 20 08 ld [ %i0 + 8 ], %g3
return _Heap_Free_list_tail(heap)->prev;
40007bb8: de 06 20 0c ld [ %i0 + 0xc ], %o7
40007bbc: 80 a0 c0 0d cmp %g3, %o5
40007bc0: 02 80 00 05 be 40007bd4 <_Heap_Walk+0x458>
40007bc4: c8 07 bf f8 ld [ %fp + -8 ], %g4
: (block->prev == free_list_head ? " (= head)" : ""),
40007bc8: 80 a5 00 0d cmp %l4, %o5
40007bcc: 02 80 00 22 be 40007c54 <_Heap_Walk+0x4d8>
40007bd0: 88 10 00 15 mov %l5, %g4
(*printer)(
40007bd4: c6 07 60 08 ld [ %i5 + 8 ], %g3
40007bd8: 80 a3 c0 03 cmp %o7, %g3
40007bdc: 02 80 00 05 be 40007bf0 <_Heap_Walk+0x474>
40007be0: f4 07 bf fc ld [ %fp + -4 ], %i2
: (block->next == free_list_tail ? " (= tail)" : "")
40007be4: 80 a5 00 03 cmp %l4, %g3
40007be8: 02 80 00 1d be 40007c5c <_Heap_Walk+0x4e0>
40007bec: b4 10 00 15 mov %l5, %i2
(*printer)(
40007bf0: f4 23 a0 64 st %i2, [ %sp + 0x64 ]
40007bf4: 98 10 00 1b mov %i3, %o4
40007bf8: c6 23 a0 60 st %g3, [ %sp + 0x60 ]
40007bfc: 96 10 00 1d mov %i5, %o3
40007c00: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
40007c04: 92 10 20 00 clr %o1
40007c08: 15 10 00 44 sethi %hi(0x40011000), %o2
40007c0c: 90 10 00 19 mov %i1, %o0
40007c10: 9f c4 00 00 call %l0
40007c14: 94 12 a1 28 or %o2, 0x128, %o2
if ( block_size != next_block->prev_size ) {
40007c18: da 07 00 00 ld [ %i4 ], %o5
40007c1c: 80 a6 c0 0d cmp %i3, %o5
40007c20: 02 80 00 11 be 40007c64 <_Heap_Walk+0x4e8>
40007c24: 98 10 00 1b mov %i3, %o4
(*printer)(
40007c28: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
40007c2c: 96 10 00 1d mov %i5, %o3
40007c30: 92 10 20 01 mov 1, %o1
40007c34: 15 10 00 44 sethi %hi(0x40011000), %o2
40007c38: 90 10 00 19 mov %i1, %o0
40007c3c: 94 12 a1 60 or %o2, 0x160, %o2
40007c40: 9f c4 00 00 call %l0
40007c44: b4 10 20 00 clr %i2
40007c48: b0 0e a0 ff and %i2, 0xff, %i0
40007c4c: 81 c7 e0 08 ret
40007c50: 81 e8 00 00 restore
: (block->prev == free_list_head ? " (= head)" : ""),
40007c54: 10 bf ff e0 b 40007bd4 <_Heap_Walk+0x458>
40007c58: c8 07 bf f0 ld [ %fp + -16 ], %g4
: (block->next == free_list_tail ? " (= tail)" : "")
40007c5c: 10 bf ff e5 b 40007bf0 <_Heap_Walk+0x474>
40007c60: f4 07 bf f4 ld [ %fp + -12 ], %i2
if ( !prev_used ) {
40007c64: 80 a5 e0 00 cmp %l7, 0
40007c68: 12 80 00 21 bne 40007cec <_Heap_Walk+0x570>
40007c6c: 96 10 00 1d mov %i5, %o3
(*printer)(
40007c70: 92 10 20 01 mov 1, %o1
40007c74: 15 10 00 44 sethi %hi(0x40011000), %o2
40007c78: 90 10 00 19 mov %i1, %o0
40007c7c: 94 12 a1 a0 or %o2, 0x1a0, %o2
40007c80: 9f c4 00 00 call %l0
40007c84: b4 10 20 00 clr %i2
40007c88: b0 0e a0 ff and %i2, 0xff, %i0
40007c8c: 81 c7 e0 08 ret
40007c90: 81 e8 00 00 restore
(*printer)(
40007c94: 9a 10 00 13 mov %l3, %o5
40007c98: 98 10 00 1b mov %i3, %o4
40007c9c: 96 10 00 1d mov %i5, %o3
40007ca0: 92 10 20 01 mov 1, %o1
40007ca4: 15 10 00 44 sethi %hi(0x40011000), %o2
40007ca8: 90 10 00 19 mov %i1, %o0
40007cac: 94 12 a0 c0 or %o2, 0xc0, %o2
40007cb0: 9f c4 00 00 call %l0
40007cb4: b4 10 20 00 clr %i2
40007cb8: b0 0e a0 ff and %i2, 0xff, %i0
40007cbc: 81 c7 e0 08 ret
40007cc0: 81 e8 00 00 restore
(*printer)(
40007cc4: 96 10 00 1d mov %i5, %o3
40007cc8: 92 10 20 01 mov 1, %o1
40007ccc: 15 10 00 44 sethi %hi(0x40011000), %o2
40007cd0: 90 10 00 19 mov %i1, %o0
40007cd4: 94 12 a0 90 or %o2, 0x90, %o2
40007cd8: 9f c4 00 00 call %l0
40007cdc: b4 10 20 00 clr %i2
40007ce0: b0 0e a0 ff and %i2, 0xff, %i0
40007ce4: 81 c7 e0 08 ret
40007ce8: 81 e8 00 00 restore
return _Heap_Free_list_head(heap)->next;
40007cec: c2 06 20 08 ld [ %i0 + 8 ], %g1
while ( free_block != free_list_tail ) {
40007cf0: 80 a5 00 01 cmp %l4, %g1
40007cf4: 02 80 00 09 be 40007d18 <_Heap_Walk+0x59c>
<== NEVER TAKEN
40007cf8: 80 a7 40 01 cmp %i5, %g1
if ( free_block == block ) {
40007cfc: 02 bf ff 89 be 40007b20 <_Heap_Walk+0x3a4>
40007d00: 80 a4 80 1c cmp %l2, %i4
free_block = free_block->next;
40007d04: c2 00 60 08 ld [ %g1 + 8 ], %g1
while ( free_block != free_list_tail ) {
40007d08: 80 a5 00 01 cmp %l4, %g1
40007d0c: 12 bf ff fc bne 40007cfc <_Heap_Walk+0x580>
40007d10: 80 a7 40 01 cmp %i5, %g1
(*printer)(
40007d14: 96 10 00 1d mov %i5, %o3
40007d18: 92 10 20 01 mov 1, %o1
40007d1c: 15 10 00 44 sethi %hi(0x40011000), %o2
40007d20: 90 10 00 19 mov %i1, %o0
40007d24: 94 12 a2 60 or %o2, 0x260, %o2
40007d28: 9f c4 00 00 call %l0
40007d2c: b4 10 20 00 clr %i2
40007d30: b0 0e a0 ff and %i2, 0xff, %i0
40007d34: 81 c7 e0 08 ret
40007d38: 81 e8 00 00 restore
(*printer)(
40007d3c: 92 10 20 01 mov 1, %o1
40007d40: 15 10 00 44 sethi %hi(0x40011000), %o2
40007d44: 90 10 00 19 mov %i1, %o0
40007d48: 94 12 a0 58 or %o2, 0x58, %o2
40007d4c: 9f c4 00 00 call %l0
40007d50: b4 10 20 00 clr %i2
40007d54: b0 0e a0 ff and %i2, 0xff, %i0
40007d58: 81 c7 e0 08 ret
40007d5c: 81 e8 00 00 restore
(*printer)(
40007d60: 90 10 00 19 mov %i1, %o0
40007d64: 94 12 a0 38 or %o2, 0x38, %o2
40007d68: 9f c4 00 00 call %l0
40007d6c: b4 10 20 00 clr %i2
40007d70: b0 0e a0 ff and %i2, 0xff, %i0
40007d74: 81 c7 e0 08 ret
40007d78: 81 e8 00 00 restore
(*printer)(
40007d7c: 90 10 00 19 mov %i1, %o0
40007d80: 94 12 a0 08 or %o2, 8, %o2
40007d84: 9f c4 00 00 call %l0
40007d88: b4 10 20 00 clr %i2
40007d8c: b0 0e a0 ff and %i2, 0xff, %i0
40007d90: 81 c7 e0 08 ret
40007d94: 81 e8 00 00 restore
(*printer)(
40007d98: 92 10 20 01 mov 1, %o1
40007d9c: 15 10 00 44 sethi %hi(0x40011000), %o2
40007da0: 90 10 00 19 mov %i1, %o0
40007da4: 94 12 a2 10 or %o2, 0x210, %o2
40007da8: 9f c4 00 00 call %l0
40007dac: b4 10 20 00 clr %i2
40007db0: b0 0e a0 ff and %i2, 0xff, %i0
40007db4: 81 c7 e0 08 ret
40007db8: 81 e8 00 00 restore
4000710c <_IO_Printf>:
#endif
#include <rtems/score/io.h>
int _IO_Printf( IO_Put_char put_char, void *arg, char const *fmt, ... )
{
4000710c: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
va_list ap;
int len;
va_start( ap, fmt );
40007110: 82 07 a0 50 add %fp, 0x50, %g1
<== NOT EXECUTED
40007114: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
<== NOT EXECUTED
len = _IO_Vprintf( put_char, arg, fmt, ap );
40007118: 96 10 00 01 mov %g1, %o3
<== NOT EXECUTED
va_start( ap, fmt );
4000711c: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
<== NOT EXECUTED
len = _IO_Vprintf( put_char, arg, fmt, ap );
40007120: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
va_start( ap, fmt );
40007124: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
<== NOT EXECUTED
len = _IO_Vprintf( put_char, arg, fmt, ap );
40007128: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
va_start( ap, fmt );
4000712c: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
len = _IO_Vprintf( put_char, arg, fmt, ap );
40007130: 40 00 00 5c call 400072a0 <_IO_Vprintf>
<== NOT EXECUTED
40007134: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
va_end( ap );
return len;
}
40007138: 81 c7 e0 08 ret
4000713c: 91 e8 00 08 restore %g0, %o0, %o0
40007a18 <_IO_Vprintf>:
return (p);
}
int
_IO_Vprintf(IO_Put_char put_char, void *arg, char const *fmt, va_list ap)
{
40007a18: 9d e3 bf 50 save %sp, -176, %sp
char padc;
int stop = 0, retval = 0;
num = 0;
if (fmt == NULL)
40007a1c: 80 a6 a0 00 cmp %i2, 0
40007a20: 02 80 00 3e be 40007b18 <_IO_Vprintf+0x100>
<== NEVER TAKEN
40007a24: b8 10 00 18 mov %i0, %i4
}
percent = fmt - 1;
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
sign = 0; dot = 0; dwidth = 0; upper = 0;
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
reswitch: switch (ch = (u_char)*fmt++) {
40007a28: 31 10 00 1e sethi %hi(0x40007800), %i0
40007a2c: 03 10 00 66 sethi %hi(0x40019800), %g1
40007a30: a8 10 20 00 clr %l4
40007a34: a4 10 20 00 clr %l2
40007a38: b0 16 20 b8 or %i0, 0xb8, %i0
40007a3c: ae 10 60 f7 or %g1, 0xf7, %l7
while ((ch = (u_char)*fmt++) != '%' || stop) {
40007a40: c2 0e 80 00 ldub [ %i2 ], %g1
40007a44: a4 0c a0 01 and %l2, 1, %l2
40007a48: ba 06 a0 01 add %i2, 1, %i5
40007a4c: 90 10 00 01 mov %g1, %o0
40007a50: 80 a0 60 25 cmp %g1, 0x25
40007a54: 12 80 00 05 bne 40007a68 <_IO_Vprintf+0x50>
40007a58: a0 10 00 12 mov %l2, %l0
40007a5c: 80 a4 a0 00 cmp %l2, 0
40007a60: 22 80 00 16 be,a 40007ab8 <_IO_Vprintf+0xa0>
<== ALWAYS TAKEN
40007a64: 82 10 00 1d mov %i5, %g1
if (ch == '\0')
40007a68: 80 a0 60 00 cmp %g1, 0
40007a6c: 02 80 00 32 be 40007b34 <_IO_Vprintf+0x11c>
40007a70: b4 25 00 1a sub %l4, %i2, %i2
while ((ch = (u_char)*fmt++) != '%' || stop) {
40007a74: a0 0c 20 ff and %l0, 0xff, %l0
PCHAR(ch);
40007a78: 9f c7 00 00 call %i4
40007a7c: 92 10 00 19 mov %i1, %o1
while ((ch = (u_char)*fmt++) != '%' || stop) {
40007a80: 82 07 60 01 add %i5, 1, %g1
40007a84: d0 08 7f ff ldub [ %g1 + -1 ], %o0
40007a88: 80 a2 20 25 cmp %o0, 0x25
40007a8c: 12 80 00 05 bne 40007aa0 <_IO_Vprintf+0x88>
40007a90: aa 07 40 1a add %i5, %i2, %l5
40007a94: 80 a4 20 00 cmp %l0, 0
40007a98: 02 80 00 0b be 40007ac4 <_IO_Vprintf+0xac>
<== ALWAYS TAKEN
40007a9c: 84 10 20 20 mov 0x20, %g2
if (ch == '\0')
40007aa0: 80 a2 20 00 cmp %o0, 0
40007aa4: 12 bf ff f5 bne 40007a78 <_IO_Vprintf+0x60>
40007aa8: ba 10 00 01 mov %g1, %i5
40007aac: ac 10 00 15 mov %l5, %l6
stop = 1;
break;
}
}
#undef PCHAR
}
40007ab0: 81 c7 e0 08 ret
40007ab4: 91 e8 00 16 restore %g0, %l6, %o0
while ((ch = (u_char)*fmt++) != '%' || stop) {
40007ab8: aa 10 00 14 mov %l4, %l5
40007abc: ba 10 00 1a mov %i2, %i5
padc = ' ';
40007ac0: 84 10 20 20 mov 0x20, %g2
sign = 0; dot = 0; dwidth = 0; upper = 0;
40007ac4: c0 27 bf d0 clr [ %fp + -48 ]
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
40007ac8: a8 10 20 00 clr %l4
padc = ' ';
40007acc: c4 2f bf c3 stb %g2, [ %fp + -61 ]
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
40007ad0: 9e 10 20 00 clr %o7
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
40007ad4: c0 27 bf c4 clr [ %fp + -60 ]
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
40007ad8: 9a 10 20 00 clr %o5
width = 0;
40007adc: c0 27 bf d4 clr [ %fp + -44 ]
sign = 0; dot = 0; dwidth = 0; upper = 0;
40007ae0: 96 10 20 00 clr %o3
40007ae4: d8 08 40 00 ldub [ %g1 ], %o4
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
40007ae8: a4 10 20 00 clr %l2
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
40007aec: 88 10 20 00 clr %g4
reswitch: switch (ch = (u_char)*fmt++) {
40007af0: 84 03 3f dd add %o4, -35, %g2
40007af4: b4 00 60 01 add %g1, 1, %i2
40007af8: 84 08 a0 ff and %g2, 0xff, %g2
40007afc: 80 a0 a0 57 cmp %g2, 0x57
40007b00: 18 80 01 d9 bgu 40008264 <_IO_Vprintf+0x84c>
<== NEVER TAKEN
40007b04: 90 0b 20 ff and %o4, 0xff, %o0
40007b08: 85 28 a0 02 sll %g2, 2, %g2
40007b0c: c4 06 00 02 ld [ %i0 + %g2 ], %g2
40007b10: 81 c0 80 00 jmp %g2
40007b14: 01 00 00 00 nop
fmt = "(fmt null)\n";
40007b18: 35 10 00 66 sethi %hi(0x40019800), %i2
<== NOT EXECUTED
40007b1c: 10 bf ff c3 b 40007a28 <_IO_Vprintf+0x10>
<== NOT EXECUTED
40007b20: b4 16 a0 e0 or %i2, 0xe0, %i2 ! 400198e0 <_Objects_Information_table+0x20>
<== NOT EXECUTED
40007b24: d8 08 60 01 ldub [ %g1 + 1 ], %o4
zflag = 1;
40007b28: 88 10 20 01 mov 1, %g4
goto reswitch;
40007b2c: 10 bf ff f1 b 40007af0 <_IO_Vprintf+0xd8>
40007b30: 82 10 00 1a mov %i2, %g1
return (retval);
40007b34: 10 bf ff df b 40007ab0 <_IO_Vprintf+0x98>
40007b38: ac 10 00 14 mov %l4, %l6
if (!dot) {
40007b3c: 80 a2 e0 00 cmp %o3, 0
40007b40: 32 80 02 5b bne,a 400084ac <_IO_Vprintf+0xa94>
<== NEVER TAKEN
40007b44: c6 48 60 01 ldsb [ %g1 + 1 ], %g3
<== NOT EXECUTED
padc = '0';
40007b48: d8 2f bf c3 stb %o4, [ %fp + -61 ]
if (!dot) {
40007b4c: d8 08 60 01 ldub [ %g1 + 1 ], %o4
reswitch: switch (ch = (u_char)*fmt++) {
40007b50: 10 bf ff e8 b 40007af0 <_IO_Vprintf+0xd8>
40007b54: 82 10 00 1a mov %i2, %g1
40007b58: 84 10 20 00 clr %g2
40007b5c: 86 10 20 10 mov 0x10, %g3
base = 16;
40007b60: 82 10 20 10 mov 0x10, %g1
reswitch: switch (ch = (u_char)*fmt++) {
40007b64: c4 3f bf b0 std %g2, [ %fp + -80 ]
sign = 0; dot = 0; dwidth = 0; upper = 0;
40007b68: ba 10 20 00 clr %i5
base = 16;
40007b6c: c2 27 bf bc st %g1, [ %fp + -68 ]
if (jflag)
40007b70: 80 a5 20 00 cmp %l4, 0
40007b74: 02 80 01 dc be 400082e4 <_IO_Vprintf+0x8cc>
40007b78: 80 a1 20 00 cmp %g4, 0
num = va_arg(ap, uintmax_t);
40007b7c: 92 10 00 1b mov %i3, %o1
40007b80: 94 10 20 08 mov 8, %o2
40007b84: 40 00 1d 63 call 4000f110 <memcpy>
40007b88: 90 07 bf d8 add %fp, -40, %o0
40007b8c: c4 1f bf d8 ldd [ %fp + -40 ], %g2
40007b90: c4 3f bf c8 std %g2, [ %fp + -56 ]
40007b94: b6 06 e0 08 add %i3, 8, %i3
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
40007b98: a8 10 20 00 clr %l4
40007b9c: bb 2f 60 04 sll %i5, 4, %i5
*p = '\0';
40007ba0: c0 2f bf e8 clrb [ %fp + -24 ]
*++p = hex2ascii_data[upper][num % base];
40007ba4: a2 05 c0 1d add %l7, %i5, %l1
40007ba8: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40007bac: ac 10 00 1c mov %i4, %l6
*p = '\0';
40007bb0: c4 1f bf c8 ldd [ %fp + -56 ], %g2
*++p = hex2ascii_data[upper][num % base];
40007bb4: f8 1f bf b0 ldd [ %fp + -80 ], %i4
40007bb8: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
*p = '\0';
40007bbc: a6 10 00 02 mov %g2, %l3
p = nbuf;
40007bc0: a0 07 bf e8 add %fp, -24, %l0
*++p = hex2ascii_data[upper][num % base];
40007bc4: b6 10 00 03 mov %g3, %i3
40007bc8: 94 10 00 1c mov %i4, %o2
40007bcc: 96 10 00 1d mov %i5, %o3
40007bd0: 90 10 00 13 mov %l3, %o0
40007bd4: 40 00 41 48 call 400180f4 <__umoddi3>
40007bd8: 92 10 00 1b mov %i3, %o1
40007bdc: f4 0c 40 09 ldub [ %l1 + %o1 ], %i2
40007be0: a0 04 20 01 inc %l0
40007be4: f4 2c 00 00 stb %i2, [ %l0 ]
} while (num /= base);
40007be8: 90 10 00 13 mov %l3, %o0
40007bec: 92 10 00 1b mov %i3, %o1
40007bf0: 94 10 00 1c mov %i4, %o2
40007bf4: 40 00 40 c7 call 40017f10 <__udivdi3>
40007bf8: 96 10 00 1d mov %i5, %o3
40007bfc: a6 10 00 08 mov %o0, %l3
40007c00: 80 92 40 13 orcc %o1, %l3, %g0
40007c04: 12 bf ff f1 bne 40007bc8 <_IO_Vprintf+0x1b0>
40007c08: b6 10 00 09 mov %o1, %i3
if (sharpflag && num != 0) {
40007c0c: c4 1f bf c8 ldd [ %fp + -56 ], %g2
40007c10: 82 10 00 02 mov %g2, %g1
40007c14: c4 07 bf c4 ld [ %fp + -60 ], %g2
40007c18: 82 10 40 03 or %g1, %g3, %g1
40007c1c: 80 a0 00 01 cmp %g0, %g1
40007c20: 86 40 20 00 addx %g0, 0, %g3
40007c24: 84 88 c0 02 andcc %g3, %g2, %g2
40007c28: c4 27 bf c4 st %g2, [ %fp + -60 ]
*lenp = p - nbuf;
40007c2c: 82 07 bf e8 add %fp, -24, %g1
40007c30: ba 10 00 1a mov %i2, %i5
40007c34: a2 24 00 01 sub %l0, %g1, %l1
40007c38: b8 10 00 16 mov %l6, %i4
40007c3c: f4 07 a0 4c ld [ %fp + 0x4c ], %i2
40007c40: f6 07 a0 50 ld [ %fp + 0x50 ], %i3
if (sharpflag && num != 0) {
40007c44: 02 80 00 0a be 40007c6c <_IO_Vprintf+0x254>
40007c48: 82 10 20 00 clr %g1
if (base == 8)
40007c4c: c4 07 bf bc ld [ %fp + -68 ], %g2
40007c50: 80 a0 a0 08 cmp %g2, 8
40007c54: 02 80 00 06 be 40007c6c <_IO_Vprintf+0x254>
<== NEVER TAKEN
40007c58: 82 10 20 01 mov 1, %g1
tmp = 0;
40007c5c: 82 18 a0 10 xor %g2, 0x10, %g1
40007c60: 80 a0 00 01 cmp %g0, %g1
40007c64: 82 60 3f ff subx %g0, -1, %g1
40007c68: 83 28 60 01 sll %g1, 1, %g1
tmp++;
40007c6c: 80 a0 00 14 cmp %g0, %l4
40007c70: 82 40 00 01 addx %g0, %g1, %g1
if (!ladjust && padc == '0')
40007c74: 80 8c a0 01 btst 1, %l2
40007c78: 12 80 01 8d bne 400082ac <_IO_Vprintf+0x894>
40007c7c: c4 0f bf c3 ldub [ %fp + -61 ], %g2
40007c80: 87 28 a0 18 sll %g2, 0x18, %g3
40007c84: 87 38 e0 18 sra %g3, 0x18, %g3
40007c88: 80 a0 e0 30 cmp %g3, 0x30
40007c8c: 12 80 01 88 bne 400082ac <_IO_Vprintf+0x894>
40007c90: c4 07 bf d4 ld [ %fp + -44 ], %g2
dwidth = width - tmp;
40007c94: ac 20 80 01 sub %g2, %g1, %l6
static inline int imax(int a, int b) { return (a > b ? a : b); }
40007c98: 80 a5 80 11 cmp %l6, %l1
40007c9c: 16 80 00 04 bge 40007cac <_IO_Vprintf+0x294>
40007ca0: 86 10 00 16 mov %l6, %g3
40007ca4: 86 10 00 11 mov %l1, %g3
width -= tmp + imax(dwidth, n);
40007ca8: c4 07 bf d4 ld [ %fp + -44 ], %g2
40007cac: 82 00 c0 01 add %g3, %g1, %g1
dwidth -= n;
40007cb0: a2 25 80 11 sub %l6, %l1, %l1
width -= tmp + imax(dwidth, n);
40007cb4: a6 20 80 01 sub %g2, %g1, %l3
while (width-- > 0)
40007cb8: ac 04 ff ff add %l3, -1, %l6
40007cbc: 80 a4 e0 00 cmp %l3, 0
40007cc0: 04 80 00 0b ble 40007cec <_IO_Vprintf+0x2d4>
40007cc4: a6 10 00 16 mov %l6, %l3
PCHAR(' ');
40007cc8: 92 10 00 19 mov %i1, %o1
40007ccc: 9f c7 00 00 call %i4
40007cd0: 90 10 20 20 mov 0x20, %o0
while (width-- > 0)
40007cd4: a6 04 ff ff add %l3, -1, %l3
40007cd8: 80 a4 ff ff cmp %l3, -1
40007cdc: 12 bf ff fc bne 40007ccc <_IO_Vprintf+0x2b4>
40007ce0: 92 10 00 19 mov %i1, %o1
40007ce4: 84 05 60 01 add %l5, 1, %g2
40007ce8: aa 05 80 02 add %l6, %g2, %l5
if (neg)
40007cec: 80 a5 20 00 cmp %l4, 0
40007cf0: 02 80 01 8e be 40008328 <_IO_Vprintf+0x910>
40007cf4: 92 10 00 19 mov %i1, %o1
PCHAR('-');
40007cf8: 90 10 20 2d mov 0x2d, %o0
40007cfc: 9f c7 00 00 call %i4
40007d00: a8 05 60 01 add %l5, 1, %l4
if (sharpflag && num != 0) {
40007d04: c2 07 bf c4 ld [ %fp + -60 ], %g1
40007d08: 80 a0 60 00 cmp %g1, 0
40007d0c: 02 80 00 0a be 40007d34 <_IO_Vprintf+0x31c>
40007d10: 80 a4 60 00 cmp %l1, 0
if (base == 8) {
40007d14: c2 07 bf bc ld [ %fp + -68 ], %g1
40007d18: 80 a0 60 08 cmp %g1, 8
40007d1c: 12 80 01 92 bne 40008364 <_IO_Vprintf+0x94c>
<== ALWAYS TAKEN
40007d20: 92 10 00 19 mov %i1, %o1
PCHAR('0');
40007d24: 90 10 20 30 mov 0x30, %o0
<== NOT EXECUTED
40007d28: 9f c7 00 00 call %i4
<== NOT EXECUTED
40007d2c: a8 05 20 01 inc %l4
<== NOT EXECUTED
while (dwidth-- > 0)
40007d30: 80 a4 60 00 cmp %l1, 0
<== NOT EXECUTED
40007d34: 04 80 00 0c ble 40007d64 <_IO_Vprintf+0x34c>
40007d38: aa 04 7f ff add %l1, -1, %l5
40007d3c: a2 10 00 15 mov %l5, %l1
PCHAR('0');
40007d40: 92 10 00 19 mov %i1, %o1
40007d44: 9f c7 00 00 call %i4
40007d48: 90 10 20 30 mov 0x30, %o0
while (dwidth-- > 0)
40007d4c: a2 04 7f ff add %l1, -1, %l1
40007d50: 80 a4 7f ff cmp %l1, -1
40007d54: 12 bf ff fc bne 40007d44 <_IO_Vprintf+0x32c>
40007d58: 92 10 00 19 mov %i1, %o1
40007d5c: a8 05 20 01 inc %l4
40007d60: a8 05 00 15 add %l4, %l5, %l4
while (*p)
40007d64: bb 2f 60 18 sll %i5, 0x18, %i5
40007d68: 80 a7 60 00 cmp %i5, 0
40007d6c: 02 80 00 0c be 40007d9c <_IO_Vprintf+0x384>
<== NEVER TAKEN
40007d70: 80 a4 a0 00 cmp %l2, 0
PCHAR(*p--);
40007d74: 91 3f 60 18 sra %i5, 0x18, %o0
40007d78: a0 04 3f ff add %l0, -1, %l0
40007d7c: 9f c7 00 00 call %i4
40007d80: 92 10 00 19 mov %i1, %o1
while (*p)
40007d84: fa 0c 00 00 ldub [ %l0 ], %i5
40007d88: bb 2f 60 18 sll %i5, 0x18, %i5
40007d8c: 80 a7 60 00 cmp %i5, 0
40007d90: 12 bf ff f9 bne 40007d74 <_IO_Vprintf+0x35c>
40007d94: a8 05 20 01 inc %l4
if (ladjust)
40007d98: 80 a4 a0 00 cmp %l2, 0
40007d9c: 22 bf ff 2a be,a 40007a44 <_IO_Vprintf+0x2c>
40007da0: c2 0e 80 00 ldub [ %i2 ], %g1
while (width-- > 0)
40007da4: 80 a4 e0 00 cmp %l3, 0
40007da8: 04 80 01 59 ble 4000830c <_IO_Vprintf+0x8f4>
40007dac: a0 04 ff ff add %l3, -1, %l0
40007db0: ba 10 00 10 mov %l0, %i5
PCHAR(' ');
40007db4: 92 10 00 19 mov %i1, %o1
40007db8: 9f c7 00 00 call %i4
40007dbc: 90 10 20 20 mov 0x20, %o0
while (width-- > 0)
40007dc0: ba 07 7f ff add %i5, -1, %i5
40007dc4: 80 a7 7f ff cmp %i5, -1
40007dc8: 12 bf ff fc bne 40007db8 <_IO_Vprintf+0x3a0>
<== NEVER TAKEN
40007dcc: 92 10 00 19 mov %i1, %o1
40007dd0: a8 05 20 01 inc %l4
40007dd4: a4 10 20 00 clr %l2
40007dd8: 10 bf ff 1a b 40007a40 <_IO_Vprintf+0x28>
40007ddc: a8 04 00 14 add %l0, %l4, %l4
reswitch: switch (ch = (u_char)*fmt++) {
40007de0: 84 10 20 00 clr %g2
<== NOT EXECUTED
40007de4: 86 10 20 10 mov 0x10, %g3
<== NOT EXECUTED
base = 16;
40007de8: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
40007dec: c4 3f bf b0 std %g2, [ %fp + -80 ]
<== NOT EXECUTED
base = 16;
40007df0: c2 27 bf bc st %g1, [ %fp + -68 ]
<== NOT EXECUTED
if (jflag)
40007df4: 80 a5 20 00 cmp %l4, 0
40007df8: 02 80 01 4e be 40008330 <_IO_Vprintf+0x918>
40007dfc: 82 06 e0 04 add %i3, 4, %g1
num = va_arg(ap, intmax_t);
40007e00: 92 10 00 1b mov %i3, %o1
40007e04: 94 10 20 08 mov 8, %o2
40007e08: 40 00 1c c2 call 4000f110 <memcpy>
40007e0c: 90 07 bf e0 add %fp, -32, %o0
40007e10: c4 1f bf e0 ldd [ %fp + -32 ], %g2
40007e14: c4 3f bf c8 std %g2, [ %fp + -56 ]
40007e18: b6 06 e0 08 add %i3, 8, %i3
if (sign && (intmax_t)num < 0) {
40007e1c: c4 1f bf c8 ldd [ %fp + -56 ], %g2
40007e20: 82 90 a0 00 orcc %g2, 0, %g1
40007e24: 16 80 01 c8 bge 40008544 <_IO_Vprintf+0xb2c>
40007e28: 9a a0 00 03 subcc %g0, %g3, %o5
num = -(intmax_t)num;
40007e2c: ba 10 20 00 clr %i5
40007e30: 98 60 00 02 subx %g0, %g2, %o4
neg = 1;
40007e34: a8 10 20 01 mov 1, %l4
num = -(intmax_t)num;
40007e38: 10 bf ff 59 b 40007b9c <_IO_Vprintf+0x184>
40007e3c: d8 3f bf c8 std %o4, [ %fp + -56 ]
if (!ladjust && width > 0)
40007e40: c2 07 bf d4 ld [ %fp + -44 ], %g1
40007e44: 80 a0 60 01 cmp %g1, 1
40007e48: 14 80 00 03 bg 40007e54 <_IO_Vprintf+0x43c>
<== NEVER TAKEN
40007e4c: ba 10 20 01 mov 1, %i5
40007e50: ba 10 20 00 clr %i5
40007e54: a8 05 60 01 add %l5, 1, %l4
40007e58: 80 8c a0 01 btst 1, %l2
40007e5c: 12 80 01 52 bne 400083a4 <_IO_Vprintf+0x98c>
<== NEVER TAKEN
40007e60: a0 06 e0 04 add %i3, 4, %l0
40007e64: 80 8f 60 ff btst 0xff, %i5
40007e68: 02 80 01 4f be 400083a4 <_IO_Vprintf+0x98c>
<== ALWAYS TAKEN
40007e6c: c2 07 bf d4 ld [ %fp + -44 ], %g1
while (width--)
40007e70: a6 00 7f fe add %g1, -2, %l3
<== NOT EXECUTED
40007e74: c2 0f bf c3 ldub [ %fp + -61 ], %g1
<== NOT EXECUTED
40007e78: a3 28 60 18 sll %g1, 0x18, %l1
<== NOT EXECUTED
40007e7c: ba 10 00 13 mov %l3, %i5
<== NOT EXECUTED
40007e80: a3 3c 60 18 sra %l1, 0x18, %l1
<== NOT EXECUTED
PCHAR(padc);
40007e84: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40007e88: 9f c7 00 00 call %i4
<== NOT EXECUTED
40007e8c: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
while (width--)
40007e90: ba 07 7f ff add %i5, -1, %i5
<== NOT EXECUTED
40007e94: 80 a7 7f ff cmp %i5, -1
<== NOT EXECUTED
40007e98: 12 bf ff fc bne 40007e88 <_IO_Vprintf+0x470>
<== NOT EXECUTED
40007e9c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
PCHAR(va_arg(ap, int));
40007ea0: d0 06 c0 00 ld [ %i3 ], %o0
<== NOT EXECUTED
40007ea4: a6 05 00 13 add %l4, %l3, %l3
<== NOT EXECUTED
40007ea8: a8 04 e0 01 add %l3, 1, %l4
<== NOT EXECUTED
40007eac: 9f c7 00 00 call %i4
<== NOT EXECUTED
40007eb0: b6 10 00 10 mov %l0, %i3
<== NOT EXECUTED
40007eb4: 10 bf fe e3 b 40007a40 <_IO_Vprintf+0x28>
<== NOT EXECUTED
40007eb8: a4 10 20 00 clr %l2
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
40007ebc: 84 10 20 00 clr %g2
40007ec0: 86 10 20 0a mov 0xa, %g3
base = 10;
40007ec4: 82 10 20 0a mov 0xa, %g1
reswitch: switch (ch = (u_char)*fmt++) {
40007ec8: c4 3f bf b0 std %g2, [ %fp + -80 ]
base = 10;
40007ecc: 10 bf ff ca b 40007df4 <_IO_Vprintf+0x3dc>
40007ed0: c2 27 bf bc st %g1, [ %fp + -68 ]
if (hflag) {
40007ed4: 80 a3 e0 00 cmp %o7, 0
40007ed8: 12 80 01 55 bne 4000842c <_IO_Vprintf+0xa14>
40007edc: d8 08 60 01 ldub [ %g1 + 1 ], %o4
hflag = 1;
40007ee0: 9e 10 20 01 mov 1, %o7
reswitch: switch (ch = (u_char)*fmt++) {
40007ee4: 10 bf ff 03 b 40007af0 <_IO_Vprintf+0xd8>
40007ee8: 82 10 00 1a mov %i2, %g1
40007eec: d8 08 60 01 ldub [ %g1 + 1 ], %o4
jflag = 1;
40007ef0: a8 10 20 01 mov 1, %l4
goto reswitch;
40007ef4: 10 bf fe ff b 40007af0 <_IO_Vprintf+0xd8>
40007ef8: 82 10 00 1a mov %i2, %g1
reswitch: switch (ch = (u_char)*fmt++) {
40007efc: 84 10 20 00 clr %g2
40007f00: 86 10 20 10 mov 0x10, %g3
base = 16;
40007f04: 82 10 20 10 mov 0x10, %g1
reswitch: switch (ch = (u_char)*fmt++) {
40007f08: c4 3f bf b0 std %g2, [ %fp + -80 ]
upper = 1;
40007f0c: ba 10 20 01 mov 1, %i5
base = 16;
40007f10: 10 bf ff 18 b 40007b70 <_IO_Vprintf+0x158>
40007f14: c2 27 bf bc st %g1, [ %fp + -68 ]
reswitch: switch (ch = (u_char)*fmt++) {
40007f18: 84 10 20 00 clr %g2
40007f1c: 86 10 20 0a mov 0xa, %g3
base = 10;
40007f20: 82 10 20 0a mov 0xa, %g1
reswitch: switch (ch = (u_char)*fmt++) {
40007f24: c4 3f bf b0 std %g2, [ %fp + -80 ]
sign = 0; dot = 0; dwidth = 0; upper = 0;
40007f28: ba 10 20 00 clr %i5
base = 10;
40007f2c: 10 bf ff 11 b 40007b70 <_IO_Vprintf+0x158>
40007f30: c2 27 bf bc st %g1, [ %fp + -68 ]
40007f34: d8 08 60 01 ldub [ %g1 + 1 ], %o4
dot = 1;
40007f38: 96 10 20 01 mov 1, %o3
reswitch: switch (ch = (u_char)*fmt++) {
40007f3c: 10 bf fe ed b 40007af0 <_IO_Vprintf+0xd8>
40007f40: 82 10 00 1a mov %i2, %g1
ch = *fmt;
40007f44: c6 48 60 01 ldsb [ %g1 + 1 ], %g3
if (ch < '0' || ch > '9')
40007f48: 84 00 ff d0 add %g3, -48, %g2
n = n * 10 + ch - '0';
40007f4c: 90 02 3f d0 add %o0, -48, %o0
if (ch < '0' || ch > '9')
40007f50: 80 a0 a0 09 cmp %g2, 9
40007f54: 18 80 00 d4 bgu 400082a4 <_IO_Vprintf+0x88c>
40007f58: d8 08 60 01 ldub [ %g1 + 1 ], %o4
reswitch: switch (ch = (u_char)*fmt++) {
40007f5c: 82 10 00 1a mov %i2, %g1
for (n = 0;; ++fmt) {
40007f60: 82 00 60 01 inc %g1
n = n * 10 + ch - '0';
40007f64: 85 2a 20 02 sll %o0, 2, %g2
40007f68: 84 00 80 08 add %g2, %o0, %g2
40007f6c: 85 28 a0 01 sll %g2, 1, %g2
40007f70: 84 00 80 03 add %g2, %g3, %g2
ch = *fmt;
40007f74: c6 48 40 00 ldsb [ %g1 ], %g3
if (ch < '0' || ch > '9')
40007f78: b4 00 ff d0 add %g3, -48, %i2
n = n * 10 + ch - '0';
40007f7c: 90 00 bf d0 add %g2, -48, %o0
if (ch < '0' || ch > '9')
40007f80: 80 a6 a0 09 cmp %i2, 9
40007f84: 08 bf ff f7 bleu 40007f60 <_IO_Vprintf+0x548>
<== NEVER TAKEN
40007f88: d8 08 40 00 ldub [ %g1 ], %o4
if (dot)
40007f8c: 80 a2 e0 00 cmp %o3, 0
40007f90: 22 bf fe d8 be,a 40007af0 <_IO_Vprintf+0xd8>
40007f94: d0 27 bf d4 st %o0, [ %fp + -44 ]
40007f98: 10 bf fe d6 b 40007af0 <_IO_Vprintf+0xd8>
40007f9c: d0 27 bf d0 st %o0, [ %fp + -48 ]
if (!width)
40007fa0: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
up = va_arg(ap, u_char *);
40007fa4: e0 06 c0 00 ld [ %i3 ], %l0
<== NOT EXECUTED
p = va_arg(ap, char *);
40007fa8: e2 06 e0 04 ld [ %i3 + 4 ], %l1
<== NOT EXECUTED
if (!width)
40007fac: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40007fb0: 12 80 00 04 bne 40007fc0 <_IO_Vprintf+0x5a8>
<== NOT EXECUTED
40007fb4: b6 06 e0 08 add %i3, 8, %i3
<== NOT EXECUTED
width = 16;
40007fb8: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
40007fbc: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
40007fc0: 82 04 3f ff add %l0, -1, %g1
<== NOT EXECUTED
40007fc4: c4 07 bf d4 ld [ %fp + -44 ], %g2
<== NOT EXECUTED
for (q=p;*q;q++)
40007fc8: a8 10 00 15 mov %l5, %l4
<== NOT EXECUTED
40007fcc: a4 04 00 02 add %l0, %g2, %l2
<== NOT EXECUTED
40007fd0: a6 00 40 02 add %g1, %g2, %l3
<== NOT EXECUTED
while(width--) {
40007fd4: 80 a4 80 10 cmp %l2, %l0
<== NOT EXECUTED
40007fd8: 22 bf fe 9a be,a 40007a40 <_IO_Vprintf+0x28>
<== NOT EXECUTED
40007fdc: a4 10 20 00 clr %l2
<== NOT EXECUTED
PCHAR(hex2ascii(*up >> 4));
40007fe0: c2 0c 00 00 ldub [ %l0 ], %g1
<== NOT EXECUTED
40007fe4: 83 30 60 04 srl %g1, 4, %g1
<== NOT EXECUTED
40007fe8: d0 4d c0 01 ldsb [ %l7 + %g1 ], %o0
<== NOT EXECUTED
40007fec: 9f c7 00 00 call %i4
<== NOT EXECUTED
40007ff0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
PCHAR(hex2ascii(*up & 0x0f));
40007ff4: c2 0c 00 00 ldub [ %l0 ], %g1
<== NOT EXECUTED
40007ff8: 82 08 60 0f and %g1, 0xf, %g1
<== NOT EXECUTED
40007ffc: d0 4d c0 01 ldsb [ %l7 + %g1 ], %o0
<== NOT EXECUTED
40008000: 9f c7 00 00 call %i4
<== NOT EXECUTED
40008004: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
if (width)
40008008: 80 a4 c0 10 cmp %l3, %l0
<== NOT EXECUTED
4000800c: 02 80 00 c0 be 4000830c <_IO_Vprintf+0x8f4>
<== NOT EXECUTED
40008010: a8 05 20 02 add %l4, 2, %l4
<== NOT EXECUTED
for (q=p;*q;q++)
40008014: d0 0c 40 00 ldub [ %l1 ], %o0
<== NOT EXECUTED
40008018: 91 2a 20 18 sll %o0, 0x18, %o0
<== NOT EXECUTED
4000801c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40008020: 22 bf ff ed be,a 40007fd4 <_IO_Vprintf+0x5bc>
<== NOT EXECUTED
40008024: a0 04 20 01 inc %l0
<== NOT EXECUTED
40008028: ba 10 00 11 mov %l1, %i5
<== NOT EXECUTED
PCHAR(*q);
4000802c: 91 3a 20 18 sra %o0, 0x18, %o0
<== NOT EXECUTED
40008030: 9f c7 00 00 call %i4
<== NOT EXECUTED
40008034: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
for (q=p;*q;q++)
40008038: ba 07 60 01 inc %i5
<== NOT EXECUTED
4000803c: d0 0f 40 00 ldub [ %i5 ], %o0
<== NOT EXECUTED
40008040: 91 2a 20 18 sll %o0, 0x18, %o0
<== NOT EXECUTED
40008044: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40008048: 12 bf ff f9 bne 4000802c <_IO_Vprintf+0x614>
<== NOT EXECUTED
4000804c: a8 05 20 01 inc %l4
<== NOT EXECUTED
40008050: 10 bf ff e1 b 40007fd4 <_IO_Vprintf+0x5bc>
<== NOT EXECUTED
40008054: a0 04 20 01 inc %l0
<== NOT EXECUTED
if (lflag) {
40008058: 80 a1 20 00 cmp %g4, 0
4000805c: 02 bf fe b3 be 40007b28 <_IO_Vprintf+0x110>
40008060: d8 08 60 01 ldub [ %g1 + 1 ], %o4
jflag = 1;
40008064: a8 10 00 04 mov %g4, %l4
reswitch: switch (ch = (u_char)*fmt++) {
40008068: 10 bf fe a2 b 40007af0 <_IO_Vprintf+0xd8>
4000806c: 82 10 00 1a mov %i2, %g1
40008070: 84 10 20 00 clr %g2
40008074: 86 10 20 08 mov 8, %g3
base = 8;
40008078: 82 10 20 08 mov 8, %g1
reswitch: switch (ch = (u_char)*fmt++) {
4000807c: c4 3f bf b0 std %g2, [ %fp + -80 ]
sign = 0; dot = 0; dwidth = 0; upper = 0;
40008080: ba 10 20 00 clr %i5
base = 8;
40008084: 10 bf fe bb b 40007b70 <_IO_Vprintf+0x158>
40008088: c2 27 bf bc st %g1, [ %fp + -68 ]
sharpflag = (width == 0);
4000808c: c4 07 bf d4 ld [ %fp + -44 ], %g2
num = (uintptr_t)va_arg(ap, void *);
40008090: c2 06 c0 00 ld [ %i3 ], %g1
sharpflag = (width == 0);
40008094: 80 a0 00 02 cmp %g0, %g2
40008098: 84 60 3f ff subx %g0, -1, %g2
num = (uintptr_t)va_arg(ap, void *);
4000809c: 86 10 00 01 mov %g1, %g3
sharpflag = (width == 0);
400080a0: c4 27 bf c4 st %g2, [ %fp + -60 ]
num = (uintptr_t)va_arg(ap, void *);
400080a4: 84 10 20 00 clr %g2
base = 16;
400080a8: 82 10 20 10 mov 0x10, %g1
num = (uintptr_t)va_arg(ap, void *);
400080ac: c4 3f bf c8 std %g2, [ %fp + -56 ]
400080b0: b6 06 e0 04 add %i3, 4, %i3
goto number;
400080b4: 84 10 20 00 clr %g2
400080b8: 86 10 20 10 mov 0x10, %g3
sign = 0; dot = 0; dwidth = 0; upper = 0;
400080bc: ba 10 20 00 clr %i5
goto number;
400080c0: c4 3f bf b0 std %g2, [ %fp + -80 ]
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
400080c4: a8 10 20 00 clr %l4
goto number;
400080c8: 10 bf fe b5 b 40007b9c <_IO_Vprintf+0x184>
400080cc: c2 27 bf bc st %g1, [ %fp + -68 ]
p = va_arg(ap, char *);
400080d0: fa 06 c0 00 ld [ %i3 ], %i5
if (p == NULL)
400080d4: 80 a7 60 00 cmp %i5, 0
400080d8: 02 80 00 fd be 400084cc <_IO_Vprintf+0xab4>
400080dc: b6 06 e0 04 add %i3, 4, %i3
if (!dot)
400080e0: 80 a2 e0 00 cmp %o3, 0
400080e4: 12 80 00 db bne 40008450 <_IO_Vprintf+0xa38>
<== NEVER TAKEN
400080e8: c2 07 bf d0 ld [ %fp + -48 ], %g1
n = strlen (p);
400080ec: 40 00 1d 76 call 4000f6c4 <strlen>
400080f0: 90 10 00 1d mov %i5, %o0
400080f4: a2 10 00 08 mov %o0, %l1
width -= n;
400080f8: c2 07 bf d4 ld [ %fp + -44 ], %g1
400080fc: 84 20 40 11 sub %g1, %l1, %g2
40008100: c4 27 bf d4 st %g2, [ %fp + -44 ]
if (!ladjust && width > 0)
40008104: a1 38 a0 1f sra %g2, 0x1f, %l0
40008108: 82 0c a0 01 and %l2, 1, %g1
4000810c: a0 24 00 02 sub %l0, %g2, %l0
40008110: a8 04 7f ff add %l1, -1, %l4
40008114: 80 8c a0 01 btst 1, %l2
40008118: 12 80 00 c9 bne 4000843c <_IO_Vprintf+0xa24>
4000811c: a1 34 20 1f srl %l0, 0x1f, %l0
40008120: 80 a4 20 00 cmp %l0, 0
40008124: 02 80 00 c7 be 40008440 <_IO_Vprintf+0xa28>
40008128: 80 a4 60 00 cmp %l1, 0
while (width--)
4000812c: c2 07 bf d4 ld [ %fp + -44 ], %g1
40008130: a6 00 7f ff add %g1, -1, %l3
40008134: c2 0f bf c3 ldub [ %fp + -61 ], %g1
40008138: a5 28 60 18 sll %g1, 0x18, %l2
4000813c: a0 10 00 13 mov %l3, %l0
40008140: a5 3c a0 18 sra %l2, 0x18, %l2
PCHAR(padc);
40008144: 92 10 00 19 mov %i1, %o1
40008148: 9f c7 00 00 call %i4
4000814c: 90 10 00 12 mov %l2, %o0
while (width--)
40008150: a0 04 3f ff add %l0, -1, %l0
40008154: 80 a4 3f ff cmp %l0, -1
40008158: 12 bf ff fc bne 40008148 <_IO_Vprintf+0x730>
4000815c: 92 10 00 19 mov %i1, %o1
40008160: 84 05 60 01 add %l5, 1, %g2
while (n--)
40008164: 80 a4 60 00 cmp %l1, 0
40008168: 02 80 00 fa be 40008550 <_IO_Vprintf+0xb38>
<== NEVER TAKEN
4000816c: aa 00 80 13 add %g2, %l3, %l5
40008170: 82 10 3f ff mov -1, %g1
40008174: c2 27 bf d4 st %g1, [ %fp + -44 ]
40008178: a0 10 20 00 clr %l0
4000817c: a2 05 20 01 add %l4, 1, %l1
40008180: a2 07 40 11 add %i5, %l1, %l1
PCHAR(*p++);
40008184: ba 07 60 01 inc %i5
40008188: d0 4f 7f ff ldsb [ %i5 + -1 ], %o0
4000818c: 9f c7 00 00 call %i4
40008190: 92 10 00 19 mov %i1, %o1
while (n--)
40008194: 80 a7 40 11 cmp %i5, %l1
40008198: 32 bf ff fc bne,a 40008188 <_IO_Vprintf+0x770>
4000819c: ba 07 60 01 inc %i5
400081a0: 84 05 60 01 add %l5, 1, %g2
400081a4: a8 05 00 02 add %l4, %g2, %l4
if (ladjust && width > 0)
400081a8: 80 8c 20 ff btst 0xff, %l0
400081ac: 02 bf fe 25 be 40007a40 <_IO_Vprintf+0x28>
400081b0: a4 10 20 00 clr %l2
while (width--)
400081b4: c2 07 bf d4 ld [ %fp + -44 ], %g1
400081b8: 80 a0 60 00 cmp %g1, 0
400081bc: 02 bf fe 21 be 40007a40 <_IO_Vprintf+0x28>
<== NEVER TAKEN
400081c0: a2 00 7f ff add %g1, -1, %l1
400081c4: c2 0f bf c3 ldub [ %fp + -61 ], %g1
400081c8: a1 28 60 18 sll %g1, 0x18, %l0
400081cc: ba 10 00 11 mov %l1, %i5
400081d0: a1 3c 20 18 sra %l0, 0x18, %l0
PCHAR(padc);
400081d4: 92 10 00 19 mov %i1, %o1
400081d8: 9f c7 00 00 call %i4
400081dc: 90 10 00 10 mov %l0, %o0
while (width--)
400081e0: ba 07 7f ff add %i5, -1, %i5
400081e4: 80 a7 7f ff cmp %i5, -1
400081e8: 12 bf ff fc bne 400081d8 <_IO_Vprintf+0x7c0>
400081ec: 92 10 00 19 mov %i1, %o1
400081f0: a8 05 20 01 inc %l4
400081f4: a4 10 20 00 clr %l2
400081f8: 10 bf fe 12 b 40007a40 <_IO_Vprintf+0x28>
400081fc: a8 04 40 14 add %l1, %l4, %l4
40008200: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
sharpflag = 1;
40008204: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
40008208: c2 27 bf c4 st %g1, [ %fp + -60 ]
<== NOT EXECUTED
goto reswitch;
4000820c: 10 bf fe 39 b 40007af0 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
40008210: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
PCHAR(ch);
40008214: 92 10 00 19 mov %i1, %o1
40008218: 9f c7 00 00 call %i4
4000821c: a8 05 60 01 add %l5, 1, %l4
break;
40008220: 10 bf fe 08 b 40007a40 <_IO_Vprintf+0x28>
40008224: a4 10 20 00 clr %l2
40008228: 84 06 e0 04 add %i3, 4, %g2
<== NOT EXECUTED
if (!dot) {
4000822c: 80 a2 e0 00 cmp %o3, 0
<== NOT EXECUTED
40008230: 12 80 00 76 bne 40008408 <_IO_Vprintf+0x9f0>
<== NOT EXECUTED
40008234: c6 06 c0 00 ld [ %i3 ], %g3
<== NOT EXECUTED
if (width < 0) {
40008238: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
4000823c: 06 80 00 af bl 400084f8 <_IO_Vprintf+0xae0>
<== NOT EXECUTED
40008240: c6 27 bf d4 st %g3, [ %fp + -44 ]
<== NOT EXECUTED
40008244: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
dwidth = va_arg(ap, int);
40008248: b6 10 00 02 mov %g2, %i3
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
4000824c: 10 bf fe 29 b 40007af0 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
40008250: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
40008254: d8 08 60 01 ldub [ %g1 + 1 ], %o4
ladjust = 1;
40008258: a4 10 20 01 mov 1, %l2
goto reswitch;
4000825c: 10 bf fe 25 b 40007af0 <_IO_Vprintf+0xd8>
40008260: 82 10 00 1a mov %i2, %g1
while (percent < fmt)
40008264: a0 10 00 1d mov %i5, %l0
40008268: a8 10 00 15 mov %l5, %l4
4000826c: 80 a6 80 1d cmp %i2, %i5
40008270: 08 bf fd f4 bleu 40007a40 <_IO_Vprintf+0x28>
<== NEVER TAKEN
40008274: a4 10 20 01 mov 1, %l2
PCHAR(*percent++);
40008278: a0 04 20 01 inc %l0
4000827c: d0 4c 3f ff ldsb [ %l0 + -1 ], %o0
40008280: 9f c7 00 00 call %i4
40008284: 92 10 00 19 mov %i1, %o1
while (percent < fmt)
40008288: 80 a6 80 10 cmp %i2, %l0
4000828c: 32 bf ff fc bne,a 4000827c <_IO_Vprintf+0x864>
40008290: a0 04 20 01 inc %l0
40008294: 84 25 40 1d sub %l5, %i5, %g2
stop = 1;
40008298: a4 10 20 01 mov 1, %l2
4000829c: 10 bf fd e9 b 40007a40 <_IO_Vprintf+0x28>
400082a0: a8 06 80 02 add %i2, %g2, %l4
reswitch: switch (ch = (u_char)*fmt++) {
400082a4: 10 bf ff 3a b 40007f8c <_IO_Vprintf+0x574>
400082a8: 82 10 00 1a mov %i2, %g1
static inline int imax(int a, int b) { return (a > b ? a : b); }
400082ac: c4 07 bf d0 ld [ %fp + -48 ], %g2
400082b0: 80 a0 80 11 cmp %g2, %l1
400082b4: 16 80 00 04 bge 400082c4 <_IO_Vprintf+0x8ac>
400082b8: 86 10 00 02 mov %g2, %g3
400082bc: 86 10 00 11 mov %l1, %g3
dwidth -= n;
400082c0: c4 07 bf d0 ld [ %fp + -48 ], %g2
400082c4: a2 20 80 11 sub %g2, %l1, %l1
width -= tmp + imax(dwidth, n);
400082c8: c4 07 bf d4 ld [ %fp + -44 ], %g2
400082cc: 82 00 c0 01 add %g3, %g1, %g1
if (!ladjust)
400082d0: 80 a4 a0 00 cmp %l2, 0
400082d4: 12 bf fe 86 bne 40007cec <_IO_Vprintf+0x2d4>
400082d8: a6 20 80 01 sub %g2, %g1, %l3
while (width-- > 0)
400082dc: 10 bf fe 78 b 40007cbc <_IO_Vprintf+0x2a4>
400082e0: ac 04 ff ff add %l3, -1, %l6
else if (lflag)
400082e4: 12 80 00 0c bne 40008314 <_IO_Vprintf+0x8fc>
400082e8: 82 06 e0 04 add %i3, 4, %g1
else if (hflag)
400082ec: 80 a3 e0 00 cmp %o7, 0
400082f0: 02 80 00 48 be 40008410 <_IO_Vprintf+0x9f8>
<== ALWAYS TAKEN
400082f4: 80 a3 60 00 cmp %o5, 0
num = (u_short)va_arg(ap, int);
400082f8: c6 16 e0 02 lduh [ %i3 + 2 ], %g3
<== NOT EXECUTED
400082fc: 84 10 20 00 clr %g2
<== NOT EXECUTED
40008300: b6 10 00 01 mov %g1, %i3
<== NOT EXECUTED
40008304: 10 bf fe 26 b 40007b9c <_IO_Vprintf+0x184>
<== NOT EXECUTED
40008308: c4 3f bf c8 std %g2, [ %fp + -56 ]
<== NOT EXECUTED
while (width-- > 0)
4000830c: 10 bf fd cd b 40007a40 <_IO_Vprintf+0x28>
40008310: a4 10 20 00 clr %l2
num = va_arg(ap, u_int);
40008314: c6 06 c0 00 ld [ %i3 ], %g3
40008318: 84 10 20 00 clr %g2
4000831c: b6 10 00 01 mov %g1, %i3
40008320: 10 bf fe 1f b 40007b9c <_IO_Vprintf+0x184>
40008324: c4 3f bf c8 std %g2, [ %fp + -56 ]
40008328: 10 bf fe 77 b 40007d04 <_IO_Vprintf+0x2ec>
4000832c: a8 10 00 15 mov %l5, %l4
else if (tflag)
40008330: 80 a1 20 00 cmp %g4, 0
40008334: 12 80 00 17 bne 40008390 <_IO_Vprintf+0x978>
40008338: c6 06 c0 00 ld [ %i3 ], %g3
else if (hflag)
4000833c: 80 a3 e0 00 cmp %o7, 0
40008340: 02 80 00 66 be 400084d8 <_IO_Vprintf+0xac0>
<== ALWAYS TAKEN
40008344: 80 a3 60 00 cmp %o5, 0
num = (short)va_arg(ap, int);
40008348: 87 28 e0 10 sll %g3, 0x10, %g3
<== NOT EXECUTED
4000834c: b6 10 00 01 mov %g1, %i3
<== NOT EXECUTED
40008350: 83 38 e0 10 sra %g3, 0x10, %g1
<== NOT EXECUTED
40008354: c2 27 bf cc st %g1, [ %fp + -52 ]
<== NOT EXECUTED
40008358: 83 38 e0 1f sra %g3, 0x1f, %g1
<== NOT EXECUTED
4000835c: 10 bf fe b0 b 40007e1c <_IO_Vprintf+0x404>
<== NOT EXECUTED
40008360: c2 27 bf c8 st %g1, [ %fp + -56 ]
<== NOT EXECUTED
} else if (base == 16) {
40008364: 80 a0 60 10 cmp %g1, 0x10
40008368: 32 bf fe 73 bne,a 40007d34 <_IO_Vprintf+0x31c>
<== NEVER TAKEN
4000836c: 80 a4 60 00 cmp %l1, 0
<== NOT EXECUTED
PCHAR('0');
40008370: 9f c7 00 00 call %i4
40008374: 90 10 20 30 mov 0x30, %o0
PCHAR('x');
40008378: 92 10 00 19 mov %i1, %o1
4000837c: 90 10 20 78 mov 0x78, %o0
40008380: 9f c7 00 00 call %i4
40008384: a8 05 20 02 add %l4, 2, %l4
while (dwidth-- > 0)
40008388: 10 bf fe 6b b 40007d34 <_IO_Vprintf+0x31c>
4000838c: 80 a4 60 00 cmp %l1, 0
num = va_arg(ap, int);
40008390: b6 10 00 01 mov %g1, %i3
40008394: c6 27 bf cc st %g3, [ %fp + -52 ]
40008398: 83 38 e0 1f sra %g3, 0x1f, %g1
4000839c: 10 bf fe a0 b 40007e1c <_IO_Vprintf+0x404>
400083a0: c2 27 bf c8 st %g1, [ %fp + -56 ]
PCHAR(va_arg(ap, int));
400083a4: d0 06 c0 00 ld [ %i3 ], %o0
400083a8: 9f c7 00 00 call %i4
400083ac: 92 10 00 19 mov %i1, %o1
if (ladjust && width > 0)
400083b0: 80 8c a0 01 btst 1, %l2
400083b4: 02 80 00 3b be 400084a0 <_IO_Vprintf+0xa88>
<== ALWAYS TAKEN
400083b8: 80 8f 60 ff btst 0xff, %i5
400083bc: 02 80 00 39 be 400084a0 <_IO_Vprintf+0xa88>
<== NOT EXECUTED
400083c0: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
while (width--)
400083c4: a8 00 7f fe add %g1, -2, %l4
<== NOT EXECUTED
400083c8: c2 0f bf c3 ldub [ %fp + -61 ], %g1
<== NOT EXECUTED
400083cc: b7 28 60 18 sll %g1, 0x18, %i3
<== NOT EXECUTED
400083d0: ba 10 00 14 mov %l4, %i5
<== NOT EXECUTED
400083d4: b7 3e e0 18 sra %i3, 0x18, %i3
<== NOT EXECUTED
PCHAR(padc);
400083d8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400083dc: 9f c7 00 00 call %i4
<== NOT EXECUTED
400083e0: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
while (width--)
400083e4: ba 07 7f ff add %i5, -1, %i5
<== NOT EXECUTED
400083e8: 80 a7 7f ff cmp %i5, -1
<== NOT EXECUTED
400083ec: 12 bf ff fc bne 400083dc <_IO_Vprintf+0x9c4>
<== NOT EXECUTED
400083f0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400083f4: 84 05 60 02 add %l5, 2, %g2
<== NOT EXECUTED
PCHAR(va_arg(ap, int));
400083f8: b6 10 00 10 mov %l0, %i3
<== NOT EXECUTED
400083fc: a8 05 00 02 add %l4, %g2, %l4
<== NOT EXECUTED
while (width--)
40008400: 10 bf fd 90 b 40007a40 <_IO_Vprintf+0x28>
<== NOT EXECUTED
40008404: a4 10 20 00 clr %l2
<== NOT EXECUTED
dwidth = va_arg(ap, int);
40008408: 10 bf ff 8f b 40008244 <_IO_Vprintf+0x82c>
<== NOT EXECUTED
4000840c: c6 27 bf d0 st %g3, [ %fp + -48 ]
<== NOT EXECUTED
else if (cflag)
40008410: 22 bf ff c2 be,a 40008318 <_IO_Vprintf+0x900>
40008414: c6 06 c0 00 ld [ %i3 ], %g3
num = (u_char)va_arg(ap, int);
40008418: c6 0e e0 03 ldub [ %i3 + 3 ], %g3
4000841c: 84 10 20 00 clr %g2
40008420: b6 10 00 01 mov %g1, %i3
40008424: 10 bf fd de b 40007b9c <_IO_Vprintf+0x184>
40008428: c4 3f bf c8 std %g2, [ %fp + -56 ]
cflag = 1;
4000842c: 9a 10 00 0f mov %o7, %o5
reswitch: switch (ch = (u_char)*fmt++) {
40008430: 82 10 00 1a mov %i2, %g1
hflag = 0;
40008434: 10 bf fd af b 40007af0 <_IO_Vprintf+0xd8>
40008438: 9e 10 20 00 clr %o7
while (n--)
4000843c: 80 a4 60 00 cmp %l1, 0
40008440: 12 bf ff 4f bne 4000817c <_IO_Vprintf+0x764>
40008444: a0 0c 00 01 and %l0, %g1, %l0
40008448: 10 bf ff 58 b 400081a8 <_IO_Vprintf+0x790>
4000844c: a8 10 00 15 mov %l5, %l4
for (n = 0; n < dwidth && p[n]; n++)
40008450: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40008454: 04 80 00 06 ble 4000846c <_IO_Vprintf+0xa54>
<== NOT EXECUTED
40008458: c4 07 bf d4 ld [ %fp + -44 ], %g2
<== NOT EXECUTED
4000845c: c2 4f 40 00 ldsb [ %i5 ], %g1
<== NOT EXECUTED
40008460: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40008464: 12 80 00 2d bne 40008518 <_IO_Vprintf+0xb00>
<== NOT EXECUTED
40008468: a2 10 20 00 clr %l1
<== NOT EXECUTED
if (!ladjust && width > 0)
4000846c: a1 38 a0 1f sra %g2, 0x1f, %l0
<== NOT EXECUTED
40008470: 82 0c a0 01 and %l2, 1, %g1
<== NOT EXECUTED
40008474: a0 24 00 02 sub %l0, %g2, %l0
<== NOT EXECUTED
40008478: 80 8c a0 01 btst 1, %l2
<== NOT EXECUTED
4000847c: 12 80 00 06 bne 40008494 <_IO_Vprintf+0xa7c>
<== NOT EXECUTED
40008480: a1 34 20 1f srl %l0, 0x1f, %l0
<== NOT EXECUTED
40008484: a8 10 3f ff mov -1, %l4
<== NOT EXECUTED
40008488: 80 a4 20 00 cmp %l0, 0
<== NOT EXECUTED
4000848c: 12 bf ff 28 bne 4000812c <_IO_Vprintf+0x714>
<== NOT EXECUTED
40008490: a2 10 20 00 clr %l1
<== NOT EXECUTED
40008494: a0 0c 00 01 and %l0, %g1, %l0
<== NOT EXECUTED
40008498: 10 bf ff 44 b 400081a8 <_IO_Vprintf+0x790>
<== NOT EXECUTED
4000849c: a8 10 00 15 mov %l5, %l4
<== NOT EXECUTED
PCHAR(va_arg(ap, int));
400084a0: b6 10 00 10 mov %l0, %i3
400084a4: 10 bf fd 67 b 40007a40 <_IO_Vprintf+0x28>
400084a8: a4 10 20 00 clr %l2
if (ch < '0' || ch > '9')
400084ac: 84 00 ff d0 add %g3, -48, %g2
<== NOT EXECUTED
n = n * 10 + ch - '0';
400084b0: 90 02 3f d0 add %o0, -48, %o0
<== NOT EXECUTED
if (ch < '0' || ch > '9')
400084b4: 80 a0 a0 09 cmp %g2, 9
<== NOT EXECUTED
400084b8: 08 bf fe a9 bleu 40007f5c <_IO_Vprintf+0x544>
<== NOT EXECUTED
400084bc: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
n = n * 10 + ch - '0';
400084c0: d0 27 bf d0 st %o0, [ %fp + -48 ]
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
400084c4: 10 bf fd 8b b 40007af0 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
400084c8: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
p = "(null)";
400084cc: 3b 10 00 66 sethi %hi(0x40019800), %i5
400084d0: 10 bf ff 04 b 400080e0 <_IO_Vprintf+0x6c8>
400084d4: ba 17 60 f0 or %i5, 0xf0, %i5 ! 400198f0 <_Objects_Information_table+0x30>
else if (cflag)
400084d8: 02 bf ff af be 40008394 <_IO_Vprintf+0x97c>
<== ALWAYS TAKEN
400084dc: b6 10 00 01 mov %g1, %i3
num = (char)va_arg(ap, int);
400084e0: 87 28 e0 18 sll %g3, 0x18, %g3
<== NOT EXECUTED
400084e4: 83 38 e0 18 sra %g3, 0x18, %g1
<== NOT EXECUTED
400084e8: c2 27 bf cc st %g1, [ %fp + -52 ]
<== NOT EXECUTED
400084ec: 83 38 e0 1f sra %g3, 0x1f, %g1
<== NOT EXECUTED
400084f0: 10 bf fe 4b b 40007e1c <_IO_Vprintf+0x404>
<== NOT EXECUTED
400084f4: c2 27 bf c8 st %g1, [ %fp + -56 ]
<== NOT EXECUTED
400084f8: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
width = -width;
400084fc: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
40008500: 82 20 00 01 neg %g1
<== NOT EXECUTED
40008504: a4 1c a0 01 xor %l2, 1, %l2
<== NOT EXECUTED
40008508: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
width = va_arg(ap, int);
4000850c: b6 10 00 02 mov %g2, %i3
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
40008510: 10 bf fd 78 b 40007af0 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
40008514: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
for (n = 0; n < dwidth && p[n]; n++)
40008518: c2 07 bf d0 ld [ %fp + -48 ], %g1
<== NOT EXECUTED
4000851c: a2 04 60 01 inc %l1
<== NOT EXECUTED
40008520: 80 a4 40 01 cmp %l1, %g1
<== NOT EXECUTED
40008524: 02 bf fe f6 be 400080fc <_IO_Vprintf+0x6e4>
<== NOT EXECUTED
40008528: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
4000852c: c2 4f 40 11 ldsb [ %i5 + %l1 ], %g1
<== NOT EXECUTED
40008530: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40008534: 22 bf fe f2 be,a 400080fc <_IO_Vprintf+0x6e4>
<== NOT EXECUTED
40008538: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
4000853c: 10 bf ff f8 b 4000851c <_IO_Vprintf+0xb04>
<== NOT EXECUTED
40008540: c2 07 bf d0 ld [ %fp + -48 ], %g1
<== NOT EXECUTED
40008544: ba 10 20 00 clr %i5
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
40008548: 10 bf fd 95 b 40007b9c <_IO_Vprintf+0x184>
4000854c: a8 10 20 00 clr %l4
while (n--)
40008550: a8 10 00 15 mov %l5, %l4
<== NOT EXECUTED
40008554: 10 bf fd 3b b 40007a40 <_IO_Vprintf+0x28>
<== NOT EXECUTED
40008558: a4 10 20 00 clr %l2
<== NOT EXECUTED
4000856c <_ISR_Handler_initialization>:
#elif defined(CPU_INTERRUPT_MAXIMUM_VECTOR_NUMBER)
#error "CPU_INTERRUPT_MAXIMUM_VECTOR_NUMBER is defined for non-simple vectored interrupts"
#endif
void _ISR_Handler_initialization( void )
{
4000856c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
uint32_t cpu_max;
uint32_t cpu_index;
size_t stack_size;
char *stack_low;
_ISR_Nest_level = 0;
40008570: c0 21 a0 10 clr [ %g6 + 0x10 ]
*
* @return This method returns the minimum stack size;
*/
RTEMS_INLINE_ROUTINE uint32_t _Stack_Minimum (void)
{
return rtems_minimum_stack_size;
40008574: 03 10 00 6c sethi %hi(0x4001b000), %g1
_CPU_Initialize_vectors();
#endif
stack_size = rtems_configuration_get_interrupt_stack_size();
if ( !_Stack_Is_enough( stack_size ) )
40008578: c4 00 63 40 ld [ %g1 + 0x340 ], %g2 ! 4001b340 <_data_load_start>
stack_size = rtems_configuration_get_interrupt_stack_size();
4000857c: 03 00 00 04 sethi %hi(0x1000), %g1
40008580: 82 10 60 00 mov %g1, %g1 ! 1000 <_Configuration_Interrupt_stack_size>
if ( !_Stack_Is_enough( stack_size ) )
40008584: 80 a0 40 02 cmp %g1, %g2
40008588: 0a 80 00 0a bcs 400085b0 <_ISR_Handler_initialization+0x44> <== NEVER TAKEN
4000858c: 05 10 00 7e sethi %hi(0x4001f800), %g2
char *stack_high;
cpu = _Per_CPU_Get_by_index( cpu_index );
stack_high = _Addresses_Add_offset( stack_low, stack_size );
cpu->interrupt_stack_low = stack_low;
40008590: 07 10 00 68 sethi %hi(0x4001a000), %g3
40008594: 84 10 a1 40 or %g2, 0x140, %g2
40008598: 86 10 e3 40 or %g3, 0x340, %g3
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
4000859c: 82 00 40 03 add %g1, %g3, %g1
400085a0: c6 20 a0 08 st %g3, [ %g2 + 8 ]
cpu->interrupt_stack_high = stack_high;
400085a4: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
);
#endif
stack_low = stack_high;
}
}
400085a8: 81 c7 e0 08 ret
400085ac: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL );
400085b0: 7f ff fc bd call 400078a4 <_Internal_error>
<== NOT EXECUTED
400085b4: 90 10 20 04 mov 4, %o0
<== NOT EXECUTED
400085b8: 01 00 00 00 nop
<== NOT EXECUTED
4000855c <_ISR_Is_in_progress>:
#if defined( RTEMS_SMP )
_ISR_Local_enable( level );
#endif
return isr_nest_level != 0;
4000855c: c2 01 a0 10 ld [ %g6 + 0x10 ], %g1
<== NOT EXECUTED
}
40008560: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
40008564: 81 c3 e0 08 retl
<== NOT EXECUTED
40008568: 90 40 20 00 addx %g0, 0, %o0
400078a4 <_Internal_error>:
/* will not return from this routine */
while (true);
}
void _Internal_error( Internal_errors_Core_list core_error )
{
400078a4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_Terminate( INTERNAL_ERROR_CORE, core_error );
400078a8: 90 10 20 00 clr %o0
<== NOT EXECUTED
400078ac: 7f ff ff eb call 40007858 <_Terminate>
<== NOT EXECUTED
400078b0: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
400078b4: 01 00 00 00 nop
<== NOT EXECUTED
4000b96c <_Mutex_Acquire>:
);
}
}
void _Mutex_Acquire( struct _Mutex_Control *_mutex )
{
4000b96c: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b970: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000b974: 86 10 00 01 mov %g1, %g3
_Thread_queue_Context_ISR_disable( &queue_context, level );
executing = _Mutex_Queue_acquire_critical( mutex, &queue_context );
owner = mutex->Queue.Queue.owner;
if ( __predict_true( owner == NULL ) ) {
4000b978: c4 06 20 0c ld [ %i0 + 0xc ], %g2
4000b97c: 80 a0 a0 00 cmp %g2, 0
4000b980: 12 80 00 07 bne 4000b99c <_Mutex_Acquire+0x30>
4000b984: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
mutex->Queue.Queue.owner = executing;
4000b988: d4 26 20 0c st %o2, [ %i0 + 0xc ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b98c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b990: 01 00 00 00 nop
4000b994: 81 c7 e0 08 ret
4000b998: 81 e8 00 00 restore
RTEMS_INLINE_ROUTINE void
_Thread_queue_Context_set_enqueue_do_nothing_extra(
Thread_queue_Context *queue_context
)
{
queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;
4000b99c: 03 10 00 36 sethi %hi(0x4000d800), %g1
4000b9a0: 82 10 60 18 or %g1, 0x18, %g1 ! 4000d818 <_Thread_queue_Enqueue_do_nothing_extra>
4000b9a4: c2 27 bf e4 st %g1, [ %fp + -28 ]
queue_context->thread_state = thread_state;
4000b9a8: 82 10 20 01 mov 1, %g1
4000b9ac: c2 27 bf e0 st %g1, [ %fp + -32 ]
RTEMS_INLINE_ROUTINE void _Thread_queue_Context_set_deadlock_callout(
Thread_queue_Context *queue_context,
Thread_queue_Deadlock_callout deadlock_callout
)
{
queue_context->deadlock_callout = deadlock_callout;
4000b9b0: 03 10 00 36 sethi %hi(0x4000d800), %g1
4000b9b4: 82 10 60 20 or %g1, 0x20, %g1 ! 4000d820 <_Thread_queue_Deadlock_fatal>
_Thread_queue_Enqueue(
4000b9b8: 96 07 bf dc add %fp, -36, %o3
4000b9bc: c2 27 bf fc st %g1, [ %fp + -4 ]
4000b9c0: 13 10 00 8d sethi %hi(0x40023400), %o1
)
{
#if defined( RTEMS_SMP )
context->Lock_context.isr_level = level;
#else
context->isr_level = level;
4000b9c4: c6 27 bf dc st %g3, [ %fp + -36 ]
4000b9c8: 92 12 61 90 or %o1, 0x190, %o1
4000b9cc: 40 00 07 99 call 4000d830 <_Thread_queue_Enqueue>
4000b9d0: 90 06 20 08 add %i0, 8, %o0
_Mutex_Queue_release( mutex, level, &queue_context );
} else {
_Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context );
_Mutex_Acquire_slow( mutex, owner, executing, level, &queue_context );
}
}
4000b9d4: 81 c7 e0 08 ret
4000b9d8: 81 e8 00 00 restore
4000a25c <_Mutex_Acquire_timed>:
int _Mutex_Acquire_timed(
struct _Mutex_Control *_mutex,
const struct timespec *abstime
)
{
4000a25c: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000a260: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000a264: 86 10 00 01 mov %g1, %g3
_Thread_queue_Context_ISR_disable( &queue_context, level );
executing = _Mutex_Queue_acquire_critical( mutex, &queue_context );
owner = mutex->Queue.Queue.owner;
if ( __predict_true( owner == NULL ) ) {
4000a268: c4 06 20 0c ld [ %i0 + 0xc ], %g2
4000a26c: 80 a0 a0 00 cmp %g2, 0
4000a270: 12 80 00 07 bne 4000a28c <_Mutex_Acquire_timed+0x30>
4000a274: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
mutex->Queue.Queue.owner = executing;
4000a278: fa 26 20 0c st %i5, [ %i0 + 0xc ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a27c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000a280: 01 00 00 00 nop
_Thread_Resource_count_increment( executing );
_Mutex_Queue_release( mutex, level, &queue_context );
return 0;
4000a284: 81 c7 e0 08 ret
4000a288: 91 e8 20 00 restore %g0, 0, %o0
queue_context->thread_state = thread_state;
4000a28c: 82 10 20 01 mov 1, %g1
4000a290: c2 27 bf e0 st %g1, [ %fp + -32 ]
queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;
4000a294: 03 10 00 35 sethi %hi(0x4000d400), %g1
4000a298: 82 10 62 b0 or %g1, 0x2b0, %g1 ! 4000d6b0 <_Thread_queue_Add_timeout_realtime_timespec>
4000a29c: c2 27 bf e4 st %g1, [ %fp + -28 ]
queue_context->deadlock_callout = deadlock_callout;
4000a2a0: 03 10 00 31 sethi %hi(0x4000c400), %g1
4000a2a4: 82 10 62 b8 or %g1, 0x2b8, %g1 ! 4000c6b8 <_Thread_queue_Deadlock_fatal>
_Thread_queue_Enqueue(
4000a2a8: 90 06 20 08 add %i0, 8, %o0
queue_context->Timeout.arg = abstime;
4000a2ac: f2 27 bf e8 st %i1, [ %fp + -24 ]
4000a2b0: 96 07 bf dc add %fp, -36, %o3
4000a2b4: c6 27 bf dc st %g3, [ %fp + -36 ]
4000a2b8: 94 10 00 1d mov %i5, %o2
queue_context->deadlock_callout = deadlock_callout;
4000a2bc: c2 27 bf fc st %g1, [ %fp + -4 ]
4000a2c0: 13 10 00 49 sethi %hi(0x40012400), %o1
4000a2c4: 40 00 09 01 call 4000c6c8 <_Thread_queue_Enqueue>
4000a2c8: 92 12 62 e8 or %o1, 0x2e8, %o1 ! 400126e8 <_Thread_queue_Operations_priority_inherit>
&queue_context,
abstime
);
_Mutex_Acquire_slow( mutex, owner, executing, level, &queue_context );
return STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) );
4000a2cc: f0 07 60 4c ld [ %i5 + 0x4c ], %i0
4000a2d0: b1 3e 20 08 sra %i0, 8, %i0
}
}
4000a2d4: 81 c7 e0 08 ret
4000a2d8: 81 e8 00 00 restore
4000b9dc <_Mutex_Release>:
return eno;
}
void _Mutex_Release( struct _Mutex_Control *_mutex )
{
4000b9dc: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b9e0: 91 d0 20 09 ta 9
<== NOT EXECUTED
executing = _Thread_Executing;
4000b9e4: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
mutex->Queue.Queue.owner = NULL;
4000b9e8: c0 26 20 0c clr [ %i0 + 0xc ]
heads = mutex->Queue.Queue.heads;
4000b9ec: d2 06 20 08 ld [ %i0 + 8 ], %o1
if ( __predict_true( heads == NULL ) ) {
4000b9f0: 80 a2 60 00 cmp %o1, 0
4000b9f4: 32 80 00 06 bne,a 4000ba0c <_Mutex_Release+0x30>
4000b9f8: c2 27 bf dc st %g1, [ %fp + -36 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b9fc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ba00: 01 00 00 00 nop
4000ba04: 81 c7 e0 08 ret
4000ba08: 81 e8 00 00 restore
_Thread_queue_Surrender(
4000ba0c: 19 10 00 8d sethi %hi(0x40023400), %o4
4000ba10: 96 07 bf dc add %fp, -36, %o3
4000ba14: 98 13 21 90 or %o4, 0x190, %o4
4000ba18: 40 00 08 23 call 4000daa4 <_Thread_queue_Surrender>
4000ba1c: 90 06 20 08 add %i0, 8, %o0
executing = _Mutex_Queue_acquire_critical( mutex, &queue_context );
_Assert( mutex->Queue.Queue.owner == executing );
_Mutex_Release_critical( mutex, executing, level, &queue_context );
}
4000ba20: 81 c7 e0 08 ret
4000ba24: 81 e8 00 00 restore
4000a2dc <_Mutex_Try_acquire>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000a2dc: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Thread_queue_Context_ISR_disable( &queue_context, level );
executing = _Mutex_Queue_acquire_critical( mutex, &queue_context );
owner = mutex->Queue.Queue.owner;
if ( __predict_true( owner == NULL ) ) {
4000a2e0: c4 02 20 0c ld [ %o0 + 0xc ], %g2
4000a2e4: 80 a0 a0 00 cmp %g2, 0
4000a2e8: 12 80 00 08 bne 4000a308 <_Mutex_Try_acquire+0x2c>
4000a2ec: c6 01 a0 20 ld [ %g6 + 0x20 ], %g3
mutex->Queue.Queue.owner = executing;
4000a2f0: c6 22 20 0c st %g3, [ %o0 + 0xc ]
<== NOT EXECUTED
_Thread_Resource_count_increment( executing );
eno = 0;
4000a2f4: 90 10 20 00 clr %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a2f8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000a2fc: 01 00 00 00 nop
}
_Mutex_Queue_release( mutex, level, &queue_context );
return eno;
}
4000a300: 81 c3 e0 08 retl
4000a304: 01 00 00 00 nop
eno = EBUSY;
4000a308: 90 10 20 10 mov 0x10, %o0 ! 10 <_TLS_Alignment+0xf>
<== NOT EXECUTED
4000a30c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000a310: 01 00 00 00 nop
}
4000a314: 81 c3 e0 08 retl
4000a318: 01 00 00 00 nop
40008c70 <_Mutex_recursive_Acquire>:
{
return (Mutex_recursive_Control *) _mutex;
}
void _Mutex_recursive_Acquire( struct _Mutex_recursive_Control *_mutex )
{
40008c70: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008c74: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
40008c78: 86 10 00 01 mov %g1, %g3
mutex = _Mutex_recursive_Get( _mutex );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
executing = _Mutex_Queue_acquire_critical( &mutex->Mutex, &queue_context );
owner = mutex->Mutex.Queue.Queue.owner;
40008c7c: c4 06 20 0c ld [ %i0 + 0xc ], %g2
if ( __predict_true( owner == NULL ) ) {
40008c80: 80 a0 a0 00 cmp %g2, 0
40008c84: 12 80 00 07 bne 40008ca0 <_Mutex_recursive_Acquire+0x30>
40008c88: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
mutex->Mutex.Queue.Queue.owner = executing;
40008c8c: d4 26 20 0c st %o2, [ %i0 + 0xc ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008c90: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008c94: 01 00 00 00 nop
40008c98: 81 c7 e0 08 ret
40008c9c: 81 e8 00 00 restore
_Thread_Resource_count_increment( executing );
_Mutex_Queue_release( &mutex->Mutex, level, &queue_context );
} else if ( owner == executing ) {
40008ca0: 80 a2 80 02 cmp %o2, %g2
40008ca4: 02 80 00 11 be 40008ce8 <_Mutex_recursive_Acquire+0x78>
40008ca8: 96 07 bf dc add %fp, -36, %o3
RTEMS_INLINE_ROUTINE void
_Thread_queue_Context_set_enqueue_do_nothing_extra(
Thread_queue_Context *queue_context
)
{
queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;
40008cac: 03 10 00 2a sethi %hi(0x4000a800), %g1
40008cb0: 82 10 61 9c or %g1, 0x19c, %g1 ! 4000a99c <_Thread_queue_Enqueue_do_nothing_extra>
40008cb4: c2 27 bf e4 st %g1, [ %fp + -28 ]
queue_context->thread_state = thread_state;
40008cb8: 82 10 20 01 mov 1, %g1
40008cbc: c2 27 bf e0 st %g1, [ %fp + -32 ]
RTEMS_INLINE_ROUTINE void _Thread_queue_Context_set_deadlock_callout(
Thread_queue_Context *queue_context,
Thread_queue_Deadlock_callout deadlock_callout
)
{
queue_context->deadlock_callout = deadlock_callout;
40008cc0: 03 10 00 2a sethi %hi(0x4000a800), %g1
40008cc4: 82 10 61 a4 or %g1, 0x1a4, %g1 ! 4000a9a4 <_Thread_queue_Deadlock_fatal>
40008cc8: c2 27 bf fc st %g1, [ %fp + -4 ]
_Thread_queue_Enqueue(
40008ccc: 13 10 00 66 sethi %hi(0x40019800), %o1
)
{
#if defined( RTEMS_SMP )
context->Lock_context.isr_level = level;
#else
context->isr_level = level;
40008cd0: c6 27 bf dc st %g3, [ %fp + -36 ]
40008cd4: 92 12 61 28 or %o1, 0x128, %o1
40008cd8: 40 00 07 37 call 4000a9b4 <_Thread_queue_Enqueue>
40008cdc: 90 06 20 08 add %i0, 8, %o0
_Mutex_Queue_release( &mutex->Mutex, level, &queue_context );
} else {
_Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context );
_Mutex_Acquire_slow( &mutex->Mutex, owner, executing, level, &queue_context );
}
}
40008ce0: 81 c7 e0 08 ret
40008ce4: 81 e8 00 00 restore
++mutex->nest_level;
40008ce8: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
40008cec: 84 00 a0 01 inc %g2
<== NOT EXECUTED
40008cf0: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
<== NOT EXECUTED
40008cf4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008cf8: 01 00 00 00 nop
40008cfc: 81 c7 e0 08 ret
40008d00: 81 e8 00 00 restore
400097e8 <_Mutex_recursive_Acquire_timed>:
int _Mutex_recursive_Acquire_timed(
struct _Mutex_recursive_Control *_mutex,
const struct timespec *abstime
)
{
400097e8: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400097ec: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
400097f0: 86 10 00 01 mov %g1, %g3
mutex = _Mutex_recursive_Get( _mutex );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
executing = _Mutex_Queue_acquire_critical( &mutex->Mutex, &queue_context );
owner = mutex->Mutex.Queue.Queue.owner;
400097f4: c4 06 20 0c ld [ %i0 + 0xc ], %g2
if ( __predict_true( owner == NULL ) ) {
400097f8: 80 a0 a0 00 cmp %g2, 0
400097fc: 12 80 00 07 bne 40009818 <_Mutex_recursive_Acquire_timed+0x30>
40009800: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
mutex->Mutex.Queue.Queue.owner = executing;
40009804: fa 26 20 0c st %i5, [ %i0 + 0xc ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009808: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000980c: 01 00 00 00 nop
_Thread_Resource_count_increment( executing );
_Mutex_Queue_release( &mutex->Mutex, level, &queue_context );
return 0;
40009810: 81 c7 e0 08 ret
40009814: 91 e8 20 00 restore %g0, 0, %o0
} else if ( owner == executing ) {
40009818: 80 a0 80 1d cmp %g2, %i5
4000981c: 02 80 00 15 be 40009870 <_Mutex_recursive_Acquire_timed+0x88>
40009820: 90 06 20 08 add %i0, 8, %o0
queue_context->thread_state = thread_state;
40009824: 82 10 20 01 mov 1, %g1
40009828: c2 27 bf e0 st %g1, [ %fp + -32 ]
queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;
4000982c: 03 10 00 32 sethi %hi(0x4000c800), %g1
40009830: 82 10 60 10 or %g1, 0x10, %g1 ! 4000c810 <_Thread_queue_Add_timeout_realtime_timespec>
40009834: c2 27 bf e4 st %g1, [ %fp + -28 ]
queue_context->deadlock_callout = deadlock_callout;
40009838: 03 10 00 2e sethi %hi(0x4000b800), %g1
4000983c: 82 10 62 10 or %g1, 0x210, %g1 ! 4000ba10 <_Thread_queue_Deadlock_fatal>
queue_context->Timeout.arg = abstime;
40009840: f2 27 bf e8 st %i1, [ %fp + -24 ]
_Thread_queue_Enqueue(
40009844: 96 07 bf dc add %fp, -36, %o3
40009848: c6 27 bf dc st %g3, [ %fp + -36 ]
4000984c: 94 10 00 1d mov %i5, %o2
queue_context->deadlock_callout = deadlock_callout;
40009850: c2 27 bf fc st %g1, [ %fp + -4 ]
40009854: 13 10 00 4a sethi %hi(0x40012800), %o1
40009858: 40 00 08 72 call 4000ba20 <_Thread_queue_Enqueue>
4000985c: 92 12 62 ec or %o1, 0x2ec, %o1 ! 40012aec <_Thread_queue_Operations_priority_inherit>
&queue_context,
abstime
);
_Mutex_Acquire_slow( &mutex->Mutex, owner, executing, level, &queue_context );
return STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) );
40009860: f0 07 60 4c ld [ %i5 + 0x4c ], %i0
40009864: b1 3e 20 08 sra %i0, 8, %i0
}
}
40009868: 81 c7 e0 08 ret
4000986c: 81 e8 00 00 restore
++mutex->nest_level;
40009870: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
40009874: 84 00 a0 01 inc %g2
<== NOT EXECUTED
40009878: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
<== NOT EXECUTED
4000987c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009880: 01 00 00 00 nop
return 0;
40009884: 81 c7 e0 08 ret
40009888: 91 e8 20 00 restore %g0, 0, %o0
40008d04 <_Mutex_recursive_Release>:
return eno;
}
void _Mutex_recursive_Release( struct _Mutex_recursive_Control *_mutex )
{
40008d04: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008d08: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Thread_queue_Context_ISR_disable( &queue_context, level );
executing = _Mutex_Queue_acquire_critical( &mutex->Mutex, &queue_context );
_Assert( mutex->Mutex.Queue.Queue.owner == executing );
nest_level = mutex->nest_level;
40008d0c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
if ( __predict_true( nest_level == 0 ) ) {
40008d10: 80 a0 a0 00 cmp %g2, 0
40008d14: 12 80 00 0b bne 40008d40 <_Mutex_recursive_Release+0x3c>
40008d18: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
mutex->Queue.Queue.owner = NULL;
40008d1c: c0 26 20 0c clr [ %i0 + 0xc ]
heads = mutex->Queue.Queue.heads;
40008d20: d2 06 20 08 ld [ %i0 + 8 ], %o1
if ( __predict_true( heads == NULL ) ) {
40008d24: 80 a2 60 00 cmp %o1, 0
40008d28: 32 80 00 0c bne,a 40008d58 <_Mutex_recursive_Release+0x54>
40008d2c: c2 27 bf dc st %g1, [ %fp + -36 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008d30: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008d34: 01 00 00 00 nop
} else {
mutex->nest_level = nest_level - 1;
_Mutex_Queue_release( &mutex->Mutex, level, &queue_context );
}
}
40008d38: 81 c7 e0 08 ret
40008d3c: 81 e8 00 00 restore
mutex->nest_level = nest_level - 1;
40008d40: 84 00 bf ff add %g2, -1, %g2
<== NOT EXECUTED
40008d44: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
<== NOT EXECUTED
40008d48: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008d4c: 01 00 00 00 nop
}
40008d50: 81 c7 e0 08 ret
40008d54: 81 e8 00 00 restore
_Thread_queue_Surrender(
40008d58: 19 10 00 66 sethi %hi(0x40019800), %o4
40008d5c: 96 07 bf dc add %fp, -36, %o3
40008d60: 98 13 21 28 or %o4, 0x128, %o4
40008d64: 40 00 07 b1 call 4000ac28 <_Thread_queue_Surrender>
40008d68: 90 06 20 08 add %i0, 8, %o0
40008d6c: 81 c7 e0 08 ret
40008d70: 81 e8 00 00 restore
4000988c <_Mutex_recursive_Try_acquire>:
int _Mutex_recursive_Try_acquire( struct _Mutex_recursive_Control *_mutex )
{
4000988c: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40009890: 91 d0 20 09 ta 9
<== NOT EXECUTED
mutex = _Mutex_recursive_Get( _mutex );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
executing = _Mutex_Queue_acquire_critical( &mutex->Mutex, &queue_context );
owner = mutex->Mutex.Queue.Queue.owner;
40009894: c6 02 20 0c ld [ %o0 + 0xc ], %g3
if ( __predict_true( owner == NULL ) ) {
40009898: 80 a0 e0 00 cmp %g3, 0
4000989c: 12 80 00 08 bne 400098bc <_Mutex_recursive_Try_acquire+0x30>
400098a0: c8 01 a0 20 ld [ %g6 + 0x20 ], %g4
mutex->Mutex.Queue.Queue.owner = executing;
400098a4: c8 22 20 0c st %g4, [ %o0 + 0xc ]
<== NOT EXECUTED
_Thread_Resource_count_increment( executing );
eno = 0;
400098a8: 90 10 20 00 clr %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400098ac: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400098b0: 01 00 00 00 nop
}
_Mutex_Queue_release( &mutex->Mutex, level, &queue_context );
return eno;
}
400098b4: 81 c3 e0 08 retl
400098b8: 01 00 00 00 nop
} else if ( owner == executing ) {
400098bc: 80 a1 00 03 cmp %g4, %g3
400098c0: 12 bf ff fb bne 400098ac <_Mutex_recursive_Try_acquire+0x20>
400098c4: 90 10 20 10 mov 0x10, %o0
++mutex->nest_level;
400098c8: c6 00 a0 14 ld [ %g2 + 0x14 ], %g3
400098cc: 86 00 e0 01 inc %g3
eno = 0;
400098d0: 90 10 20 00 clr %o0
400098d4: 10 bf ff f6 b 400098ac <_Mutex_recursive_Try_acquire+0x20>
400098d8: c6 20 a0 14 st %g3, [ %g2 + 0x14 ]
4000eae0 <_Objects_API_maximum_class>:
#include <rtems/score/objectimpl.h>
unsigned int _Objects_API_maximum_class(
uint32_t api
)
{
4000eae0: 82 02 3f ff add %o0, -1, %g1
4000eae4: 80 a0 60 02 cmp %g1, 2
4000eae8: 18 80 00 06 bgu 4000eb00 <_Objects_API_maximum_class+0x20> <== NEVER TAKEN
4000eaec: 90 10 20 00 clr %o0
4000eaf0: 83 28 60 02 sll %g1, 2, %g1
4000eaf4: 05 10 00 67 sethi %hi(0x40019c00), %g2
4000eaf8: 84 10 a0 84 or %g2, 0x84, %g2 ! 40019c84 <CSWTCH.1>
4000eafc: d0 00 80 01 ld [ %g2 + %g1 ], %o0
case OBJECTS_NO_API:
default:
break;
}
return 0;
}
4000eb00: 81 c3 e0 08 retl
4000eb04: 01 00 00 00 nop
4000bb2c <_Objects_Active_count>:
#include <rtems/score/chainimpl.h>
Objects_Maximum _Objects_Active_count(
const Objects_Information *information
)
{
4000bb2c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
size_t inactive;
size_t maximum;
_Assert( _Objects_Allocator_is_owner() );
inactive = _Chain_Node_count_unprotected( &information->Inactive );
4000bb30: 7f ff f8 20 call 40009bb0 <_Chain_Node_count_unprotected>
<== NOT EXECUTED
4000bb34: 90 06 20 20 add %i0, 0x20, %o0
<== NOT EXECUTED
maximum = information->maximum;
return (Objects_Maximum) ( maximum - inactive );
4000bb38: f0 16 20 10 lduh [ %i0 + 0x10 ], %i0
4000bb3c: b0 26 00 08 sub %i0, %o0, %i0
4000bb40: b1 2e 20 10 sll %i0, 0x10, %i0
}
4000bb44: b1 36 20 10 srl %i0, 0x10, %i0
4000bb48: 81 c7 e0 08 ret
4000bb4c: 81 e8 00 00 restore
40008e4c <_Objects_Allocate>:
Objects_Control *_Objects_Allocate( Objects_Information *information )
{
40008e4c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_RTEMS_Lock_allocator();
40008e50: 7f ff f8 83 call 4000705c <_RTEMS_Lock_allocator>
<== NOT EXECUTED
40008e54: 01 00 00 00 nop
<== NOT EXECUTED
return _Objects_Allocate_unprotected( information );
40008e58: 7f ff ff c7 call 40008d74 <_Objects_Allocate_unprotected>
40008e5c: 81 e8 00 00 restore
40008d74 <_Objects_Allocate_unprotected>:
}
Objects_Control *_Objects_Allocate_unprotected(
Objects_Information *information
)
{
40008d74: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
* If the application is using the optional manager stubs and
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
40008d78: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
40008d7c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40008d80: 02 80 00 31 be 40008e44 <_Objects_Allocate_unprotected+0xd0>
<== NOT EXECUTED
40008d84: ba 10 00 18 mov %i0, %i5
return _Chain_Immutable_head( the_chain )->next;
40008d88: f0 06 20 20 ld [ %i0 + 0x20 ], %i0
return &the_chain->Tail.Node;
40008d8c: b8 07 60 24 add %i5, 0x24, %i4
40008d90: b6 07 60 20 add %i5, 0x20, %i3
if ( !_Chain_Is_empty(the_chain))
40008d94: 80 a7 00 18 cmp %i4, %i0
40008d98: 02 80 00 1e be 40008e10 <_Objects_Allocate_unprotected+0x9c>
40008d9c: c4 0f 60 12 ldub [ %i5 + 0x12 ], %g2
new_first = old_first->next;
40008da0: c2 06 00 00 ld [ %i0 ], %g1
head->next = new_first;
40008da4: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
* OK. The manager should be initialized and configured to have objects.
* With any luck, it is safe to attempt to allocate an object.
*/
the_object = _Objects_Get_inactive( information );
if ( information->auto_extend ) {
40008da8: 80 88 a0 ff btst 0xff, %g2
40008dac: 02 80 00 17 be 40008e08 <_Objects_Allocate_unprotected+0x94>
40008db0: f6 20 60 04 st %i3, [ %g1 + 4 ]
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
40008db4: c2 06 20 08 ld [ %i0 + 8 ], %g1
40008db8: c6 07 60 08 ld [ %i5 + 8 ], %g3
40008dbc: 05 00 00 3f sethi %hi(0xfc00), %g2
40008dc0: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <_Configuration_Interrupt_stack_size+0xefff>
40008dc4: 82 08 40 02 and %g1, %g2, %g1
40008dc8: 84 08 c0 02 and %g3, %g2, %g2
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
40008dcc: c8 07 60 30 ld [ %i5 + 0x30 ], %g4
block = (uint32_t) _Objects_Get_index( the_object->id ) -
40008dd0: 82 20 40 02 sub %g1, %g2, %g1
block /= information->allocation_size;
40008dd4: c4 17 60 14 lduh [ %i5 + 0x14 ], %g2
40008dd8: 81 80 20 00 wr %g0, %y
40008ddc: 01 00 00 00 nop
40008de0: 01 00 00 00 nop
40008de4: 01 00 00 00 nop
40008de8: 84 70 40 02 udiv %g1, %g2, %g2
information->inactive_per_block[ block ]--;
40008dec: 83 28 a0 02 sll %g2, 2, %g1
40008df0: c6 01 00 01 ld [ %g4 + %g1 ], %g3
information->inactive--;
40008df4: c4 17 60 2c lduh [ %i5 + 0x2c ], %g2
information->inactive_per_block[ block ]--;
40008df8: 86 00 ff ff add %g3, -1, %g3
40008dfc: c6 21 00 01 st %g3, [ %g4 + %g1 ]
information->inactive--;
40008e00: 82 00 bf ff add %g2, -1, %g1
40008e04: c2 37 60 2c sth %g1, [ %i5 + 0x2c ]
);
}
#endif
return the_object;
}
40008e08: 81 c7 e0 08 ret
40008e0c: 81 e8 00 00 restore
if ( information->auto_extend ) {
40008e10: 80 88 a0 ff btst 0xff, %g2
40008e14: 02 80 00 0c be 40008e44 <_Objects_Allocate_unprotected+0xd0>
40008e18: 01 00 00 00 nop
_Objects_Extend_information( information );
40008e1c: 40 00 00 11 call 40008e60 <_Objects_Extend_information>
40008e20: 90 10 00 1d mov %i5, %o0
return _Chain_Immutable_head( the_chain )->next;
40008e24: f0 07 60 20 ld [ %i5 + 0x20 ], %i0
if ( !_Chain_Is_empty(the_chain))
40008e28: 80 a7 00 18 cmp %i4, %i0
40008e2c: 02 80 00 06 be 40008e44 <_Objects_Allocate_unprotected+0xd0>
40008e30: 01 00 00 00 nop
new_first = old_first->next;
40008e34: c2 06 00 00 ld [ %i0 ], %g1
head->next = new_first;
40008e38: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
new_first->previous = head;
40008e3c: 10 bf ff de b 40008db4 <_Objects_Allocate_unprotected+0x40>
40008e40: f6 20 60 04 st %i3, [ %g1 + 4 ]
return NULL;
40008e44: 81 c7 e0 08 ret
40008e48: 91 e8 20 00 restore %g0, 0, %o0
4000ded4 <_Objects_Close>:
information->local_table[ index ] = the_object;
4000ded4: c2 12 60 0a lduh [ %o1 + 0xa ], %g1
<== NOT EXECUTED
4000ded8: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
<== NOT EXECUTED
4000dedc: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
4000dee0: c0 20 80 01 clr [ %g2 + %g1 ]
<== NOT EXECUTED
Objects_Control *the_object
)
{
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove( information, the_object );
4000dee4: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000dee8: 40 00 00 69 call 4000e08c <_Objects_Namespace_remove>
<== NOT EXECUTED
4000deec: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
400091a8 <_Objects_Do_initialize_information>:
#if defined(RTEMS_MULTIPROCESSING)
,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
400091a8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
information->maximum = 0;
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
400091ac: 05 10 00 66 sethi %hi(0x40019800), %g2
information->size = size;
400091b0: f8 26 20 18 st %i4, [ %i0 + 0x18 ]
_Objects_Information_table[ the_api ][ the_class ] = information;
400091b4: 84 10 a0 c0 or %g2, 0xc0, %g2
information->the_api = the_api;
400091b8: f2 26 00 00 st %i1, [ %i0 ]
_Objects_Information_table[ the_api ][ the_class ] = information;
400091bc: b9 2e 60 02 sll %i1, 2, %i4
information->the_class = the_class;
400091c0: f4 36 20 04 sth %i2, [ %i0 + 4 ]
_Objects_Information_table[ the_api ][ the_class ] = information;
400091c4: 89 2e a0 02 sll %i2, 2, %g4
information->local_table = 0;
400091c8: c0 26 20 1c clr [ %i0 + 0x1c ]
* @retval true Unlimited objects are available.
* @retval false The object count is fixed.
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_unlimited( uint32_t maximum )
{
return (maximum & OBJECTS_UNLIMITED_OBJECTS) != 0;
400091cc: 87 36 e0 1f srl %i3, 0x1f, %g3
information->inactive_per_block = 0;
400091d0: c0 26 20 30 clr [ %i0 + 0x30 ]
maximum_per_allocation = _Objects_Maximum_per_allocation( maximum );
/*
* Unlimited and maximum of zero is illogical.
*/
if ( information->auto_extend && maximum_per_allocation == 0) {
400091d4: 83 2e e0 10 sll %i3, 0x10, %g1
information->object_blocks = 0;
400091d8: c0 26 20 34 clr [ %i0 + 0x34 ]
if ( information->auto_extend && maximum_per_allocation == 0) {
400091dc: 80 a0 60 00 cmp %g1, 0
information->inactive = 0;
400091e0: c0 36 20 2c clrh [ %i0 + 0x2c ]
information->is_string = is_string;
400091e4: fa 2e 20 38 stb %i5, [ %i0 + 0x38 ]
information->maximum = 0;
400091e8: c0 36 20 10 clrh [ %i0 + 0x10 ]
_Objects_Information_table[ the_api ][ the_class ] = information;
400091ec: c4 00 80 1c ld [ %g2 + %i4 ], %g2
400091f0: f0 20 80 04 st %i0, [ %g2 + %g4 ]
information->auto_extend = _Objects_Is_unlimited( maximum );
400091f4: c6 2e 20 12 stb %g3, [ %i0 + 0x12 ]
if ( information->auto_extend && maximum_per_allocation == 0) {
400091f8: 12 80 00 05 bne 4000920c <_Objects_Do_initialize_information+0x64>
400091fc: c8 07 a0 5c ld [ %fp + 0x5c ], %g4
40009200: 80 a0 e0 00 cmp %g3, 0
40009204: 12 80 00 1c bne 40009274 <_Objects_Do_initialize_information+0xcc>
40009208: 01 00 00 00 nop
(( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) |
4000920c: 05 00 00 40 sethi %hi(0x10000), %g2
information->local_table = &null_local_table;
/*
* Calculate minimum and maximum Id's
*/
minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
40009210: 87 30 60 10 srl %g1, 0x10, %g3
40009214: 80 a0 00 03 cmp %g0, %g3
40009218: 82 40 20 00 addx %g0, 0, %g1
4000921c: 82 10 40 02 or %g1, %g2, %g1
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40009220: 85 2e a0 1b sll %i2, 0x1b, %g2
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
40009224: b3 2e 60 18 sll %i1, 0x18, %i1
return &the_chain->Tail.Node;
40009228: ba 06 20 20 add %i0, 0x20, %i5
(( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) |
4000922c: b4 10 40 19 or %g1, %i1, %i2
information->allocation_size = maximum_per_allocation;
40009230: f6 36 20 14 sth %i3, [ %i0 + 0x14 ]
40009234: b4 16 80 02 or %i2, %g2, %i2
information->local_table = &null_local_table;
40009238: 03 10 00 71 sethi %hi(0x4001c400), %g1
4000923c: 84 06 20 24 add %i0, 0x24, %g2
40009240: 82 10 63 58 or %g1, 0x358, %g1
information->minimum_id =
40009244: f4 26 20 08 st %i2, [ %i0 + 8 ]
_Chain_Initialize_empty( &information->Inactive );
/*
* Initialize objects .. if there are any
*/
if ( maximum_per_allocation ) {
40009248: 80 a0 e0 00 cmp %g3, 0
information->local_table = &null_local_table;
4000924c: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
information->name_length = maximum_name_length;
40009250: c8 36 20 3a sth %g4, [ %i0 + 0x3a ]
head->next = tail;
40009254: c4 26 20 20 st %g2, [ %i0 + 0x20 ]
head->previous = NULL;
40009258: c0 26 20 24 clr [ %i0 + 0x24 ]
if ( maximum_per_allocation ) {
4000925c: 12 80 00 04 bne 4000926c <_Objects_Do_initialize_information+0xc4>
40009260: fa 26 20 28 st %i5, [ %i0 + 0x28 ]
#if defined(RTEMS_MULTIPROCESSING)
information->extract = extract;
_RBTree_Initialize_empty( &information->Global_by_id );
_RBTree_Initialize_empty( &information->Global_by_name );
#endif
}
40009264: 81 c7 e0 08 ret
40009268: 81 e8 00 00 restore
_Objects_Extend_information( information );
4000926c: 7f ff fe fd call 40008e60 <_Objects_Extend_information>
40009270: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_UNLIMITED_AND_MAXIMUM_IS_0 );
40009274: 7f ff f9 8c call 400078a4 <_Internal_error>
40009278: 90 10 20 13 mov 0x13, %o0
4000927c: 01 00 00 00 nop
<== NOT EXECUTED
40008e60 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
40008e60: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
40008e64: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
<== NOT EXECUTED
40008e68: e2 16 20 14 lduh [ %i0 + 0x14 ], %l1
<== NOT EXECUTED
40008e6c: e4 16 20 0a lduh [ %i0 + 0xa ], %l2
40008e70: e0 16 20 10 lduh [ %i0 + 0x10 ], %l0
40008e74: 80 a0 a0 00 cmp %g2, 0
40008e78: 02 80 00 95 be 400090cc <_Objects_Extend_information+0x26c> <== ALWAYS TAKEN
40008e7c: b6 10 00 11 mov %l1, %i3
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
40008e80: 81 80 20 00 wr %g0, %y
40008e84: 01 00 00 00 nop
40008e88: 01 00 00 00 nop
40008e8c: 01 00 00 00 nop
40008e90: b2 f4 00 11 udivcc %l0, %l1, %i1
40008e94: 02 80 00 b1 be 40009158 <_Objects_Extend_information+0x2f8> <== NEVER TAKEN
40008e98: b5 2c 20 10 sll %l0, 0x10, %i2
if ( information->object_blocks[ block ] == NULL ) {
40008e9c: c2 00 80 00 ld [ %g2 ], %g1
40008ea0: 80 a0 60 00 cmp %g1, 0
40008ea4: 02 80 00 b1 be 40009168 <_Objects_Extend_information+0x308> <== NEVER TAKEN
40008ea8: ba 10 00 12 mov %l2, %i5
block = 0;
40008eac: 10 80 00 06 b 40008ec4 <_Objects_Extend_information+0x64>
40008eb0: b8 10 20 00 clr %i4
if ( information->object_blocks[ block ] == NULL ) {
40008eb4: c2 00 80 01 ld [ %g2 + %g1 ], %g1
40008eb8: 80 a0 60 00 cmp %g1, 0
40008ebc: 02 80 00 08 be 40008edc <_Objects_Extend_information+0x7c>
40008ec0: a8 10 20 00 clr %l4
for ( ; block < block_count; block++ ) {
40008ec4: b8 07 20 01 inc %i4
do_extend = false;
break;
} else
index_base += information->allocation_size;
40008ec8: ba 07 40 1b add %i5, %i3, %i5
for ( ; block < block_count; block++ ) {
40008ecc: 80 a6 40 1c cmp %i1, %i4
40008ed0: 12 bf ff f9 bne 40008eb4 <_Objects_Extend_information+0x54>
40008ed4: 83 2f 20 02 sll %i4, 2, %g1
do_extend = true;
40008ed8: a8 10 20 01 mov 1, %l4
}
}
index_end = index_base + information->allocation_size;
maximum = (uint32_t) information->maximum + information->allocation_size;
40008edc: b5 36 a0 10 srl %i2, 0x10, %i2
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
40008ee0: 03 00 00 3f sethi %hi(0xfc00), %g1
maximum = (uint32_t) information->maximum + information->allocation_size;
40008ee4: b4 06 80 1b add %i2, %i3, %i2
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
40008ee8: 82 10 63 ff or %g1, 0x3ff, %g1
40008eec: 80 a6 80 01 cmp %i2, %g1
40008ef0: 18 80 00 88 bgu 40009110 <_Objects_Extend_information+0x2b0>
40008ef4: 01 00 00 00 nop
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
40008ef8: d0 06 20 18 ld [ %i0 + 0x18 ], %o0
if ( information->auto_extend ) {
40008efc: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
40008f00: 80 a0 60 00 cmp %g1, 0
40008f04: 02 80 00 78 be 400090e4 <_Objects_Extend_information+0x284>
40008f08: 90 5e c0 08 smul %i3, %o0, %o0
new_object_block = _Workspace_Allocate( block_size );
40008f0c: 40 00 0d 2b call 4000c3b8 <_Workspace_Allocate>
40008f10: 01 00 00 00 nop
if ( !new_object_block )
40008f14: a6 92 20 00 orcc %o0, 0, %l3
40008f18: 02 80 00 6b be 400090c4 <_Objects_Extend_information+0x264> <== NEVER TAKEN
40008f1c: b6 07 40 1b add %i5, %i3, %i3
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
40008f20: 80 8d 20 ff btst 0xff, %l4
40008f24: 22 80 00 45 be,a 40009038 <_Objects_Extend_information+0x1d8>
40008f28: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
(void*)(block_count * sizeof(uint32_t)),
CPU_ALIGNMENT
);
block_size = object_blocks_size + inactive_per_block_size +
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
40008f2c: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
block_count++;
40008f30: b2 06 60 01 inc %i1
((maximum + minimum_index) * sizeof(Objects_Control *));
40008f34: 90 04 80 1a add %l2, %i2, %o0
if ( information->auto_extend ) {
40008f38: 80 a0 60 00 cmp %g1, 0
(void*)(block_count * sizeof(void*)),
40008f3c: b5 2e 60 02 sll %i1, 2, %i2
((maximum + minimum_index) * sizeof(Objects_Control *));
40008f40: 91 2a 20 02 sll %o0, 2, %o0
void *address,
size_t alignment
)
{
uintptr_t mask = alignment - (uintptr_t)1;
return (void*)(((uintptr_t)address + mask) & ~mask);
40008f44: b2 06 a0 07 add %i2, 7, %i1
40008f48: b2 0e 7f f8 and %i1, -8, %i1
block_size = object_blocks_size + inactive_per_block_size +
40008f4c: 83 2e 60 01 sll %i1, 1, %g1
if ( information->auto_extend ) {
40008f50: 12 80 00 69 bne 400090f4 <_Objects_Extend_information+0x294>
40008f54: 90 02 00 01 add %o0, %g1, %o0
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
return;
}
} else {
object_blocks = _Workspace_Allocate_or_fatal_error( block_size );
40008f58: 40 00 0d 2e call 4000c410 <_Workspace_Allocate_or_fatal_error>
40008f5c: 01 00 00 00 nop
40008f60: aa 10 00 08 mov %o0, %l5
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
40008f64: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
return (void *)((uintptr_t)base + offset);
40008f68: a8 05 40 19 add %l5, %i1, %l4
40008f6c: b4 06 bf fc add %i2, -4, %i2
40008f70: 80 a0 40 12 cmp %g1, %l2
40008f74: 18 80 00 69 bgu 40009118 <_Objects_Extend_information+0x2b8>
40008f78: b2 06 40 14 add %i1, %l4, %i1
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
40008f7c: 80 a4 a0 00 cmp %l2, 0
40008f80: 22 80 00 0b be,a 40008fac <_Objects_Extend_information+0x14c> <== NEVER TAKEN
40008f84: c0 25 40 1a clr [ %l5 + %i2 ]
<== NOT EXECUTED
40008f88: a5 2c a0 02 sll %l2, 2, %l2
40008f8c: 82 10 00 19 mov %i1, %g1
40008f90: a4 04 80 19 add %l2, %i1, %l2
local_table[ index ] = NULL;
40008f94: c0 20 40 00 clr [ %g1 ]
40008f98: 82 00 60 04 add %g1, 4, %g1
for ( index = 0; index < minimum_index; index++ ) {
40008f9c: 80 a4 80 01 cmp %l2, %g1
40008fa0: 32 bf ff fe bne,a 40008f98 <_Objects_Extend_information+0x138> <== NEVER TAKEN
40008fa4: c0 20 40 00 clr [ %g1 ]
<== NOT EXECUTED
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
40008fa8: c0 25 40 1a clr [ %l5 + %i2 ]
inactive_per_block[block_count] = 0;
for ( index = index_base ; index < index_end ; ++index ) {
40008fac: 80 a7 40 1b cmp %i5, %i3
40008fb0: 1a 80 00 0b bcc 40008fdc <_Objects_Extend_information+0x17c> <== NEVER TAKEN
40008fb4: c0 25 00 1a clr [ %l4 + %i2 ]
40008fb8: 83 2f 60 02 sll %i5, 2, %g1
40008fbc: 85 2e e0 02 sll %i3, 2, %g2
40008fc0: 82 00 40 19 add %g1, %i1, %g1
40008fc4: 84 00 80 19 add %g2, %i1, %g2
local_table[ index ] = NULL;
40008fc8: c0 20 40 00 clr [ %g1 ]
40008fcc: 82 00 60 04 add %g1, 4, %g1
for ( index = index_base ; index < index_end ; ++index ) {
40008fd0: 80 a0 80 01 cmp %g2, %g1
40008fd4: 32 bf ff fe bne,a 40008fcc <_Objects_Extend_information+0x16c>
40008fd8: c0 20 40 00 clr [ %g1 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008fdc: 91 d0 20 09 ta 9
<== NOT EXECUTED
uint8_t node,
uint16_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40008fe0: 07 00 00 40 sethi %hi(0x10000), %g3
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
40008fe4: c4 06 00 00 ld [ %i0 ], %g2
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40008fe8: c8 16 20 04 lduh [ %i0 + 4 ], %g4
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
40008fec: a0 04 00 11 add %l0, %l1, %l0
old_tables = information->object_blocks;
40008ff0: d0 06 20 34 ld [ %i0 + 0x34 ], %o0
40008ff4: 89 29 20 1b sll %g4, 0x1b, %g4
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
40008ff8: 85 28 a0 18 sll %g2, 0x18, %g2
information->object_blocks = object_blocks;
40008ffc: ea 26 20 34 st %l5, [ %i0 + 0x34 ]
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40009000: 84 10 80 03 or %g2, %g3, %g2
information->inactive_per_block = inactive_per_block;
40009004: e8 26 20 30 st %l4, [ %i0 + 0x30 ]
#if !defined(RTEMS_USE_16_BIT_OBJECT)
(( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) |
40009008: 87 2c 20 10 sll %l0, 0x10, %g3
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
4000900c: 84 10 80 04 or %g2, %g4, %g2
(( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) |
40009010: 87 30 e0 10 srl %g3, 0x10, %g3
information->local_table = local_table;
40009014: f2 26 20 1c st %i1, [ %i0 + 0x1c ]
40009018: 84 10 80 03 or %g2, %g3, %g2
information->maximum = (Objects_Maximum) maximum;
4000901c: e0 36 20 10 sth %l0, [ %i0 + 0x10 ]
information->maximum_id = _Objects_Build_id(
40009020: c4 26 20 0c st %g2, [ %i0 + 0xc ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009024: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009028: 01 00 00 00 nop
information->maximum
);
_ISR_lock_ISR_enable( &lock_context );
_Workspace_Free( old_tables );
4000902c: 40 00 0c f3 call 4000c3f8 <_Workspace_Free>
40009030: 01 00 00 00 nop
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
40009034: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
40009038: b9 2f 20 02 sll %i4, 2, %i4
4000903c: e6 20 40 1c st %l3, [ %g1 + %i4 ]
/*
* Append to inactive chain.
*/
the_object = information->object_blocks[ block ];
for ( index = index_base ; index < index_end ; ++index ) {
40009040: 80 a7 40 1b cmp %i5, %i3
the_object = information->object_blocks[ block ];
40009044: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
for ( index = index_base ; index < index_end ; ++index ) {
40009048: 1a 80 00 19 bcc 400090ac <_Objects_Extend_information+0x24c> <== NEVER TAKEN
4000904c: c2 00 40 1c ld [ %g1 + %i4 ], %g1
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
40009050: c8 06 00 00 ld [ %i0 ], %g4
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40009054: c4 16 20 04 lduh [ %i0 + 4 ], %g2
_Chain_Initialize_node( &the_object->Node );
_Chain_Append_unprotected( &information->Inactive, &the_object->Node );
the_object = (Objects_Control *)
( (char *) the_object + information->size );
40009058: de 06 20 18 ld [ %i0 + 0x18 ], %o7
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
4000905c: 89 29 20 18 sll %g4, 0x18, %g4
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40009060: 85 28 a0 1b sll %g2, 0x1b, %g2
40009064: 07 00 00 40 sethi %hi(0x10000), %g3
(( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) |
40009068: 35 00 00 3f sethi %hi(0xfc00), %i2
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
4000906c: 88 11 00 03 or %g4, %g3, %g4
40009070: b2 06 20 24 add %i0, 0x24, %i1
40009074: 88 11 00 02 or %g4, %g2, %g4
(( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) |
40009078: b4 16 a3 ff or %i2, 0x3ff, %i2
old_last = tail->previous;
4000907c: c6 06 20 28 ld [ %i0 + 0x28 ], %g3
40009080: 84 0f 40 1a and %i5, %i2, %g2
the_node->next = tail;
40009084: f2 20 40 00 st %i1, [ %g1 ]
40009088: 84 10 80 04 or %g2, %g4, %g2
the_object->id = _Objects_Build_id(
4000908c: c4 20 60 08 st %g2, [ %g1 + 8 ]
for ( index = index_base ; index < index_end ; ++index ) {
40009090: ba 07 60 01 inc %i5
tail->previous = the_node;
40009094: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
40009098: 80 a6 c0 1d cmp %i3, %i5
old_last->next = the_node;
4000909c: c2 20 c0 00 st %g1, [ %g3 ]
the_node->previous = old_last;
400090a0: c6 20 60 04 st %g3, [ %g1 + 4 ]
400090a4: 12 bf ff f6 bne 4000907c <_Objects_Extend_information+0x21c>
400090a8: 82 00 40 0f add %g1, %o7, %g1
}
information->inactive_per_block[ block ] = information->allocation_size;
400090ac: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2
400090b0: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
400090b4: c2 16 20 2c lduh [ %i0 + 0x2c ], %g1
information->inactive_per_block[ block ] = information->allocation_size;
400090b8: c4 20 c0 1c st %g2, [ %g3 + %i4 ]
(Objects_Maximum)(information->inactive + information->allocation_size);
400090bc: 82 00 40 02 add %g1, %g2, %g1
information->inactive =
400090c0: c2 36 20 2c sth %g1, [ %i0 + 0x2c ]
}
400090c4: 81 c7 e0 08 ret
400090c8: 81 e8 00 00 restore
400090cc: ba 10 00 12 mov %l2, %i5
do_extend = true;
400090d0: a8 10 20 01 mov 1, %l4
block = 0;
400090d4: b8 10 20 00 clr %i4
block_count = 0;
400090d8: b2 10 20 00 clr %i1
400090dc: 10 bf ff 80 b 40008edc <_Objects_Extend_information+0x7c>
400090e0: b5 2c 20 10 sll %l0, 0x10, %i2
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
400090e4: 40 00 0c cb call 4000c410 <_Workspace_Allocate_or_fatal_error>
400090e8: b6 07 40 1b add %i5, %i3, %i3
400090ec: 10 bf ff 8d b 40008f20 <_Objects_Extend_information+0xc0>
400090f0: a6 10 00 08 mov %o0, %l3
object_blocks = _Workspace_Allocate( block_size );
400090f4: 40 00 0c b1 call 4000c3b8 <_Workspace_Allocate>
400090f8: 01 00 00 00 nop
if ( !object_blocks ) {
400090fc: aa 92 20 00 orcc %o0, 0, %l5
40009100: 32 bf ff 9a bne,a 40008f68 <_Objects_Extend_information+0x108> <== ALWAYS TAKEN
40009104: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
_Workspace_Free( new_object_block );
40009108: 40 00 0c bc call 4000c3f8 <_Workspace_Free>
<== NOT EXECUTED
4000910c: 91 e8 00 13 restore %g0, %l3, %o0
<== NOT EXECUTED
40009110: 81 c7 e0 08 ret
40009114: 81 e8 00 00 restore
memcpy( object_blocks,
40009118: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
4000911c: 94 10 00 1a mov %i2, %o2
40009120: 40 00 17 fc call 4000f110 <memcpy>
40009124: 90 10 00 15 mov %l5, %o0
memcpy( inactive_per_block,
40009128: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
4000912c: 94 10 00 1a mov %i2, %o2
40009130: 40 00 17 f8 call 4000f110 <memcpy>
40009134: 90 10 00 14 mov %l4, %o0
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
40009138: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2
memcpy( local_table,
4000913c: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
40009140: 94 02 80 12 add %o2, %l2, %o2
memcpy( local_table,
40009144: 90 10 00 19 mov %i1, %o0
40009148: 40 00 17 f2 call 4000f110 <memcpy>
4000914c: 95 2a a0 02 sll %o2, 2, %o2
40009150: 10 bf ff 97 b 40008fac <_Objects_Extend_information+0x14c>
40009154: c0 25 40 1a clr [ %l5 + %i2 ]
for ( ; block < block_count; block++ ) {
40009158: ba 10 00 12 mov %l2, %i5
<== NOT EXECUTED
do_extend = true;
4000915c: a8 10 20 01 mov 1, %l4
<== NOT EXECUTED
block = 0;
40009160: 10 bf ff 5f b 40008edc <_Objects_Extend_information+0x7c>
<== NOT EXECUTED
40009164: b8 10 20 00 clr %i4
<== NOT EXECUTED
do_extend = false;
40009168: a8 10 20 00 clr %l4
<== NOT EXECUTED
block = 0;
4000916c: 10 bf ff 5c b 40008edc <_Objects_Extend_information+0x7c>
<== NOT EXECUTED
40009170: b8 10 20 00 clr %i4
<== NOT EXECUTED
4000def0 <_Objects_Free>:
old_last = tail->previous;
4000def0: c6 02 20 28 ld [ %o0 + 0x28 ], %g3
<== NOT EXECUTED
void _Objects_Free(
Objects_Information *information,
Objects_Control *the_object
)
{
uint32_t allocation_size = information->allocation_size;
4000def4: c4 12 20 14 lduh [ %o0 + 0x14 ], %g2
return &the_chain->Tail.Node;
4000def8: 88 02 20 24 add %o0, 0x24, %g4
the_node->next = tail;
4000defc: c8 22 40 00 st %g4, [ %o1 ]
tail->previous = the_node;
4000df00: d2 22 20 28 st %o1, [ %o0 + 0x28 ]
old_last->next = the_node;
4000df04: d2 20 c0 00 st %o1, [ %g3 ]
the_node->previous = old_last;
4000df08: c6 22 60 04 st %g3, [ %o1 + 4 ]
_Assert( _Objects_Allocator_is_owner() );
_Chain_Append_unprotected( &information->Inactive, &the_object->Node );
if ( information->auto_extend ) {
4000df0c: c6 0a 20 12 ldub [ %o0 + 0x12 ], %g3
4000df10: 80 a0 e0 00 cmp %g3, 0
4000df14: 02 80 00 1e be 4000df8c <_Objects_Free+0x9c>
<== ALWAYS TAKEN
4000df18: 09 00 00 3f sethi %hi(0xfc00), %g4
uint32_t block;
block = (uint32_t) (_Objects_Get_index( the_object->id ) -
4000df1c: c6 02 60 08 ld [ %o1 + 8 ], %g3
_Objects_Get_index( information->minimum_id ));
4000df20: da 02 20 08 ld [ %o0 + 8 ], %o5
block /= information->allocation_size;
information->inactive_per_block[ block ]++;
4000df24: d6 02 20 30 ld [ %o0 + 0x30 ], %o3
block = (uint32_t) (_Objects_Get_index( the_object->id ) -
4000df28: 88 11 23 ff or %g4, 0x3ff, %g4
4000df2c: 86 08 c0 04 and %g3, %g4, %g3
_Objects_Get_index( information->minimum_id ));
4000df30: 88 0b 40 04 and %o5, %g4, %g4
uint32_t allocation_size = information->allocation_size;
4000df34: 85 28 a0 10 sll %g2, 0x10, %g2
block = (uint32_t) (_Objects_Get_index( the_object->id ) -
4000df38: 86 20 c0 04 sub %g3, %g4, %g3
uint32_t allocation_size = information->allocation_size;
4000df3c: 99 30 a0 10 srl %g2, 0x10, %o4
block /= information->allocation_size;
4000df40: 81 80 20 00 wr %g0, %y
4000df44: 01 00 00 00 nop
4000df48: 01 00 00 00 nop
4000df4c: 01 00 00 00 nop
4000df50: 88 70 c0 0c udiv %g3, %o4, %g4
information->inactive_per_block[ block ]++;
4000df54: 89 29 20 02 sll %g4, 2, %g4
4000df58: da 02 c0 04 ld [ %o3 + %g4 ], %o5
information->inactive++;
4000df5c: c6 12 20 2c lduh [ %o0 + 0x2c ], %g3
information->inactive_per_block[ block ]++;
4000df60: 9a 03 60 01 inc %o5
4000df64: da 22 c0 04 st %o5, [ %o3 + %g4 ]
information->inactive++;
4000df68: 86 00 e0 01 inc %g3
4000df6c: c6 32 20 2c sth %g3, [ %o0 + 0x2c ]
/*
* Check if the threshold level has been met of
* 1.5 x allocation_size are free.
*/
if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) {
4000df70: 85 30 a0 11 srl %g2, 0x11, %g2
4000df74: 87 28 e0 10 sll %g3, 0x10, %g3
4000df78: 84 00 80 0c add %g2, %o4, %g2
4000df7c: 87 30 e0 10 srl %g3, 0x10, %g3
4000df80: 80 a0 c0 02 cmp %g3, %g2
4000df84: 18 80 00 04 bgu 4000df94 <_Objects_Free+0xa4>
4000df88: 01 00 00 00 nop
_Objects_Shrink_information( information );
}
}
}
4000df8c: 81 c3 e0 08 retl
4000df90: 01 00 00 00 nop
_Objects_Shrink_information( information );
4000df94: 82 13 c0 00 mov %o7, %g1
4000df98: 40 00 00 47 call 4000e0b4 <_Objects_Shrink_information>
4000df9c: 9e 10 40 00 mov %g1, %o7
4000e02c <_Objects_Get>:
const Objects_Information *information
)
{
uint32_t index;
index = id - information->minimum_id + 1;
4000e02c: c4 02 a0 08 ld [ %o2 + 8 ], %g2
<== NOT EXECUTED
if ( information->maximum >= index ) {
4000e030: c2 12 a0 10 lduh [ %o2 + 0x10 ], %g1
index = id - information->minimum_id + 1;
4000e034: 90 02 20 01 inc %o0
4000e038: 90 22 00 02 sub %o0, %g2, %o0
if ( information->maximum >= index ) {
4000e03c: 80 a0 40 08 cmp %g1, %o0
4000e040: 0a 80 00 0c bcs 4000e070 <_Objects_Get+0x44>
<== NEVER TAKEN
4000e044: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e048: 91 d0 20 09 ta 9
<== NOT EXECUTED
Objects_Control *the_object;
_ISR_lock_ISR_disable( lock_context );
4000e04c: c2 22 40 00 st %g1, [ %o1 ]
the_object = information->local_table[ index ];
4000e050: c2 02 a0 1c ld [ %o2 + 0x1c ], %g1
4000e054: 91 2a 20 02 sll %o0, 2, %o0
4000e058: d0 00 40 08 ld [ %g1 + %o0 ], %o0
if ( the_object != NULL ) {
4000e05c: 80 a2 20 00 cmp %o0, 0
4000e060: 02 80 00 06 be 4000e078 <_Objects_Get+0x4c>
4000e064: 01 00 00 00 nop
_ISR_lock_ISR_enable( lock_context );
}
return NULL;
}
4000e068: 81 c3 e0 08 retl
4000e06c: 01 00 00 00 nop
4000e070: 81 c3 e0 08 retl
4000e074: 90 10 20 00 clr %o0 ! 0 <PROM_START>
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e078: c2 02 40 00 ld [ %o1 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e07c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e080: 01 00 00 00 nop
4000e084: 81 c3 e0 08 retl
4000e088: 01 00 00 00 nop
4000c05c <_Objects_Get_by_name>:
const Objects_Information *information,
const char *name,
size_t *name_length_p,
Objects_Get_by_name_error *error
)
{
4000c05c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
uint32_t index;
_Assert( information->is_string );
_Assert( _Objects_Allocator_is_owner() );
if ( name == NULL ) {
4000c060: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000c064: 22 80 00 2e be,a 4000c11c <_Objects_Get_by_name+0xc0>
<== NOT EXECUTED
4000c068: c0 26 c0 00 clr [ %i3 ]
*error = OBJECTS_GET_BY_NAME_INVALID_NAME;
return NULL;
}
name_length = strnlen( name, information->name_length + 1 );
4000c06c: d2 16 20 3a lduh [ %i0 + 0x3a ], %o1
4000c070: 92 02 60 01 inc %o1
4000c074: 40 00 1c 31 call 40013138 <strnlen>
4000c078: 90 10 00 19 mov %i1, %o0
max_name_length = information->name_length;
4000c07c: e0 16 20 3a lduh [ %i0 + 0x3a ], %l0
if ( name_length > max_name_length ) {
4000c080: 80 a2 00 10 cmp %o0, %l0
4000c084: 18 80 00 22 bgu 4000c10c <_Objects_Get_by_name+0xb0>
4000c088: 80 a6 a0 00 cmp %i2, 0
*error = OBJECTS_GET_BY_NAME_NAME_TOO_LONG;
return NULL;
}
if ( name_length_p != NULL ) {
4000c08c: 32 80 00 02 bne,a 4000c094 <_Objects_Get_by_name+0x38>
4000c090: d0 26 80 00 st %o0, [ %i2 ]
*name_length_p = name_length;
}
for ( index = 1; index <= information->maximum; index++ ) {
4000c094: f8 16 20 10 lduh [ %i0 + 0x10 ], %i4
4000c098: 80 a7 20 00 cmp %i4, 0
4000c09c: 02 80 00 18 be 4000c0fc <_Objects_Get_by_name+0xa0>
4000c0a0: 82 10 20 02 mov 2, %g1
Objects_Control *the_object;
the_object = information->local_table[ index ];
4000c0a4: f4 06 20 1c ld [ %i0 + 0x1c ], %i2
4000c0a8: b8 07 20 01 inc %i4
for ( index = 1; index <= information->maximum; index++ ) {
4000c0ac: ba 10 20 01 mov 1, %i5
the_object = information->local_table[ index ];
4000c0b0: 83 2f 60 02 sll %i5, 2, %g1
4000c0b4: f0 06 80 01 ld [ %i2 + %g1 ], %i0
if ( the_object == NULL )
4000c0b8: 80 a6 20 00 cmp %i0, 0
4000c0bc: 22 80 00 0c be,a 4000c0ec <_Objects_Get_by_name+0x90>
4000c0c0: ba 07 60 01 inc %i5
continue;
if ( the_object->name.name_p == NULL )
4000c0c4: d2 06 20 0c ld [ %i0 + 0xc ], %o1
4000c0c8: 80 a2 60 00 cmp %o1, 0
4000c0cc: 02 80 00 07 be 4000c0e8 <_Objects_Get_by_name+0x8c>
4000c0d0: 94 10 00 10 mov %l0, %o2
continue;
if ( strncmp( name, the_object->name.name_p, max_name_length ) == 0 ) {
4000c0d4: 40 00 1b cf call 40013010 <strncmp>
4000c0d8: 90 10 00 19 mov %i1, %o0
4000c0dc: 80 a2 20 00 cmp %o0, 0
4000c0e0: 02 80 00 09 be 4000c104 <_Objects_Get_by_name+0xa8>
4000c0e4: 01 00 00 00 nop
for ( index = 1; index <= information->maximum; index++ ) {
4000c0e8: ba 07 60 01 inc %i5
4000c0ec: 80 a7 40 1c cmp %i5, %i4
4000c0f0: 12 bf ff f1 bne 4000c0b4 <_Objects_Get_by_name+0x58>
4000c0f4: 83 2f 60 02 sll %i5, 2, %g1
return the_object;
}
}
*error = OBJECTS_GET_BY_NAME_NO_OBJECT;
4000c0f8: 82 10 20 02 mov 2, %g1
4000c0fc: c2 26 c0 00 st %g1, [ %i3 ]
return NULL;
4000c100: b0 10 20 00 clr %i0
}
4000c104: 81 c7 e0 08 ret
4000c108: 81 e8 00 00 restore
*error = OBJECTS_GET_BY_NAME_NAME_TOO_LONG;
4000c10c: 82 10 20 01 mov 1, %g1
4000c110: c2 26 c0 00 st %g1, [ %i3 ]
return NULL;
4000c114: 81 c7 e0 08 ret
4000c118: 91 e8 20 00 restore %g0, 0, %o0
return NULL;
4000c11c: 81 c7 e0 08 ret
4000c120: 91 e8 20 00 restore %g0, 0, %o0
4000dfb8 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
4000dfb8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
4000dfbc: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000dfc0: 02 80 00 19 be 4000e024 <_Objects_Get_information+0x6c>
<== NOT EXECUTED
4000dfc4: 01 00 00 00 nop
/*
* This call implicitly validates the_api so we do not call
* _Objects_Is_api_valid above here.
*/
the_class_api_maximum = _Objects_API_maximum_class( the_api );
4000dfc8: 40 00 02 c6 call 4000eae0 <_Objects_API_maximum_class>
4000dfcc: 90 10 00 18 mov %i0, %o0
if ( the_class_api_maximum == 0 )
4000dfd0: 80 a2 20 00 cmp %o0, 0
4000dfd4: 02 80 00 14 be 4000e024 <_Objects_Get_information+0x6c>
4000dfd8: 80 a2 00 19 cmp %o0, %i1
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
4000dfdc: 0a 80 00 12 bcs 4000e024 <_Objects_Get_information+0x6c>
4000dfe0: 03 10 00 66 sethi %hi(0x40019800), %g1
return NULL;
if ( !_Objects_Information_table[ the_api ] )
4000dfe4: b1 2e 20 02 sll %i0, 2, %i0
4000dfe8: 82 10 60 c0 or %g1, 0xc0, %g1
4000dfec: c2 00 40 18 ld [ %g1 + %i0 ], %g1
4000dff0: 80 a0 60 00 cmp %g1, 0
4000dff4: 02 80 00 0c be 4000e024 <_Objects_Get_information+0x6c> <== NEVER TAKEN
4000dff8: b3 2e 60 02 sll %i1, 2, %i1
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
4000dffc: f0 00 40 19 ld [ %g1 + %i1 ], %i0
if ( !info )
4000e000: 80 a6 20 00 cmp %i0, 0
4000e004: 02 80 00 08 be 4000e024 <_Objects_Get_information+0x6c>
4000e008: 01 00 00 00 nop
* In a multprocessing configuration, we may access remote objects.
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
4000e00c: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
4000e010: 80 a0 60 00 cmp %g1, 0
4000e014: 02 80 00 04 be 4000e024 <_Objects_Get_information+0x6c>
4000e018: 01 00 00 00 nop
return NULL;
#endif
return info;
}
4000e01c: 81 c7 e0 08 ret
4000e020: 81 e8 00 00 restore
return NULL;
4000e024: 81 c7 e0 08 ret
4000e028: 91 e8 20 00 restore %g0, 0, %o0
4000dfa0 <_Objects_Get_information_id>:
4000dfa0: 83 32 20 18 srl %o0, 0x18, %g1
<== NOT EXECUTED
Objects_Information *_Objects_Get_information_id(
Objects_Id id
)
{
return _Objects_Get_information(
4000dfa4: 93 32 20 1b srl %o0, 0x1b, %o1
4000dfa8: 90 08 60 07 and %g1, 7, %o0
4000dfac: 82 13 c0 00 mov %o7, %g1
4000dfb0: 40 00 00 02 call 4000dfb8 <_Objects_Get_information>
4000dfb4: 9e 10 40 00 mov %g1, %o7
4001295c <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
4001295c: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
40012960: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40012964: 02 80 00 1e be 400129dc <_Objects_Get_name_as_string+0x80>
<== NOT EXECUTED
40012968: 80 a6 a0 00 cmp %i2, 0
4001296c: 02 80 00 1c be 400129dc <_Objects_Get_name_as_string+0x80>
40012970: 80 a6 20 00 cmp %i0, 0
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id;
40012974: 22 80 00 18 be,a 400129d4 <_Objects_Get_name_as_string+0x78>
40012978: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1
information = _Objects_Get_information_id( tmpId );
4001297c: 7f ff e8 24 call 4000ca0c <_Objects_Get_information_id>
40012980: 90 10 00 18 mov %i0, %o0
if ( !information )
40012984: ba 92 20 00 orcc %o0, 0, %i5
40012988: 02 80 00 15 be 400129dc <_Objects_Get_name_as_string+0x80>
4001298c: 94 10 00 1d mov %i5, %o2
return NULL;
the_object = _Objects_Get( tmpId, &lock_context, information );
40012990: 92 07 bf fc add %fp, -4, %o1
40012994: 7f ff e8 41 call 4000ca98 <_Objects_Get>
40012998: 90 10 00 18 mov %i0, %o0
if ( the_object == NULL ) {
4001299c: 80 a2 20 00 cmp %o0, 0
400129a0: 02 80 00 0f be 400129dc <_Objects_Get_name_as_string+0x80>
400129a4: 96 10 00 19 mov %i1, %o3
return NULL;
}
_Objects_Name_to_string(
400129a8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
400129ac: d2 0f 60 38 ldub [ %i5 + 0x38 ], %o1
400129b0: c2 27 bf f4 st %g1, [ %fp + -12 ]
400129b4: 94 10 00 1a mov %i2, %o2
400129b8: 7f ff ff be call 400128b0 <_Objects_Name_to_string>
400129bc: 90 07 bf f4 add %fp, -12, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400129c0: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400129c4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400129c8: 01 00 00 00 nop
length
);
_ISR_lock_ISR_enable( &lock_context );
return name;
}
400129cc: 81 c7 e0 08 ret
400129d0: 91 e8 00 1a restore %g0, %i2, %o0
400129d4: 10 bf ff ea b 4001297c <_Objects_Get_name_as_string+0x20>
400129d8: f0 00 60 08 ld [ %g1 + 8 ], %i0
return NULL;
400129dc: 81 c7 e0 08 ret
400129e0: 91 e8 20 00 restore %g0, 0, %o0
4000bfc4 <_Objects_Get_next>:
Objects_Control *_Objects_Get_next(
Objects_Id id,
const Objects_Information *information,
Objects_Id *next_id_p
)
{
4000bfc4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Objects_Id next_id;
if ( !information )
return NULL;
if ( !next_id_p )
4000bfc8: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000bfcc: 02 80 00 20 be 4000c04c <_Objects_Get_next+0x88>
<== NOT EXECUTED
4000bfd0: 80 a6 a0 00 cmp %i2, 0
4000bfd4: 02 80 00 1e be 4000c04c <_Objects_Get_next+0x88>
4000bfd8: 83 2e 20 10 sll %i0, 0x10, %g1
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
4000bfdc: 80 a0 60 00 cmp %g1, 0
4000bfe0: 22 80 00 02 be,a 4000bfe8 <_Objects_Get_next+0x24>
4000bfe4: f0 06 60 08 ld [ %i1 + 8 ], %i0
_RTEMS_Lock_allocator();
4000bfe8: 7f ff f6 d0 call 40009b28 <_RTEMS_Lock_allocator>
4000bfec: 01 00 00 00 nop
_Objects_Allocator_lock();
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
4000bff0: 10 80 00 08 b 4000c010 <_Objects_Get_next+0x4c>
4000bff4: c4 16 60 10 lduh [ %i1 + 0x10 ], %g2
*next_id_p = OBJECTS_ID_FINAL;
return NULL;
}
/* try to grab one */
the_object = _Objects_Get_no_protection( next_id, information );
4000bff8: 40 00 00 17 call 4000c054 <_Objects_Get_no_protection>
4000bffc: b0 06 20 01 inc %i0
next_id++;
} while ( the_object == NULL );
4000c000: 80 a2 20 00 cmp %o0, 0
4000c004: 32 80 00 10 bne,a 4000c044 <_Objects_Get_next+0x80>
4000c008: f0 26 80 00 st %i0, [ %i2 ]
if (_Objects_Get_index(next_id) > information->maximum)
4000c00c: c4 16 60 10 lduh [ %i1 + 0x10 ], %g2
4000c010: 83 2e 20 10 sll %i0, 0x10, %g1
the_object = _Objects_Get_no_protection( next_id, information );
4000c014: 90 10 00 18 mov %i0, %o0
if (_Objects_Get_index(next_id) > information->maximum)
4000c018: 83 30 60 10 srl %g1, 0x10, %g1
4000c01c: 80 a0 80 01 cmp %g2, %g1
4000c020: 1a bf ff f6 bcc 4000bff8 <_Objects_Get_next+0x34>
4000c024: 92 10 00 19 mov %i1, %o1
_RTEMS_Unlock_allocator();
4000c028: 7f ff f6 c5 call 40009b3c <_RTEMS_Unlock_allocator>
4000c02c: 01 00 00 00 nop
*next_id_p = OBJECTS_ID_FINAL;
4000c030: 82 10 3f ff mov -1, %g1 ! ffffffff <RAM_END+0xbfbfffff>
4000c034: c2 26 80 00 st %g1, [ %i2 ]
return NULL;
4000c038: 90 10 20 00 clr %o0
*next_id_p = next_id;
return the_object;
}
4000c03c: 81 c7 e0 08 ret
4000c040: 91 e8 00 08 restore %g0, %o0, %o0
4000c044: 81 c7 e0 08 ret
4000c048: 91 e8 00 08 restore %g0, %o0, %o0
return NULL;
4000c04c: 10 bf ff fc b 4000c03c <_Objects_Get_next+0x78>
4000c050: 90 10 20 00 clr %o0
40009174 <_Objects_Get_no_protection>:
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
40009174: c4 02 60 08 ld [ %o1 + 8 ], %g2
<== NOT EXECUTED
if ( information->maximum >= index ) {
40009178: c2 12 60 10 lduh [ %o1 + 0x10 ], %g1
<== NOT EXECUTED
index = id - information->minimum_id + 1;
4000917c: 90 02 20 01 inc %o0
<== NOT EXECUTED
40009180: 90 22 00 02 sub %o0, %g2, %o0
if ( information->maximum >= index ) {
40009184: 80 a0 40 08 cmp %g1, %o0
40009188: 0a 80 00 06 bcs 400091a0 <_Objects_Get_no_protection+0x2c> <== NEVER TAKEN
4000918c: 01 00 00 00 nop
if ( (the_object = information->local_table[ index ]) != NULL ) {
40009190: c2 02 60 1c ld [ %o1 + 0x1c ], %g1
40009194: 91 2a 20 02 sll %o0, 2, %o0
40009198: 81 c3 e0 08 retl
4000919c: d0 00 40 08 ld [ %g1 + %o0 ], %o0
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
return NULL;
}
400091a0: 81 c3 e0 08 retl
400091a4: 90 10 20 00 clr %o0
4000cb2c <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
4000cb2c: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id;
4000cb30: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4000cb34: 12 80 00 04 bne 4000cb44 <_Objects_Id_to_name+0x18>
<== NOT EXECUTED
4000cb38: 01 00 00 00 nop
4000cb3c: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1
4000cb40: f0 00 60 08 ld [ %g1 + 8 ], %i0
information = _Objects_Get_information_id( tmpId );
4000cb44: 7f ff ff b2 call 4000ca0c <_Objects_Get_information_id>
4000cb48: 90 10 00 18 mov %i0, %o0
if ( !information )
4000cb4c: 80 a2 20 00 cmp %o0, 0
4000cb50: 02 80 00 13 be 4000cb9c <_Objects_Id_to_name+0x70>
4000cb54: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
4000cb58: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1
4000cb5c: 80 a0 60 00 cmp %g1, 0
4000cb60: 12 80 00 0f bne 4000cb9c <_Objects_Id_to_name+0x70>
<== NEVER TAKEN
4000cb64: 94 10 00 08 mov %o0, %o2
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get(
4000cb68: 92 07 bf fc add %fp, -4, %o1
4000cb6c: 7f ff ff cb call 4000ca98 <_Objects_Get>
4000cb70: 90 10 00 18 mov %i0, %o0
tmpId,
&lock_context,
information
);
if ( !the_object )
4000cb74: 80 a2 20 00 cmp %o0, 0
4000cb78: 02 80 00 09 be 4000cb9c <_Objects_Id_to_name+0x70>
4000cb7c: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
*name = the_object->name;
4000cb80: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
4000cb84: c2 26 40 00 st %g1, [ %i1 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000cb88: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000cb8c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000cb90: 01 00 00 00 nop
_ISR_lock_ISR_enable( &lock_context );
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
4000cb94: 81 c7 e0 08 ret
4000cb98: 91 e8 20 00 restore %g0, 0, %o0
return OBJECTS_INVALID_ID;
4000cb9c: 81 c7 e0 08 ret
4000cba0: 91 e8 20 03 restore %g0, 3, %o0
400131bc <_Objects_Name_to_id_u32>:
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
400131bc: 80 a2 e0 00 cmp %o3, 0
<== NOT EXECUTED
400131c0: 02 80 00 21 be 40013244 <_Objects_Name_to_id_u32+0x88>
<== NOT EXECUTED
400131c4: 80 a2 60 00 cmp %o1, 0
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
400131c8: 02 80 00 1d be 4001323c <_Objects_Name_to_id_u32+0x80>
400131cc: 82 10 20 01 mov 1, %g1
search_local_node = false;
if ( information->maximum != 0 &&
(node == OBJECTS_SEARCH_ALL_NODES ||
node == OBJECTS_SEARCH_LOCAL_NODE ||
400131d0: 05 20 00 00 sethi %hi(0x80000000), %g2
400131d4: 84 38 80 0a xnor %g2, %o2, %g2
400131d8: 80 a0 a0 00 cmp %g2, 0
400131dc: 02 80 00 05 be 400131f0 <_Objects_Name_to_id_u32+0x34>
400131e0: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3
400131e4: 80 a2 a0 01 cmp %o2, 1
400131e8: 18 80 00 15 bgu 4001323c <_Objects_Name_to_id_u32+0x80>
400131ec: 01 00 00 00 nop
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
400131f0: 80 a0 e0 00 cmp %g3, 0
400131f4: 02 80 00 11 be 40013238 <_Objects_Name_to_id_u32+0x7c>
400131f8: 82 10 20 01 mov 1, %g1
the_object = information->local_table[ index ];
400131fc: da 02 20 1c ld [ %o0 + 0x1c ], %o5
40013200: 86 00 e0 01 inc %g3
40013204: 85 28 60 02 sll %g1, 2, %g2
40013208: c4 03 40 02 ld [ %o5 + %g2 ], %g2
if ( !the_object )
4001320c: 80 a0 a0 00 cmp %g2, 0
40013210: 22 80 00 07 be,a 4001322c <_Objects_Name_to_id_u32+0x70>
40013214: 82 00 60 01 inc %g1
continue;
if ( name == the_object->name.name_u32 ) {
40013218: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
4001321c: 80 a1 00 09 cmp %g4, %o1
40013220: 22 80 00 0c be,a 40013250 <_Objects_Name_to_id_u32+0x94>
40013224: c2 00 a0 08 ld [ %g2 + 8 ], %g1
for ( index = 1; index <= information->maximum; index++ ) {
40013228: 82 00 60 01 inc %g1
4001322c: 80 a0 c0 01 cmp %g3, %g1
40013230: 32 bf ff f6 bne,a 40013208 <_Objects_Name_to_id_u32+0x4c>
40013234: 85 28 60 02 sll %g1, 2, %g2
return OBJECTS_INVALID_NAME;
40013238: 82 10 20 01 mov 1, %g1
name_for_mp.name_u32 = name;
return _Objects_MP_Global_name_search( information, name_for_mp, node, id );
#else
return OBJECTS_INVALID_NAME;
#endif
}
4001323c: 81 c3 e0 08 retl
40013240: 90 10 00 01 mov %g1, %o0
return OBJECTS_INVALID_ADDRESS;
40013244: 82 10 20 02 mov 2, %g1
}
40013248: 81 c3 e0 08 retl
4001324c: 90 10 00 01 mov %g1, %o0
*id = the_object->id;
40013250: c2 22 c0 00 st %g1, [ %o3 ]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
40013254: 10 bf ff fa b 4001323c <_Objects_Name_to_id_u32+0x80>
40013258: 82 10 20 00 clr %g1
400128b0 <_Objects_Name_to_string>:
Objects_Name name,
bool is_string,
char *buffer,
size_t buffer_size
)
{
400128b0: 9c 03 bf b0 add %sp, -80, %sp
<== NOT EXECUTED
const char *s;
char *d;
size_t i;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( is_string ) {
400128b4: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
400128b8: 12 80 00 20 bne 40012938 <_Objects_Name_to_string+0x88>
<== NOT EXECUTED
400128bc: c2 02 00 00 ld [ %o0 ], %g1
s = name.name_p;
} else
#endif
{
lname[ 0 ] = (name.name_u32 >> 24) & 0xff;
400128c0: 85 30 60 18 srl %g1, 0x18, %g2
lname[ 1 ] = (name.name_u32 >> 16) & 0xff;
400128c4: 89 30 60 10 srl %g1, 0x10, %g4
lname[ 2 ] = (name.name_u32 >> 8) & 0xff;
400128c8: 87 30 60 08 srl %g1, 8, %g3
lname[ 0 ] = (name.name_u32 >> 24) & 0xff;
400128cc: c4 2b a0 48 stb %g2, [ %sp + 0x48 ]
lname[ 1 ] = (name.name_u32 >> 16) & 0xff;
400128d0: c8 2b a0 49 stb %g4, [ %sp + 0x49 ]
lname[ 2 ] = (name.name_u32 >> 8) & 0xff;
400128d4: c6 2b a0 4a stb %g3, [ %sp + 0x4a ]
lname[ 3 ] = (name.name_u32 >> 0) & 0xff;
lname[ 4 ] = '\0';
400128d8: c0 2b a0 4c clrb [ %sp + 0x4c ]
lname[ 3 ] = (name.name_u32 >> 0) & 0xff;
400128dc: c2 2b a0 4b stb %g1, [ %sp + 0x4b ]
s = lname;
400128e0: 82 03 a0 48 add %sp, 0x48, %g1
d = buffer;
i = 1;
if ( s != NULL ) {
while ( *s != '\0' ) {
400128e4: 87 28 a0 18 sll %g2, 0x18, %g3
400128e8: 80 a0 e0 00 cmp %g3, 0
400128ec: 02 80 00 16 be 40012944 <_Objects_Name_to_string+0x94> <== NEVER TAKEN
400128f0: 90 10 20 01 mov 1, %o0
if ( i < buffer_size ) {
400128f4: 80 a2 c0 08 cmp %o3, %o0
400128f8: 08 80 00 09 bleu 4001291c <_Objects_Name_to_string+0x6c>
400128fc: 82 00 60 01 inc %g1
return uc >= ' ' && uc <= '~';
40012900: 86 00 bf e0 add %g2, -32, %g3
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
40012904: 86 08 e0 ff and %g3, 0xff, %g3
40012908: 80 a0 e0 5e cmp %g3, 0x5e
4001290c: 38 80 00 02 bgu,a 40012914 <_Objects_Name_to_string+0x64>
40012910: 84 10 20 2a mov 0x2a, %g2
40012914: c4 2a 80 00 stb %g2, [ %o2 ]
++d;
40012918: 94 02 a0 01 inc %o2
while ( *s != '\0' ) {
4001291c: c6 48 40 00 ldsb [ %g1 ], %g3
}
++s;
++i;
40012920: 88 02 20 01 add %o0, 1, %g4
while ( *s != '\0' ) {
40012924: 80 a0 e0 00 cmp %g3, 0
40012928: 02 80 00 08 be 40012948 <_Objects_Name_to_string+0x98>
4001292c: c4 08 40 00 ldub [ %g1 ], %g2
++i;
40012930: 10 bf ff f1 b 400128f4 <_Objects_Name_to_string+0x44>
40012934: 90 10 00 04 mov %g4, %o0
if ( s != NULL ) {
40012938: 80 a0 60 00 cmp %g1, 0
4001293c: 32 bf ff ea bne,a 400128e4 <_Objects_Name_to_string+0x34>
40012940: c4 08 40 00 ldub [ %g1 ], %g2
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
40012944: 90 10 20 00 clr %o0
}
}
if ( buffer_size > 0 ) {
40012948: 80 a2 e0 00 cmp %o3, 0
4001294c: 32 80 00 02 bne,a 40012954 <_Objects_Name_to_string+0xa4>
40012950: c0 2a 80 00 clrb [ %o2 ]
*d = '\0';
}
return i - 1;
}
40012954: 81 c3 e0 08 retl
40012958: 9c 03 a0 50 add %sp, 0x50, %sp
4000e08c <_Objects_Namespace_remove>:
void _Objects_Namespace_remove(
Objects_Information *information,
Objects_Control *the_object
)
{
4000e08c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/*
* If this is a string format name, then free the memory.
*/
if ( information->is_string )
4000e090: c2 0e 20 38 ldub [ %i0 + 0x38 ], %g1
<== NOT EXECUTED
4000e094: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e098: 22 80 00 05 be,a 4000e0ac <_Objects_Namespace_remove+0x20>
<== NOT EXECUTED
4000e09c: c0 26 60 0c clr [ %i1 + 0xc ]
_Workspace_Free( (void *)the_object->name.name_p );
4000e0a0: 7f ff f8 d6 call 4000c3f8 <_Workspace_Free>
4000e0a4: d0 06 60 0c ld [ %i1 + 0xc ], %o0
/*
* Clear out either format.
*/
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
the_object->name.name_p = NULL;
4000e0a8: c0 26 60 0c clr [ %i1 + 0xc ]
#endif
the_object->name.name_u32 = 0;
}
4000e0ac: 81 c7 e0 08 ret
4000e0b0: 81 e8 00 00 restore
40008c54 <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
40008c54: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
40008c58: d2 16 20 3a lduh [ %i0 + 0x3a ], %o1
<== NOT EXECUTED
40008c5c: 40 00 1a 73 call 4000f628 <strnlen>
<== NOT EXECUTED
40008c60: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
40008c64: f0 0e 20 38 ldub [ %i0 + 0x38 ], %i0
40008c68: 80 a6 20 00 cmp %i0, 0
40008c6c: 12 80 00 19 bne 40008cd0 <_Objects_Set_name+0x7c>
40008c70: ba 10 00 08 mov %o0, %i5
40008c74: 03 08 08 08 sethi %hi(0x20202000), %g1
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
40008c78: 80 a2 20 00 cmp %o0, 0
40008c7c: 02 80 00 12 be 40008cc4 <_Objects_Set_name+0x70>
40008c80: 82 10 60 20 or %g1, 0x20, %g1
40008c84: c2 4e 80 00 ldsb [ %i2 ], %g1
40008c88: 80 a2 20 01 cmp %o0, 1
40008c8c: 08 80 00 29 bleu 40008d30 <_Objects_Set_name+0xdc>
40008c90: 85 28 60 18 sll %g1, 0x18, %g2
40008c94: c2 4e a0 01 ldsb [ %i2 + 1 ], %g1
40008c98: 83 28 60 10 sll %g1, 0x10, %g1
40008c9c: 80 a2 20 02 cmp %o0, 2
40008ca0: 02 80 00 1e be 40008d18 <_Objects_Set_name+0xc4>
40008ca4: 84 10 40 02 or %g1, %g2, %g2
40008ca8: c2 4e a0 02 ldsb [ %i2 + 2 ], %g1
40008cac: 83 28 60 08 sll %g1, 8, %g1
40008cb0: 80 a2 20 03 cmp %o0, 3
40008cb4: 02 80 00 1d be 40008d28 <_Objects_Set_name+0xd4>
40008cb8: 82 10 40 02 or %g1, %g2, %g1
40008cbc: c4 4e a0 03 ldsb [ %i2 + 3 ], %g2
40008cc0: 82 10 80 01 or %g2, %g1, %g1
40008cc4: c2 26 60 0c st %g1, [ %i1 + 0xc ]
40008cc8: 81 c7 e0 08 ret
40008ccc: 91 e8 20 01 restore %g0, 1, %o0
d = _Workspace_Allocate( length + 1 );
40008cd0: 40 00 0c 79 call 4000beb4 <_Workspace_Allocate>
40008cd4: 90 02 20 01 inc %o0
if ( !d )
40008cd8: b8 92 20 00 orcc %o0, 0, %i4
40008cdc: 02 80 00 0d be 40008d10 <_Objects_Set_name+0xbc>
40008ce0: 01 00 00 00 nop
_Workspace_Free( (void *)the_object->name.name_p );
40008ce4: 40 00 0c 84 call 4000bef4 <_Workspace_Free>
40008ce8: d0 06 60 0c ld [ %i1 + 0xc ], %o0
the_object->name.name_p = NULL;
40008cec: c0 26 60 0c clr [ %i1 + 0xc ]
strncpy( d, name, length );
40008cf0: 94 10 00 1d mov %i5, %o2
40008cf4: 92 10 00 1a mov %i2, %o1
40008cf8: 40 00 1a 08 call 4000f518 <strncpy>
40008cfc: 90 10 00 1c mov %i4, %o0
d[length] = '\0';
40008d00: c0 2f 00 1d clrb [ %i4 + %i5 ]
the_object->name.name_p = d;
40008d04: f8 26 60 0c st %i4, [ %i1 + 0xc ]
40008d08: 81 c7 e0 08 ret
40008d0c: 81 e8 00 00 restore
);
}
return true;
}
40008d10: 81 c7 e0 08 ret
40008d14: 91 e8 20 00 restore %g0, 0, %o0
40008d18: 07 00 00 08 sethi %hi(0x2000), %g3
40008d1c: 86 10 e0 20 or %g3, 0x20, %g3 ! 2020 <_Configuration_Interrupt_stack_size+0x1020>
40008d20: 10 bf ff e9 b 40008cc4 <_Objects_Set_name+0x70>
40008d24: 82 10 80 03 or %g2, %g3, %g1
40008d28: 10 bf ff e7 b 40008cc4 <_Objects_Set_name+0x70>
40008d2c: 82 10 60 20 or %g1, 0x20, %g1
40008d30: 03 00 08 08 sethi %hi(0x202000), %g1
40008d34: 82 10 60 20 or %g1, 0x20, %g1 ! 202020 <PROM_END+0x2020>
40008d38: 10 bf ff e3 b 40008cc4 <_Objects_Set_name+0x70>
40008d3c: 82 10 80 01 or %g2, %g1, %g1
4000e0b4 <_Objects_Shrink_information>:
#include <rtems/score/wkspace.h>
void _Objects_Shrink_information(
Objects_Information *information
)
{
4000e0b4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
4000e0b8: c6 16 20 0a lduh [ %i0 + 0xa ], %g3
<== NOT EXECUTED
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
4000e0bc: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
block_count = (information->maximum - index_base) /
4000e0c0: c8 16 20 10 lduh [ %i0 + 0x10 ], %g4
<== NOT EXECUTED
4000e0c4: 88 21 00 03 sub %g4, %g3, %g4
<== NOT EXECUTED
for ( block = 0; block < block_count; block++ ) {
4000e0c8: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
4000e0cc: 01 00 00 00 nop
<== NOT EXECUTED
4000e0d0: 01 00 00 00 nop
<== NOT EXECUTED
4000e0d4: 01 00 00 00 nop
<== NOT EXECUTED
4000e0d8: 88 f1 00 02 udivcc %g4, %g2, %g4
<== NOT EXECUTED
4000e0dc: 02 80 00 35 be 4000e1b0 <_Objects_Shrink_information+0xfc>
<== NOT EXECUTED
4000e0e0: 01 00 00 00 nop
if ( information->inactive_per_block[ block ] ==
4000e0e4: f4 06 20 30 ld [ %i0 + 0x30 ], %i2
4000e0e8: c2 06 80 00 ld [ %i2 ], %g1
4000e0ec: 80 a0 80 01 cmp %g2, %g1
4000e0f0: 02 80 00 0f be 4000e12c <_Objects_Shrink_information+0x78> <== NEVER TAKEN
4000e0f4: ba 10 20 04 mov 4, %i5
for ( block = 0; block < block_count; block++ ) {
4000e0f8: 10 80 00 07 b 4000e114 <_Objects_Shrink_information+0x60>
4000e0fc: 82 10 20 00 clr %g1
if ( information->inactive_per_block[ block ] ==
4000e100: f8 06 80 1d ld [ %i2 + %i5 ], %i4
4000e104: 80 a0 80 1c cmp %g2, %i4
4000e108: 02 80 00 0a be 4000e130 <_Objects_Shrink_information+0x7c>
4000e10c: b6 07 60 04 add %i5, 4, %i3
4000e110: ba 10 00 1b mov %i3, %i5
for ( block = 0; block < block_count; block++ ) {
4000e114: 82 00 60 01 inc %g1
4000e118: 80 a1 00 01 cmp %g4, %g1
4000e11c: 12 bf ff f9 bne 4000e100 <_Objects_Shrink_information+0x4c>
4000e120: 86 00 c0 02 add %g3, %g2, %g3
return;
}
index_base += information->allocation_size;
}
}
4000e124: 81 c7 e0 08 ret
4000e128: 81 e8 00 00 restore
if ( information->inactive_per_block[ block ] ==
4000e12c: ba 10 20 00 clr %i5
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000e130: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
return &the_chain->Tail.Node;
4000e134: b4 06 20 24 add %i0, 0x24, %i2
while ( node != tail ) {
4000e138: 80 a0 40 1a cmp %g1, %i2
4000e13c: 02 80 00 12 be 4000e184 <_Objects_Shrink_information+0xd0> <== NEVER TAKEN
4000e140: 84 00 80 03 add %g2, %g3, %g2
4000e144: 37 00 00 3f sethi %hi(0xfc00), %i3
4000e148: b6 16 e3 ff or %i3, 0x3ff, %i3 ! ffff <_Configuration_Interrupt_stack_size+0xefff>
4000e14c: c8 00 60 08 ld [ %g1 + 8 ], %g4
4000e150: 88 09 00 1b and %g4, %i3, %g4
if ( index >= index_base && index < index_end ) {
4000e154: 80 a1 00 03 cmp %g4, %g3
4000e158: 0a 80 00 08 bcs 4000e178 <_Objects_Shrink_information+0xc4>
4000e15c: f8 00 40 00 ld [ %g1 ], %i4
4000e160: 80 a1 00 02 cmp %g4, %g2
4000e164: 1a 80 00 06 bcc 4000e17c <_Objects_Shrink_information+0xc8>
4000e168: 80 a6 80 1c cmp %i2, %i4
previous = the_node->previous;
4000e16c: c2 00 60 04 ld [ %g1 + 4 ], %g1
next->previous = previous;
4000e170: c2 27 20 04 st %g1, [ %i4 + 4 ]
previous->next = next;
4000e174: f8 20 40 00 st %i4, [ %g1 ]
while ( node != tail ) {
4000e178: 80 a6 80 1c cmp %i2, %i4
4000e17c: 12 bf ff f4 bne 4000e14c <_Objects_Shrink_information+0x98>
4000e180: 82 10 00 1c mov %i4, %g1
_Workspace_Free( information->object_blocks[ block ] );
4000e184: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
4000e188: 7f ff f8 9c call 4000c3f8 <_Workspace_Free>
4000e18c: d0 00 40 1d ld [ %g1 + %i5 ], %o0
information->object_blocks[ block ] = NULL;
4000e190: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
4000e194: c0 20 40 1d clr [ %g1 + %i5 ]
information->inactive_per_block[ block ] = 0;
4000e198: c4 06 20 30 ld [ %i0 + 0x30 ], %g2
information->inactive -= information->allocation_size;
4000e19c: c2 16 20 2c lduh [ %i0 + 0x2c ], %g1
information->inactive_per_block[ block ] = 0;
4000e1a0: c0 20 80 1d clr [ %g2 + %i5 ]
information->inactive -= information->allocation_size;
4000e1a4: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2
4000e1a8: 82 20 40 02 sub %g1, %g2, %g1
4000e1ac: c2 36 20 2c sth %g1, [ %i0 + 0x2c ]
return;
4000e1b0: 81 c7 e0 08 ret
4000e1b4: 81 e8 00 00 restore
40009280 <_Once>:
#define ONCE_STATE_NOT_RUN 0
#define ONCE_STATE_RUNNING 1
#define ONCE_STATE_COMPLETE 2
int _Once( unsigned char *once_state, void ( *init_routine )( void ) )
{
40009280: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int eno = 0;
if ( *once_state != ONCE_STATE_COMPLETE ) {
40009284: c2 0e 00 00 ldub [ %i0 ], %g1
<== NOT EXECUTED
40009288: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
4000928c: 02 80 00 0e be 400092c4 <_Once+0x44>
<== NOT EXECUTED
40009290: ba 10 20 00 clr %i5
static API_Mutex_Control _Once_Mutex = API_MUTEX_INITIALIZER( "_Once" );
void _Once_Lock( void )
{
_API_Mutex_Lock( &_Once_Mutex );
40009294: 39 10 00 6d sethi %hi(0x4001b400), %i4
40009298: 7f ff f7 7b call 40007084 <_API_Mutex_Lock>
4000929c: 90 17 21 b0 or %i4, 0x1b0, %o0 ! 4001b5b0 <_Once_Mutex>
switch ( *once_state ) {
400092a0: c2 0e 00 00 ldub [ %i0 ], %g1
400092a4: 80 a0 60 00 cmp %g1, 0
400092a8: 02 80 00 09 be 400092cc <_Once+0x4c>
400092ac: 82 18 60 01 xor %g1, 1, %g1
int eno = 0;
400092b0: 80 a0 00 01 cmp %g0, %g1
400092b4: ba 40 3f ff addx %g0, -1, %i5
400092b8: ba 0f 60 16 and %i5, 0x16, %i5
}
void _Once_Unlock( void )
{
_API_Mutex_Unlock( &_Once_Mutex );
400092bc: 7f ff f7 7e call 400070b4 <_API_Mutex_Unlock>
400092c0: 90 17 21 b0 or %i4, 0x1b0, %o0
}
400092c4: 81 c7 e0 08 ret
400092c8: 91 e8 00 1d restore %g0, %i5, %o0
*once_state = ONCE_STATE_RUNNING;
400092cc: 82 10 20 01 mov 1, %g1
( *init_routine )();
400092d0: 9f c6 40 00 call %i1
400092d4: c2 2e 00 00 stb %g1, [ %i0 ]
*once_state = ONCE_STATE_COMPLETE;
400092d8: 82 10 20 02 mov 2, %g1
break;
400092dc: 10 bf ff f8 b 400092bc <_Once+0x3c>
400092e0: c2 2e 00 00 stb %g1, [ %i0 ]
4000a32c <_Once_Lock>:
static API_Mutex_Control _Once_Mutex = API_MUTEX_INITIALIZER( "_Once" );
void _Once_Lock( void )
{
_API_Mutex_Lock( &_Once_Mutex );
4000a32c: 11 10 00 4f sethi %hi(0x40013c00), %o0
<== NOT EXECUTED
4000a330: 90 12 20 c0 or %o0, 0xc0, %o0 ! 40013cc0 <_Once_Mutex>
<== NOT EXECUTED
4000a334: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000a338: 7f ff f6 2c call 40007be8 <_API_Mutex_Lock>
<== NOT EXECUTED
4000a33c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000a340 <_Once_Unlock>:
}
void _Once_Unlock( void )
{
_API_Mutex_Unlock( &_Once_Mutex );
4000a340: 11 10 00 4f sethi %hi(0x40013c00), %o0
<== NOT EXECUTED
4000a344: 90 12 20 c0 or %o0, 0xc0, %o0 ! 40013cc0 <_Once_Mutex>
<== NOT EXECUTED
4000a348: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000a34c: 7f ff f6 33 call 40007c18 <_API_Mutex_Unlock>
<== NOT EXECUTED
4000a350: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40023cb8 <_Processor_mask_Copy>:
long *dst,
size_t dst_size,
const long *src,
size_t src_size
)
{
40023cb8: 82 10 00 08 mov %o0, %g1
<== NOT EXECUTED
long inclusive = 0;
long exclusive = 0;
if ( ( dst_size | src_size ) % sizeof( long ) != 0 ) {
40023cbc: 84 12 40 0b or %o1, %o3, %g2
<== NOT EXECUTED
40023cc0: 80 88 a0 03 btst 3, %g2
<== NOT EXECUTED
40023cc4: 12 80 00 2b bne 40023d70 <_Processor_mask_Copy+0xb8>
<== NOT EXECUTED
40023cc8: 90 10 20 03 mov 3, %o0
return PROCESSOR_MASK_COPY_INVALID_SIZE;
}
while ( dst_size > 0 && src_size > 0 ) {
40023ccc: 80 a2 e0 00 cmp %o3, 0
40023cd0: 02 80 00 11 be 40023d14 <_Processor_mask_Copy+0x5c>
40023cd4: 86 10 20 00 clr %g3
40023cd8: 80 a2 60 00 cmp %o1, 0
40023cdc: 32 80 00 07 bne,a 40023cf8 <_Processor_mask_Copy+0x40>
40023ce0: c4 02 80 00 ld [ %o2 ], %g2
40023ce4: 30 80 00 0d b,a 40023d18 <_Processor_mask_Copy+0x60>
40023ce8: 80 a2 e0 00 cmp %o3, 0
40023cec: 02 80 00 0b be 40023d18 <_Processor_mask_Copy+0x60>
<== ALWAYS TAKEN
40023cf0: 80 a2 60 00 cmp %o1, 0
long bits = *src;
40023cf4: c4 02 80 00 ld [ %o2 ], %g2
<== NOT EXECUTED
inclusive |= bits;
*dst = bits;
40023cf8: c4 20 40 00 st %g2, [ %g1 ]
++dst;
++src;
dst_size -= sizeof( long );
src_size -= sizeof( long );
40023cfc: 96 02 ff fc add %o3, -4, %o3
while ( dst_size > 0 && src_size > 0 ) {
40023d00: 92 82 7f fc addcc %o1, -4, %o1
inclusive |= bits;
40023d04: 86 10 c0 02 or %g3, %g2, %g3
++dst;
40023d08: 82 00 60 04 add %g1, 4, %g1
while ( dst_size > 0 && src_size > 0 ) {
40023d0c: 12 bf ff f7 bne 40023ce8 <_Processor_mask_Copy+0x30>
40023d10: 94 02 a0 04 add %o2, 4, %o2
}
while ( dst_size > 0 ) {
40023d14: 80 a2 60 00 cmp %o1, 0
40023d18: 02 80 00 07 be 40023d34 <_Processor_mask_Copy+0x7c>
40023d1c: 80 a2 e0 00 cmp %o3, 0
*dst = 0;
40023d20: c0 20 40 00 clr [ %g1 ]
while ( dst_size > 0 ) {
40023d24: 92 82 7f fc addcc %o1, -4, %o1
40023d28: 12 bf ff fe bne 40023d20 <_Processor_mask_Copy+0x68>
<== NEVER TAKEN
40023d2c: 82 00 60 04 add %g1, 4, %g1
++dst;
dst_size -= sizeof( long );
}
while ( src_size > 0 ) {
40023d30: 80 a2 e0 00 cmp %o3, 0
40023d34: 02 80 00 0e be 40023d6c <_Processor_mask_Copy+0xb4>
40023d38: 82 10 20 00 clr %g1
exclusive |= *src;
40023d3c: c4 02 80 00 ld [ %o2 ], %g2
40023d40: 82 10 40 02 or %g1, %g2, %g1
while ( src_size > 0 ) {
40023d44: 96 82 ff fc addcc %o3, -4, %o3
40023d48: 12 bf ff fd bne 40023d3c <_Processor_mask_Copy+0x84>
<== NEVER TAKEN
40023d4c: 94 02 a0 04 add %o2, 4, %o2
++src;
src_size -= sizeof( long );
}
if ( exclusive != 0 ) {
40023d50: 80 a0 60 00 cmp %g1, 0
40023d54: 02 80 00 07 be 40023d70 <_Processor_mask_Copy+0xb8>
40023d58: 90 10 20 00 clr %o0
if ( inclusive != 0 ) {
return PROCESSOR_MASK_COPY_PARTIAL_LOSS;
} else {
return PROCESSOR_MASK_COPY_COMPLETE_LOSS;
40023d5c: 80 a0 00 03 cmp %g0, %g3
40023d60: 90 60 3f ff subx %g0, -1, %o0
40023d64: 81 c3 e0 08 retl
40023d68: 90 02 20 01 inc %o0
}
}
return PROCESSOR_MASK_COPY_LOSSLESS;
40023d6c: 90 10 20 00 clr %o0
}
40023d70: 81 c3 e0 08 retl
40023d74: 01 00 00 00 nop
40008c20 <_Protected_heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
40008c20: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
void *p;
_RTEMS_Lock_allocator();
40008c24: 7f ff f7 4c call 40006954 <_RTEMS_Lock_allocator>
<== NOT EXECUTED
40008c28: 01 00 00 00 nop
<== NOT EXECUTED
p = _Heap_Allocate_aligned_with_boundary(
40008c2c: 96 10 00 1b mov %i3, %o3
40008c30: 94 10 00 1a mov %i2, %o2
40008c34: 92 10 00 19 mov %i1, %o1
40008c38: 7f ff f7 b2 call 40006b00 <_Heap_Allocate_aligned_with_boundary>
40008c3c: 90 10 00 18 mov %i0, %o0
heap,
size,
alignment,
boundary
);
_RTEMS_Unlock_allocator();
40008c40: 7f ff f7 4a call 40006968 <_RTEMS_Unlock_allocator>
40008c44: b0 10 00 08 mov %o0, %i0
return p;
}
40008c48: 81 c7 e0 08 ret
40008c4c: 81 e8 00 00 restore
40008c50 <_Protected_heap_Extend>:
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
uintptr_t size
)
{
40008c50: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
uintptr_t amount_extended;
_RTEMS_Lock_allocator();
40008c54: 7f ff f7 40 call 40006954 <_RTEMS_Lock_allocator>
<== NOT EXECUTED
40008c58: 01 00 00 00 nop
<== NOT EXECUTED
amount_extended = _Heap_Extend( the_heap, starting_address, size, 0 );
40008c5c: 96 10 20 00 clr %o3 ! 0 <PROM_START>
40008c60: 92 10 00 19 mov %i1, %o1
40008c64: 94 10 00 1a mov %i2, %o2
40008c68: 40 00 12 95 call 4000d6bc <_Heap_Extend>
40008c6c: 90 10 00 18 mov %i0, %o0
_RTEMS_Unlock_allocator();
40008c70: 7f ff f7 3e call 40006968 <_RTEMS_Unlock_allocator>
40008c74: ba 10 00 08 mov %o0, %i5
return amount_extended != 0;
}
40008c78: 80 a0 00 1d cmp %g0, %i5
40008c7c: b0 40 20 00 addx %g0, 0, %i0
40008c80: 81 c7 e0 08 ret
40008c84: 81 e8 00 00 restore
4000d1e4 <_Protected_heap_Get_free_information>:
bool _Protected_heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
)
{
4000d1e4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
/*
* TBD: _Heap_Get_free_information does not error check or return status.
*/
_RTEMS_Lock_allocator();
4000d1e8: 7f ff f2 c9 call 40009d0c <_RTEMS_Lock_allocator>
<== NOT EXECUTED
4000d1ec: 01 00 00 00 nop
<== NOT EXECUTED
_Heap_Get_free_information( the_heap, info );
4000d1f0: 90 10 00 18 mov %i0, %o0
4000d1f4: 92 10 00 19 mov %i1, %o1
4000d1f8: 40 00 14 73 call 400123c4 <_Heap_Get_free_information>
4000d1fc: b0 10 20 01 mov 1, %i0
_RTEMS_Unlock_allocator();
4000d200: 7f ff f2 c8 call 40009d20 <_RTEMS_Unlock_allocator>
4000d204: 01 00 00 00 nop
return true;
}
4000d208: 81 c7 e0 08 ret
4000d20c: 81 e8 00 00 restore
4000d210 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
4000d210: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( !the_heap )
return false;
if ( !the_info )
4000d214: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4000d218: 02 80 00 0e be 4000d250 <_Protected_heap_Get_information+0x40>
<== NOT EXECUTED
4000d21c: 80 a6 60 00 cmp %i1, 0
4000d220: 22 80 00 0d be,a 4000d254 <_Protected_heap_Get_information+0x44>
4000d224: b0 10 20 00 clr %i0
return false;
_RTEMS_Lock_allocator();
4000d228: 7f ff f2 b9 call 40009d0c <_RTEMS_Lock_allocator>
4000d22c: 01 00 00 00 nop
_Heap_Get_information( the_heap, the_info );
4000d230: 90 10 00 18 mov %i0, %o0
4000d234: 92 10 00 19 mov %i1, %o1
4000d238: 7f ff f4 88 call 4000a458 <_Heap_Get_information>
4000d23c: b0 10 20 01 mov 1, %i0
_RTEMS_Unlock_allocator();
4000d240: 7f ff f2 b8 call 40009d20 <_RTEMS_Unlock_allocator>
4000d244: b0 0e 20 01 and %i0, 1, %i0
return true;
}
4000d248: 81 c7 e0 08 ret
4000d24c: 81 e8 00 00 restore
return false;
4000d250: b0 10 20 00 clr %i0
}
4000d254: b0 0e 20 01 and %i0, 1, %i0
4000d258: 81 c7 e0 08 ret
4000d25c: 81 e8 00 00 restore
4000d260 <_Protected_heap_Walk>:
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
4000d260: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
enabled = _Thread_Dispatch_disable_level == 0;
4000d264: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
* then it is forbidden to lock a mutex. But since we are inside
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( _Thread_Dispatch_is_enabled() ) {
4000d268: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000d26c: 02 80 00 04 be 4000d27c <_Protected_heap_Walk+0x1c>
<== NOT EXECUTED
4000d270: 01 00 00 00 nop
_RTEMS_Lock_allocator();
status = _Heap_Walk( the_heap, source, do_dump );
_RTEMS_Unlock_allocator();
} else {
status = _Heap_Walk( the_heap, source, do_dump );
4000d274: 7f ff f6 78 call 4000ac54 <_Heap_Walk>
4000d278: 81 e8 00 00 restore
_RTEMS_Lock_allocator();
4000d27c: 7f ff f2 a4 call 40009d0c <_RTEMS_Lock_allocator>
4000d280: 01 00 00 00 nop
status = _Heap_Walk( the_heap, source, do_dump );
4000d284: 94 10 00 1a mov %i2, %o2
4000d288: 92 10 00 19 mov %i1, %o1
4000d28c: 7f ff f6 72 call 4000ac54 <_Heap_Walk>
4000d290: 90 10 00 18 mov %i0, %o0
_RTEMS_Unlock_allocator();
4000d294: 7f ff f2 a3 call 40009d20 <_RTEMS_Unlock_allocator>
4000d298: b0 10 00 08 mov %o0, %i0
}
return status;
}
4000d29c: 81 c7 e0 08 ret
4000d2a0: 81 e8 00 00 restore
4000930c <_RBTree_Extract>:
#include <rtems/score/rbtreeimpl.h>
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
4000930c: c6 02 40 00 ld [ %o1 ], %g3
<== NOT EXECUTED
40009310: 80 a0 e0 00 cmp %g3, 0
40009314: 02 80 00 d0 be 40009654 <_RBTree_Extract+0x348>
<== ALWAYS TAKEN
40009318: c4 02 60 04 ld [ %o1 + 4 ], %g2
4000931c: 80 a0 a0 00 cmp %g2, 0
40009320: 32 80 00 13 bne,a 4000936c <_RBTree_Extract+0x60>
40009324: c2 00 80 00 ld [ %g2 ], %g1
40009328: c2 02 60 08 ld [ %o1 + 8 ], %g1
4000932c: c8 02 60 0c ld [ %o1 + 0xc ], %g4
40009330: c2 20 e0 08 st %g1, [ %g3 + 8 ]
40009334: 80 a0 60 00 cmp %g1, 0
40009338: 22 80 00 cf be,a 40009674 <_RBTree_Extract+0x368>
4000933c: c6 22 00 00 st %g3, [ %o0 ]
40009340: c4 00 40 00 ld [ %g1 ], %g2
40009344: 80 a2 40 02 cmp %o1, %g2
40009348: 22 80 00 d3 be,a 40009694 <_RBTree_Extract+0x388>
4000934c: c6 20 40 00 st %g3, [ %g1 ]
40009350: c6 20 60 04 st %g3, [ %g1 + 4 ]
40009354: 80 a1 20 00 cmp %g4, 0
40009358: 02 80 00 55 be 400094ac <_RBTree_Extract+0x1a0>
4000935c: 9a 10 20 01 mov 1, %o5
)
{
_Assert( _RBTree_Find_root( the_node ) == _RBTree_Root( the_rbtree ) );
RB_REMOVE( RBTree_Control, the_rbtree, the_node );
_RBTree_Initialize_node( the_node );
}
40009360: 81 c3 e0 08 retl
40009364: 01 00 00 00 nop
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
40009368: c2 00 80 00 ld [ %g2 ], %g1
4000936c: 80 a0 60 00 cmp %g1, 0
40009370: 32 bf ff fe bne,a 40009368 <_RBTree_Extract+0x5c>
40009374: 84 10 00 01 mov %g1, %g2
40009378: c6 00 a0 04 ld [ %g2 + 4 ], %g3
4000937c: c2 00 a0 08 ld [ %g2 + 8 ], %g1
40009380: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
40009384: 80 a0 e0 00 cmp %g3, 0
40009388: 02 80 00 04 be 40009398 <_RBTree_Extract+0x8c>
4000938c: 9a 10 00 01 mov %g1, %o5
40009390: c2 20 e0 08 st %g1, [ %g3 + 8 ]
40009394: da 00 a0 08 ld [ %g2 + 8 ], %o5
40009398: 80 a0 60 00 cmp %g1, 0
4000939c: 22 80 00 07 be,a 400093b8 <_RBTree_Extract+0xac>
<== NEVER TAKEN
400093a0: c6 22 00 00 st %g3, [ %o0 ]
<== NOT EXECUTED
400093a4: d8 00 40 00 ld [ %g1 ], %o4
400093a8: 80 a0 80 0c cmp %g2, %o4
400093ac: 22 80 00 03 be,a 400093b8 <_RBTree_Extract+0xac>
400093b0: c6 20 40 00 st %g3, [ %g1 ]
400093b4: c6 20 60 04 st %g3, [ %g1 + 4 ]
400093b8: 80 a2 40 0d cmp %o1, %o5
400093bc: 22 80 00 02 be,a 400093c4 <_RBTree_Extract+0xb8>
400093c0: 82 10 00 02 mov %g2, %g1
400093c4: da 02 40 00 ld [ %o1 ], %o5
400093c8: da 20 80 00 st %o5, [ %g2 ]
400093cc: da 02 60 04 ld [ %o1 + 4 ], %o5
400093d0: da 20 a0 04 st %o5, [ %g2 + 4 ]
400093d4: da 02 60 08 ld [ %o1 + 8 ], %o5
400093d8: da 20 a0 08 st %o5, [ %g2 + 8 ]
400093dc: da 02 60 0c ld [ %o1 + 0xc ], %o5
400093e0: da 20 a0 0c st %o5, [ %g2 + 0xc ]
400093e4: da 02 60 08 ld [ %o1 + 8 ], %o5
400093e8: 80 a3 60 00 cmp %o5, 0
400093ec: 22 80 00 07 be,a 40009408 <_RBTree_Extract+0xfc>
400093f0: c4 22 00 00 st %g2, [ %o0 ]
400093f4: d8 03 40 00 ld [ %o5 ], %o4
400093f8: 80 a2 40 0c cmp %o1, %o4
400093fc: 22 80 00 03 be,a 40009408 <_RBTree_Extract+0xfc>
40009400: c4 23 40 00 st %g2, [ %o5 ]
40009404: c4 23 60 04 st %g2, [ %o5 + 4 ]
40009408: da 02 40 00 ld [ %o1 ], %o5
4000940c: c4 23 60 08 st %g2, [ %o5 + 8 ]
40009410: da 02 60 04 ld [ %o1 + 4 ], %o5
40009414: 80 a3 60 00 cmp %o5, 0
40009418: 32 80 00 02 bne,a 40009420 <_RBTree_Extract+0x114>
4000941c: c4 23 60 08 st %g2, [ %o5 + 8 ]
40009420: 80 a0 60 00 cmp %g1, 0
40009424: 02 bf ff cc be 40009354 <_RBTree_Extract+0x48>
<== NEVER TAKEN
40009428: 84 10 00 01 mov %g1, %g2
4000942c: c4 00 a0 08 ld [ %g2 + 8 ], %g2
40009430: 80 a0 a0 00 cmp %g2, 0
40009434: 32 bf ff ff bne,a 40009430 <_RBTree_Extract+0x124>
40009438: c4 00 a0 08 ld [ %g2 + 8 ], %g2
4000943c: 80 a1 20 00 cmp %g4, 0
40009440: 12 bf ff c8 bne 40009360 <_RBTree_Extract+0x54>
40009444: 9a 10 20 01 mov 1, %o5
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
40009448: 10 80 00 1a b 400094b0 <_RBTree_Extract+0x1a4>
4000944c: 80 a0 e0 00 cmp %g3, 0
40009450: 80 a0 e0 01 cmp %g3, 1
40009454: 22 80 00 54 be,a 400095a4 <_RBTree_Extract+0x298>
40009458: c8 00 a0 04 ld [ %g2 + 4 ], %g4
4000945c: c6 00 80 00 ld [ %g2 ], %g3
40009460: 80 a0 e0 00 cmp %g3, 0
40009464: 22 80 00 07 be,a 40009480 <_RBTree_Extract+0x174>
40009468: c8 00 a0 04 ld [ %g2 + 4 ], %g4
4000946c: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
40009470: 80 a1 20 00 cmp %g4, 0
40009474: 32 80 00 98 bne,a 400096d4 <_RBTree_Extract+0x3c8>
40009478: da 00 60 0c ld [ %g1 + 0xc ], %o5
4000947c: c8 00 a0 04 ld [ %g2 + 4 ], %g4
40009480: 80 a1 20 00 cmp %g4, 0
40009484: 22 80 00 07 be,a 400094a0 <_RBTree_Extract+0x194>
40009488: da 20 a0 0c st %o5, [ %g2 + 0xc ]
4000948c: d8 01 20 0c ld [ %g4 + 0xc ], %o4
40009490: 80 a3 20 00 cmp %o4, 0
40009494: 12 80 00 89 bne 400096b8 <_RBTree_Extract+0x3ac>
40009498: 80 a0 e0 00 cmp %g3, 0
4000949c: da 20 a0 0c st %o5, [ %g2 + 0xc ]
400094a0: 86 10 00 01 mov %g1, %g3
400094a4: c4 00 60 08 ld [ %g1 + 8 ], %g2
400094a8: 82 10 00 02 mov %g2, %g1
400094ac: 80 a0 e0 00 cmp %g3, 0
400094b0: 22 80 00 07 be,a 400094cc <_RBTree_Extract+0x1c0>
400094b4: c4 02 00 00 ld [ %o0 ], %g2
400094b8: c4 00 e0 0c ld [ %g3 + 0xc ], %g2
400094bc: 80 a0 a0 00 cmp %g2, 0
400094c0: 12 80 00 37 bne 4000959c <_RBTree_Extract+0x290>
400094c4: 01 00 00 00 nop
400094c8: c4 02 00 00 ld [ %o0 ], %g2
400094cc: 80 a0 c0 02 cmp %g3, %g2
400094d0: 02 80 00 31 be 40009594 <_RBTree_Extract+0x288>
400094d4: 80 a0 e0 00 cmp %g3, 0
400094d8: c4 00 40 00 ld [ %g1 ], %g2
400094dc: 80 a0 80 03 cmp %g2, %g3
400094e0: 32 bf ff dc bne,a 40009450 <_RBTree_Extract+0x144>
400094e4: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
400094e8: c4 00 60 04 ld [ %g1 + 4 ], %g2
400094ec: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
400094f0: 80 a1 20 01 cmp %g4, 1
400094f4: 02 80 00 40 be 400095f4 <_RBTree_Extract+0x2e8>
400094f8: c6 00 80 00 ld [ %g2 ], %g3
400094fc: 80 a0 e0 00 cmp %g3, 0
40009500: 22 80 00 06 be,a 40009518 <_RBTree_Extract+0x20c>
40009504: c8 00 a0 04 ld [ %g2 + 4 ], %g4
40009508: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
4000950c: 80 a1 20 00 cmp %g4, 0
40009510: 12 80 00 ac bne 400097c0 <_RBTree_Extract+0x4b4>
40009514: c8 00 a0 04 ld [ %g2 + 4 ], %g4
40009518: 80 a1 20 00 cmp %g4, 0
4000951c: 22 bf ff e1 be,a 400094a0 <_RBTree_Extract+0x194>
40009520: da 20 a0 0c st %o5, [ %g2 + 0xc ]
40009524: c6 01 20 0c ld [ %g4 + 0xc ], %g3
40009528: 80 a0 e0 00 cmp %g3, 0
4000952c: 22 bf ff dd be,a 400094a0 <_RBTree_Extract+0x194>
40009530: da 20 a0 0c st %o5, [ %g2 + 0xc ]
40009534: c6 00 60 0c ld [ %g1 + 0xc ], %g3
40009538: da 00 60 04 ld [ %g1 + 4 ], %o5
4000953c: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
40009540: c0 20 60 0c clr [ %g1 + 0xc ]
40009544: c0 21 20 0c clr [ %g4 + 0xc ]
40009548: c4 03 40 00 ld [ %o5 ], %g2
4000954c: 80 a0 a0 00 cmp %g2, 0
40009550: 02 80 00 03 be 4000955c <_RBTree_Extract+0x250>
40009554: c4 20 60 04 st %g2, [ %g1 + 4 ]
40009558: c2 20 a0 08 st %g1, [ %g2 + 8 ]
4000955c: c4 00 60 08 ld [ %g1 + 8 ], %g2
40009560: 80 a0 a0 00 cmp %g2, 0
40009564: 02 80 00 c1 be 40009868 <_RBTree_Extract+0x55c>
40009568: c4 23 60 08 st %g2, [ %o5 + 8 ]
4000956c: c4 00 60 08 ld [ %g1 + 8 ], %g2
40009570: c6 00 80 00 ld [ %g2 ], %g3
40009574: 80 a0 40 03 cmp %g1, %g3
40009578: 22 80 00 c1 be,a 4000987c <_RBTree_Extract+0x570>
4000957c: da 20 80 00 st %o5, [ %g2 ]
40009580: da 20 a0 04 st %o5, [ %g2 + 4 ]
40009584: c6 02 00 00 ld [ %o0 ], %g3
40009588: c2 23 40 00 st %g1, [ %o5 ]
4000958c: da 20 60 08 st %o5, [ %g1 + 8 ]
40009590: 80 a0 e0 00 cmp %g3, 0
40009594: 02 bf ff 73 be 40009360 <_RBTree_Extract+0x54>
40009598: 01 00 00 00 nop
}
4000959c: 81 c3 e0 08 retl
400095a0: c0 20 e0 0c clr [ %g3 + 0xc ]
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
400095a4: c0 20 a0 0c clr [ %g2 + 0xc ]
400095a8: 80 a1 20 00 cmp %g4, 0
400095ac: c6 20 60 0c st %g3, [ %g1 + 0xc ]
400095b0: 02 80 00 03 be 400095bc <_RBTree_Extract+0x2b0>
<== NEVER TAKEN
400095b4: c8 20 40 00 st %g4, [ %g1 ]
400095b8: c2 21 20 08 st %g1, [ %g4 + 8 ]
400095bc: c6 00 60 08 ld [ %g1 + 8 ], %g3
400095c0: 80 a0 e0 00 cmp %g3, 0
400095c4: 02 80 00 22 be 4000964c <_RBTree_Extract+0x340>
400095c8: c6 20 a0 08 st %g3, [ %g2 + 8 ]
400095cc: c6 00 60 08 ld [ %g1 + 8 ], %g3
400095d0: d8 00 c0 00 ld [ %g3 ], %o4
400095d4: 80 a0 40 0c cmp %g1, %o4
400095d8: 22 80 00 25 be,a 4000966c <_RBTree_Extract+0x360>
400095dc: c4 20 c0 00 st %g2, [ %g3 ]
400095e0: c4 20 e0 04 st %g2, [ %g3 + 4 ]
400095e4: c2 20 a0 04 st %g1, [ %g2 + 4 ]
400095e8: c4 20 60 08 st %g2, [ %g1 + 8 ]
400095ec: 10 bf ff 9c b 4000945c <_RBTree_Extract+0x150>
400095f0: 84 10 00 04 mov %g4, %g2
400095f4: c0 20 a0 0c clr [ %g2 + 0xc ]
400095f8: 80 a0 e0 00 cmp %g3, 0
400095fc: c8 20 60 0c st %g4, [ %g1 + 0xc ]
40009600: 02 80 00 03 be 4000960c <_RBTree_Extract+0x300>
<== NEVER TAKEN
40009604: c6 20 60 04 st %g3, [ %g1 + 4 ]
40009608: c2 20 e0 08 st %g1, [ %g3 + 8 ]
4000960c: c8 00 60 08 ld [ %g1 + 8 ], %g4
40009610: 80 a1 20 00 cmp %g4, 0
40009614: 02 80 00 1d be 40009688 <_RBTree_Extract+0x37c>
40009618: c8 20 a0 08 st %g4, [ %g2 + 8 ]
4000961c: c8 00 60 08 ld [ %g1 + 8 ], %g4
40009620: d8 01 00 00 ld [ %g4 ], %o4
40009624: 80 a0 40 0c cmp %g1, %o4
40009628: 22 80 00 22 be,a 400096b0 <_RBTree_Extract+0x3a4>
4000962c: c4 21 00 00 st %g2, [ %g4 ]
40009630: c4 21 20 04 st %g2, [ %g4 + 4 ]
40009634: c8 00 60 04 ld [ %g1 + 4 ], %g4
40009638: c2 20 80 00 st %g1, [ %g2 ]
4000963c: c6 01 00 00 ld [ %g4 ], %g3
40009640: c4 20 60 08 st %g2, [ %g1 + 8 ]
40009644: 10 bf ff ae b 400094fc <_RBTree_Extract+0x1f0>
40009648: 84 10 00 04 mov %g4, %g2
4000964c: 10 bf ff e6 b 400095e4 <_RBTree_Extract+0x2d8>
40009650: c4 22 00 00 st %g2, [ %o0 ]
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
40009654: c2 02 60 08 ld [ %o1 + 8 ], %g1
40009658: 80 a0 a0 00 cmp %g2, 0
4000965c: 02 bf ff 36 be 40009334 <_RBTree_Extract+0x28>
40009660: c8 02 60 0c ld [ %o1 + 0xc ], %g4
40009664: 10 bf ff 33 b 40009330 <_RBTree_Extract+0x24>
40009668: 86 10 00 02 mov %g2, %g3
4000966c: 10 bf ff de b 400095e4 <_RBTree_Extract+0x2d8>
40009670: c8 00 40 00 ld [ %g1 ], %g4
40009674: 80 a1 20 00 cmp %g4, 0
40009678: 12 bf ff 3a bne 40009360 <_RBTree_Extract+0x54>
<== NEVER TAKEN
4000967c: 9a 10 20 01 mov 1, %o5
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
40009680: 10 bf ff 8c b 400094b0 <_RBTree_Extract+0x1a4>
40009684: 80 a0 e0 00 cmp %g3, 0
40009688: c4 22 00 00 st %g2, [ %o0 ]
4000968c: 10 bf ff eb b 40009638 <_RBTree_Extract+0x32c>
40009690: 88 10 00 03 mov %g3, %g4
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
40009694: 80 a1 20 00 cmp %g4, 0
40009698: 12 bf ff 32 bne 40009360 <_RBTree_Extract+0x54>
4000969c: 9a 10 20 01 mov 1, %o5
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
400096a0: 10 bf ff 84 b 400094b0 <_RBTree_Extract+0x1a4>
400096a4: 80 a0 e0 00 cmp %g3, 0
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
400096a8: 10 bf ff 58 b 40009408 <_RBTree_Extract+0xfc>
<== NOT EXECUTED
400096ac: c4 23 40 00 st %g2, [ %o5 ]
<== NOT EXECUTED
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
400096b0: 10 bf ff e2 b 40009638 <_RBTree_Extract+0x32c>
400096b4: 88 10 00 03 mov %g3, %g4
400096b8: 22 80 00 21 be,a 4000973c <_RBTree_Extract+0x430>
400096bc: c6 01 00 00 ld [ %g4 ], %g3
400096c0: da 00 e0 0c ld [ %g3 + 0xc ], %o5
400096c4: 80 a3 60 00 cmp %o5, 0
400096c8: 22 80 00 1d be,a 4000973c <_RBTree_Extract+0x430>
<== ALWAYS TAKEN
400096cc: c6 01 00 00 ld [ %g4 ], %g3
400096d0: da 00 60 0c ld [ %g1 + 0xc ], %o5
<== NOT EXECUTED
400096d4: c8 00 40 00 ld [ %g1 ], %g4
400096d8: da 20 a0 0c st %o5, [ %g2 + 0xc ]
400096dc: c0 20 60 0c clr [ %g1 + 0xc ]
400096e0: c0 20 e0 0c clr [ %g3 + 0xc ]
400096e4: c4 01 20 04 ld [ %g4 + 4 ], %g2
400096e8: 80 a0 a0 00 cmp %g2, 0
400096ec: 02 80 00 03 be 400096f8 <_RBTree_Extract+0x3ec>
400096f0: c4 20 40 00 st %g2, [ %g1 ]
400096f4: c2 20 a0 08 st %g1, [ %g2 + 8 ]
400096f8: c4 00 60 08 ld [ %g1 + 8 ], %g2
400096fc: 80 a0 a0 00 cmp %g2, 0
40009700: 02 80 00 2b be 400097ac <_RBTree_Extract+0x4a0>
40009704: c4 21 20 08 st %g2, [ %g4 + 8 ]
40009708: c4 00 60 08 ld [ %g1 + 8 ], %g2
4000970c: c6 00 80 00 ld [ %g2 ], %g3
40009710: 80 a0 40 03 cmp %g1, %g3
40009714: 22 80 00 4f be,a 40009850 <_RBTree_Extract+0x544>
40009718: c8 20 80 00 st %g4, [ %g2 ]
4000971c: c8 20 a0 04 st %g4, [ %g2 + 4 ]
40009720: c6 02 00 00 ld [ %o0 ], %g3
40009724: c2 21 20 04 st %g1, [ %g4 + 4 ]
40009728: c8 20 60 08 st %g4, [ %g1 + 8 ]
4000972c: 80 a0 e0 00 cmp %g3, 0
40009730: 12 bf ff 9b bne 4000959c <_RBTree_Extract+0x290>
<== ALWAYS TAKEN
40009734: 01 00 00 00 nop
40009738: 30 bf ff 0a b,a 40009360 <_RBTree_Extract+0x54>
<== NOT EXECUTED
4000973c: c0 21 20 0c clr [ %g4 + 0xc ]
40009740: 9a 10 20 01 mov 1, %o5
40009744: c6 20 a0 04 st %g3, [ %g2 + 4 ]
40009748: 80 a0 e0 00 cmp %g3, 0
4000974c: 02 80 00 03 be 40009758 <_RBTree_Extract+0x44c>
40009750: da 20 a0 0c st %o5, [ %g2 + 0xc ]
40009754: c4 20 e0 08 st %g2, [ %g3 + 8 ]
40009758: c6 00 a0 08 ld [ %g2 + 8 ], %g3
4000975c: 80 a0 e0 00 cmp %g3, 0
40009760: 02 80 00 40 be 40009860 <_RBTree_Extract+0x554>
<== NEVER TAKEN
40009764: c6 21 20 08 st %g3, [ %g4 + 8 ]
40009768: c6 00 a0 08 ld [ %g2 + 8 ], %g3
4000976c: da 00 c0 00 ld [ %g3 ], %o5
40009770: 80 a0 80 0d cmp %g2, %o5
40009774: 22 80 00 03 be,a 40009780 <_RBTree_Extract+0x474>
<== ALWAYS TAKEN
40009778: c8 20 c0 00 st %g4, [ %g3 ]
4000977c: c8 20 e0 04 st %g4, [ %g3 + 4 ]
<== NOT EXECUTED
40009780: c4 21 00 00 st %g2, [ %g4 ]
40009784: c8 20 a0 08 st %g4, [ %g2 + 8 ]
40009788: c8 00 40 00 ld [ %g1 ], %g4
4000978c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40009790: c4 21 20 0c st %g2, [ %g4 + 0xc ]
40009794: c6 01 00 00 ld [ %g4 ], %g3
40009798: 80 a0 e0 00 cmp %g3, 0
4000979c: 02 bf ff d2 be 400096e4 <_RBTree_Extract+0x3d8>
<== NEVER TAKEN
400097a0: c0 20 60 0c clr [ %g1 + 0xc ]
400097a4: 10 bf ff d0 b 400096e4 <_RBTree_Extract+0x3d8>
400097a8: c0 20 e0 0c clr [ %g3 + 0xc ]
400097ac: c8 22 00 00 st %g4, [ %o0 ]
400097b0: 86 10 00 04 mov %g4, %g3
400097b4: c2 21 20 04 st %g1, [ %g4 + 4 ]
400097b8: 10 bf ff dd b 4000972c <_RBTree_Extract+0x420>
400097bc: c8 20 60 08 st %g4, [ %g1 + 8 ]
400097c0: 80 a1 20 00 cmp %g4, 0
400097c4: 22 80 00 07 be,a 400097e0 <_RBTree_Extract+0x4d4>
400097c8: c8 00 e0 04 ld [ %g3 + 4 ], %g4
400097cc: da 01 20 0c ld [ %g4 + 0xc ], %o5
400097d0: 80 a3 60 00 cmp %o5, 0
400097d4: 32 bf ff 59 bne,a 40009538 <_RBTree_Extract+0x22c>
400097d8: c6 00 60 0c ld [ %g1 + 0xc ], %g3
400097dc: c8 00 e0 04 ld [ %g3 + 4 ], %g4
400097e0: c0 20 e0 0c clr [ %g3 + 0xc ]
400097e4: 9a 10 20 01 mov 1, %o5
400097e8: c8 20 80 00 st %g4, [ %g2 ]
400097ec: 80 a1 20 00 cmp %g4, 0
400097f0: 02 80 00 03 be 400097fc <_RBTree_Extract+0x4f0>
400097f4: da 20 a0 0c st %o5, [ %g2 + 0xc ]
400097f8: c4 21 20 08 st %g2, [ %g4 + 8 ]
400097fc: c8 00 a0 08 ld [ %g2 + 8 ], %g4
40009800: 80 a1 20 00 cmp %g4, 0
40009804: 02 80 00 22 be 4000988c <_RBTree_Extract+0x580>
<== NEVER TAKEN
40009808: c8 20 e0 08 st %g4, [ %g3 + 8 ]
4000980c: c8 00 a0 08 ld [ %g2 + 8 ], %g4
40009810: da 01 00 00 ld [ %g4 ], %o5
40009814: 80 a0 80 0d cmp %g2, %o5
40009818: 22 80 00 03 be,a 40009824 <_RBTree_Extract+0x518>
<== NEVER TAKEN
4000981c: c6 21 00 00 st %g3, [ %g4 ]
<== NOT EXECUTED
40009820: c6 21 20 04 st %g3, [ %g4 + 4 ]
40009824: c4 20 e0 04 st %g2, [ %g3 + 4 ]
40009828: c6 20 a0 08 st %g3, [ %g2 + 8 ]
4000982c: da 00 60 04 ld [ %g1 + 4 ], %o5
40009830: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40009834: c4 23 60 0c st %g2, [ %o5 + 0xc ]
40009838: c8 03 60 04 ld [ %o5 + 4 ], %g4
4000983c: 80 a1 20 00 cmp %g4, 0
40009840: 02 bf ff 42 be 40009548 <_RBTree_Extract+0x23c>
<== NEVER TAKEN
40009844: c0 20 60 0c clr [ %g1 + 0xc ]
40009848: 10 bf ff 40 b 40009548 <_RBTree_Extract+0x23c>
4000984c: c0 21 20 0c clr [ %g4 + 0xc ]
40009850: c6 02 00 00 ld [ %o0 ], %g3
40009854: c2 21 20 04 st %g1, [ %g4 + 4 ]
40009858: 10 bf ff b5 b 4000972c <_RBTree_Extract+0x420>
4000985c: c8 20 60 08 st %g4, [ %g1 + 8 ]
40009860: 10 bf ff c8 b 40009780 <_RBTree_Extract+0x474>
<== NOT EXECUTED
40009864: c8 22 00 00 st %g4, [ %o0 ]
<== NOT EXECUTED
40009868: da 22 00 00 st %o5, [ %o0 ]
4000986c: 86 10 00 0d mov %o5, %g3
40009870: c2 23 40 00 st %g1, [ %o5 ]
40009874: 10 bf ff 47 b 40009590 <_RBTree_Extract+0x284>
40009878: da 20 60 08 st %o5, [ %g1 + 8 ]
4000987c: c6 02 00 00 ld [ %o0 ], %g3
40009880: c2 23 40 00 st %g1, [ %o5 ]
40009884: 10 bf ff 43 b 40009590 <_RBTree_Extract+0x284>
40009888: da 20 60 08 st %o5, [ %g1 + 8 ]
4000988c: 10 bf ff e6 b 40009824 <_RBTree_Extract+0x518>
<== NOT EXECUTED
40009890: c6 22 00 00 st %g3, [ %o0 ]
<== NOT EXECUTED
40009894 <_RBTree_Insert_color>:
#include "config.h"
#endif
#include <rtems/score/rbtreeimpl.h>
RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline )
40009894: 98 10 20 01 mov 1, %o4
<== NOT EXECUTED
40009898: c2 02 60 08 ld [ %o1 + 8 ], %g1
4000989c: 80 a0 60 00 cmp %g1, 0
400098a0: 22 80 00 2f be,a 4000995c <_RBTree_Insert_color+0xc8>
400098a4: c2 02 00 00 ld [ %o0 ], %g1
400098a8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
400098ac: 80 a0 a0 01 cmp %g2, 1
400098b0: 32 80 00 2b bne,a 4000995c <_RBTree_Insert_color+0xc8>
400098b4: c2 02 00 00 ld [ %o0 ], %g1
400098b8: c6 00 60 08 ld [ %g1 + 8 ], %g3
400098bc: c8 00 c0 00 ld [ %g3 ], %g4
400098c0: 80 a0 40 04 cmp %g1, %g4
400098c4: 02 80 00 28 be 40009964 <_RBTree_Insert_color+0xd0>
400098c8: 84 10 00 03 mov %g3, %g2
400098cc: 80 a1 20 00 cmp %g4, 0
400098d0: 22 80 00 07 be,a 400098ec <_RBTree_Insert_color+0x58>
400098d4: c8 00 40 00 ld [ %g1 ], %g4
400098d8: da 01 20 0c ld [ %g4 + 0xc ], %o5
400098dc: 80 a3 60 01 cmp %o5, 1
400098e0: 22 80 00 58 be,a 40009a40 <_RBTree_Insert_color+0x1ac>
400098e4: c0 21 20 0c clr [ %g4 + 0xc ]
400098e8: c8 00 40 00 ld [ %g1 ], %g4
400098ec: 80 a2 40 04 cmp %o1, %g4
400098f0: 22 80 00 3c be,a 400099e0 <_RBTree_Insert_color+0x14c>
400098f4: c8 02 60 04 ld [ %o1 + 4 ], %g4
400098f8: c6 00 a0 04 ld [ %g2 + 4 ], %g3
400098fc: c0 20 60 0c clr [ %g1 + 0xc ]
40009900: c2 00 c0 00 ld [ %g3 ], %g1
40009904: c2 20 a0 04 st %g1, [ %g2 + 4 ]
40009908: 80 a0 60 00 cmp %g1, 0
4000990c: 02 80 00 03 be 40009918 <_RBTree_Insert_color+0x84>
40009910: d8 20 a0 0c st %o4, [ %g2 + 0xc ]
40009914: c4 20 60 08 st %g2, [ %g1 + 8 ]
40009918: c2 00 a0 08 ld [ %g2 + 8 ], %g1
4000991c: 80 a0 60 00 cmp %g1, 0
40009920: 02 80 00 44 be 40009a30 <_RBTree_Insert_color+0x19c>
40009924: c2 20 e0 08 st %g1, [ %g3 + 8 ]
40009928: c2 00 a0 08 ld [ %g2 + 8 ], %g1
4000992c: c8 00 40 00 ld [ %g1 ], %g4
40009930: 80 a0 80 04 cmp %g2, %g4
40009934: 22 80 00 47 be,a 40009a50 <_RBTree_Insert_color+0x1bc>
40009938: c6 20 40 00 st %g3, [ %g1 ]
4000993c: c6 20 60 04 st %g3, [ %g1 + 4 ]
40009940: c4 20 c0 00 st %g2, [ %g3 ]
40009944: c6 20 a0 08 st %g3, [ %g2 + 8 ]
40009948: c2 02 60 08 ld [ %o1 + 8 ], %g1
4000994c: 80 a0 60 00 cmp %g1, 0
40009950: 32 bf ff d7 bne,a 400098ac <_RBTree_Insert_color+0x18> <== ALWAYS TAKEN
40009954: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40009958: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Control_RB_INSERT_COLOR( the_rbtree, the_node );
}
4000995c: 81 c3 e0 08 retl
40009960: c0 20 60 0c clr [ %g1 + 0xc ]
RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline )
40009964: c8 00 e0 04 ld [ %g3 + 4 ], %g4
40009968: 80 a1 20 00 cmp %g4, 0
4000996c: 22 80 00 07 be,a 40009988 <_RBTree_Insert_color+0xf4>
40009970: da 00 60 04 ld [ %g1 + 4 ], %o5
40009974: da 01 20 0c ld [ %g4 + 0xc ], %o5
40009978: 80 a3 60 01 cmp %o5, 1
4000997c: 22 80 00 31 be,a 40009a40 <_RBTree_Insert_color+0x1ac>
40009980: c0 21 20 0c clr [ %g4 + 0xc ]
40009984: da 00 60 04 ld [ %g1 + 4 ], %o5
40009988: 80 a3 40 09 cmp %o5, %o1
4000998c: 02 80 00 3a be 40009a74 <_RBTree_Insert_color+0x1e0>
40009990: 88 10 00 01 mov %g1, %g4
40009994: c0 20 60 0c clr [ %g1 + 0xc ]
40009998: 80 a3 60 00 cmp %o5, 0
4000999c: d8 20 a0 0c st %o4, [ %g2 + 0xc ]
400099a0: 02 80 00 03 be 400099ac <_RBTree_Insert_color+0x118>
400099a4: da 20 80 00 st %o5, [ %g2 ]
400099a8: c4 23 60 08 st %g2, [ %o5 + 8 ]
400099ac: c2 00 a0 08 ld [ %g2 + 8 ], %g1
400099b0: 80 a0 60 00 cmp %g1, 0
400099b4: 02 80 00 2c be 40009a64 <_RBTree_Insert_color+0x1d0>
400099b8: c2 21 20 08 st %g1, [ %g4 + 8 ]
400099bc: c2 00 a0 08 ld [ %g2 + 8 ], %g1
400099c0: c6 00 40 00 ld [ %g1 ], %g3
400099c4: 80 a0 80 03 cmp %g2, %g3
400099c8: 22 80 00 4a be,a 40009af0 <_RBTree_Insert_color+0x25c>
400099cc: c8 20 40 00 st %g4, [ %g1 ]
400099d0: c8 20 60 04 st %g4, [ %g1 + 4 ]
400099d4: c4 21 20 04 st %g2, [ %g4 + 4 ]
400099d8: 10 bf ff b0 b 40009898 <_RBTree_Insert_color+0x4>
400099dc: c8 20 a0 08 st %g4, [ %g2 + 8 ]
400099e0: 80 a1 20 00 cmp %g4, 0
400099e4: 02 80 00 3b be 40009ad0 <_RBTree_Insert_color+0x23c>
400099e8: c8 20 40 00 st %g4, [ %g1 ]
400099ec: c2 21 20 08 st %g1, [ %g4 + 8 ]
400099f0: c6 00 60 08 ld [ %g1 + 8 ], %g3
400099f4: 80 a0 e0 00 cmp %g3, 0
400099f8: 02 80 00 19 be 40009a5c <_RBTree_Insert_color+0x1c8>
<== NEVER TAKEN
400099fc: c6 22 60 08 st %g3, [ %o1 + 8 ]
40009a00: c6 00 60 08 ld [ %g1 + 8 ], %g3
40009a04: c8 00 c0 00 ld [ %g3 ], %g4
40009a08: 80 a0 40 04 cmp %g1, %g4
40009a0c: 22 80 00 03 be,a 40009a18 <_RBTree_Insert_color+0x184> <== NEVER TAKEN
40009a10: d2 20 c0 00 st %o1, [ %g3 ]
<== NOT EXECUTED
40009a14: d2 20 e0 04 st %o1, [ %g3 + 4 ]
40009a18: 86 10 00 09 mov %o1, %g3
40009a1c: c2 22 60 04 st %g1, [ %o1 + 4 ]
40009a20: d2 20 60 08 st %o1, [ %g1 + 8 ]
40009a24: 92 10 00 01 mov %g1, %o1
40009a28: 10 bf ff b4 b 400098f8 <_RBTree_Insert_color+0x64>
40009a2c: 82 10 00 03 mov %g3, %g1
40009a30: c6 22 00 00 st %g3, [ %o0 ]
40009a34: c4 20 c0 00 st %g2, [ %g3 ]
40009a38: 10 bf ff c4 b 40009948 <_RBTree_Insert_color+0xb4>
40009a3c: c6 20 a0 08 st %g3, [ %g2 + 8 ]
40009a40: 92 10 00 03 mov %g3, %o1
40009a44: c0 20 60 0c clr [ %g1 + 0xc ]
40009a48: 10 bf ff 94 b 40009898 <_RBTree_Insert_color+0x4>
40009a4c: da 20 e0 0c st %o5, [ %g3 + 0xc ]
40009a50: c4 20 c0 00 st %g2, [ %g3 ]
40009a54: 10 bf ff bd b 40009948 <_RBTree_Insert_color+0xb4>
40009a58: c6 20 a0 08 st %g3, [ %g2 + 8 ]
40009a5c: 10 bf ff ef b 40009a18 <_RBTree_Insert_color+0x184>
<== NOT EXECUTED
40009a60: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
40009a64: c8 22 00 00 st %g4, [ %o0 ]
40009a68: c4 21 20 04 st %g2, [ %g4 + 4 ]
40009a6c: 10 bf ff 8b b 40009898 <_RBTree_Insert_color+0x4>
40009a70: c8 20 a0 08 st %g4, [ %g2 + 8 ]
40009a74: c8 02 40 00 ld [ %o1 ], %g4
40009a78: 80 a1 20 00 cmp %g4, 0
40009a7c: 02 80 00 04 be 40009a8c <_RBTree_Insert_color+0x1f8>
40009a80: c8 20 60 04 st %g4, [ %g1 + 4 ]
40009a84: c2 21 20 08 st %g1, [ %g4 + 8 ]
40009a88: c6 00 60 08 ld [ %g1 + 8 ], %g3
40009a8c: 80 a0 e0 00 cmp %g3, 0
40009a90: 02 80 00 1b be 40009afc <_RBTree_Insert_color+0x268>
<== NEVER TAKEN
40009a94: c6 22 60 08 st %g3, [ %o1 + 8 ]
40009a98: c6 00 60 08 ld [ %g1 + 8 ], %g3
40009a9c: c8 00 c0 00 ld [ %g3 ], %g4
40009aa0: 80 a0 40 04 cmp %g1, %g4
40009aa4: 22 80 00 03 be,a 40009ab0 <_RBTree_Insert_color+0x21c> <== ALWAYS TAKEN
40009aa8: d2 20 c0 00 st %o1, [ %g3 ]
40009aac: d2 20 e0 04 st %o1, [ %g3 + 4 ]
<== NOT EXECUTED
40009ab0: 86 10 00 09 mov %o1, %g3
40009ab4: c2 22 40 00 st %g1, [ %o1 ]
40009ab8: c8 00 80 00 ld [ %g2 ], %g4
40009abc: da 01 20 04 ld [ %g4 + 4 ], %o5
40009ac0: d2 20 60 08 st %o1, [ %g1 + 8 ]
40009ac4: 92 10 00 01 mov %g1, %o1
40009ac8: 10 bf ff b3 b 40009994 <_RBTree_Insert_color+0x100>
40009acc: 82 10 00 03 mov %g3, %g1
40009ad0: c6 22 60 08 st %g3, [ %o1 + 8 ]
40009ad4: c6 00 60 08 ld [ %g1 + 8 ], %g3
40009ad8: c8 00 c0 00 ld [ %g3 ], %g4
40009adc: 80 a0 40 04 cmp %g1, %g4
40009ae0: 32 bf ff ce bne,a 40009a18 <_RBTree_Insert_color+0x184> <== ALWAYS TAKEN
40009ae4: d2 20 e0 04 st %o1, [ %g3 + 4 ]
40009ae8: 10 bf ff cc b 40009a18 <_RBTree_Insert_color+0x184>
<== NOT EXECUTED
40009aec: d2 20 c0 00 st %o1, [ %g3 ]
<== NOT EXECUTED
40009af0: c4 21 20 04 st %g2, [ %g4 + 4 ]
40009af4: 10 bf ff 69 b 40009898 <_RBTree_Insert_color+0x4>
40009af8: c8 20 a0 08 st %g4, [ %g2 + 8 ]
40009afc: 10 bf ff ed b 40009ab0 <_RBTree_Insert_color+0x21c>
<== NOT EXECUTED
40009b00: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
40009de0 <_RBTree_Iterate>:
void _RBTree_Iterate(
const RBTree_Control *rbtree,
RBTree_Visitor visitor,
void *visitor_arg
)
{
40009de0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
const RBTree_Node *current = _RBTree_Minimum( rbtree );
40009de4: 40 00 00 12 call 40009e2c <_RBTree_Minimum>
<== NOT EXECUTED
40009de8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40009dec: 10 80 00 0b b 40009e18 <_RBTree_Iterate+0x38>
40009df0: ba 10 00 08 mov %o0, %i5
bool stop = false;
while ( !stop && current != NULL ) {
stop = ( *visitor )( current, visitor_arg );
40009df4: 9f c6 40 00 call %i1
40009df8: 90 10 00 1d mov %i5, %o0
40009dfc: b8 10 00 08 mov %o0, %i4
current = _RBTree_Successor( current );
40009e00: 40 00 00 18 call 40009e60 <_RBTree_Successor>
40009e04: 90 10 00 1d mov %i5, %o0
while ( !stop && current != NULL ) {
40009e08: b8 1f 20 01 xor %i4, 1, %i4
40009e0c: 80 8f 20 ff btst 0xff, %i4
40009e10: 02 80 00 05 be 40009e24 <_RBTree_Iterate+0x44>
<== NEVER TAKEN
40009e14: ba 10 00 08 mov %o0, %i5
40009e18: 80 a7 60 00 cmp %i5, 0
40009e1c: 12 bf ff f6 bne 40009df4 <_RBTree_Iterate+0x14>
40009e20: 92 10 00 1a mov %i2, %o1
}
}
40009e24: 81 c7 e0 08 ret
40009e28: 81 e8 00 00 restore
40017838 <_RBTree_Maximum>:
RB_GENERATE_MINMAX( RBTree_Control, RBTree_Node, Node, static )
40017838: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
4001783c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40017840: 32 80 00 04 bne,a 40017850 <_RBTree_Maximum+0x18>
<== NOT EXECUTED
40017844: c2 02 20 04 ld [ %o0 + 4 ], %g1
40017848: 30 80 00 07 b,a 40017864 <_RBTree_Maximum+0x2c>
4001784c: c2 02 20 04 ld [ %o0 + 4 ], %g1
40017850: 80 a0 60 00 cmp %g1, 0
40017854: 32 bf ff fe bne,a 4001784c <_RBTree_Maximum+0x14>
40017858: 90 10 00 01 mov %g1, %o0
RBTree_Node *_RBTree_Maximum( const RBTree_Control *tree )
{
return RB_MAX( RBTree_Control, RTEMS_DECONST( RBTree_Control *, tree ) );
}
4001785c: 81 c3 e0 08 retl
40017860: 01 00 00 00 nop
40017864: 81 c3 e0 08 retl
40017868: 01 00 00 00 nop
4000e1b8 <_RBTree_Minimum>:
#endif
#include <rtems/score/rbtreeimpl.h>
#include <rtems/score/basedefs.h>
RB_GENERATE_MINMAX( RBTree_Control, RBTree_Node, Node, static )
4000e1b8: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
4000e1bc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e1c0: 32 80 00 04 bne,a 4000e1d0 <_RBTree_Minimum+0x18>
<== NOT EXECUTED
4000e1c4: c2 02 00 00 ld [ %o0 ], %g1
4000e1c8: 30 80 00 07 b,a 4000e1e4 <_RBTree_Minimum+0x2c>
4000e1cc: c2 02 00 00 ld [ %o0 ], %g1
4000e1d0: 80 a0 60 00 cmp %g1, 0
4000e1d4: 32 bf ff fe bne,a 4000e1cc <_RBTree_Minimum+0x14>
4000e1d8: 90 10 00 01 mov %g1, %o0
RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static )
RBTree_Node *_RBTree_Minimum( const RBTree_Control *tree )
{
return RB_MIN( RBTree_Control, RTEMS_DECONST( RBTree_Control *, tree ) );
}
4000e1dc: 81 c3 e0 08 retl
4000e1e0: 01 00 00 00 nop
4000e1e4: 81 c3 e0 08 retl
4000e1e8: 01 00 00 00 nop
400179f0 <_RBTree_Postorder_first>:
return RB_ROOT( the_rbtree );
400179f0: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
)
{
const RBTree_Node *the_node;
the_node = _RBTree_Root( the_rbtree );
if ( the_node == NULL ) {
400179f4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400179f8: 02 80 00 0d be 40017a2c <_RBTree_Postorder_first+0x3c>
<== NOT EXECUTED
400179fc: 01 00 00 00 nop
if ( _RBTree_Left( the_node ) != NULL ) {
40017a00: 90 10 00 01 mov %g1, %o0
40017a04: c2 00 40 00 ld [ %g1 ], %g1
40017a08: 80 a0 60 00 cmp %g1, 0
40017a0c: 32 bf ff fe bne,a 40017a04 <_RBTree_Postorder_first+0x14>
40017a10: 90 10 00 01 mov %g1, %o0
40017a14: c2 02 20 04 ld [ %o0 + 4 ], %g1
} else if ( _RBTree_Right( the_node ) != NULL ) {
40017a18: 80 a0 60 00 cmp %g1, 0
40017a1c: 32 bf ff fa bne,a 40017a04 <_RBTree_Postorder_first+0x14>
40017a20: 90 10 00 01 mov %g1, %o0
return NULL;
}
return _RBTree_Postorder_dive_left( the_node, offset );
40017a24: 81 c3 e0 08 retl
40017a28: 90 22 00 09 sub %o0, %o1, %o0
}
40017a2c: 81 c3 e0 08 retl
40017a30: 90 10 20 00 clr %o0
4001798c <_RBTree_Postorder_next>:
void *_RBTree_Postorder_next(
const RBTree_Node *the_node,
size_t offset
)
{
4001798c: c6 02 20 08 ld [ %o0 + 8 ], %g3
<== NOT EXECUTED
const RBTree_Node *parent;
parent = _RBTree_Parent( the_node );
if ( parent == NULL ) {
40017990: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40017994: 02 80 00 15 be 400179e8 <_RBTree_Postorder_next+0x5c>
<== NOT EXECUTED
40017998: 01 00 00 00 nop
return NULL;
}
if (
4001799c: c2 00 c0 00 ld [ %g3 ], %g1
400179a0: 80 a2 00 01 cmp %o0, %g1
400179a4: 22 80 00 04 be,a 400179b4 <_RBTree_Postorder_next+0x28>
400179a8: c2 00 e0 04 ld [ %g3 + 4 ], %g1
&& _RBTree_Right( parent ) != NULL
) {
return _RBTree_Postorder_dive_left( _RBTree_Right( parent ), offset );
}
return (void *) ( (uintptr_t) parent - offset );
400179ac: 81 c3 e0 08 retl
400179b0: 90 20 c0 09 sub %g3, %o1, %o0
&& _RBTree_Right( parent ) != NULL
400179b4: 80 a0 60 00 cmp %g1, 0
400179b8: 02 bf ff fd be 400179ac <_RBTree_Postorder_next+0x20>
400179bc: 84 10 00 01 mov %g1, %g2
400179c0: c2 00 40 00 ld [ %g1 ], %g1
if ( _RBTree_Left( the_node ) != NULL ) {
400179c4: 80 a0 60 00 cmp %g1, 0
400179c8: 32 bf ff fe bne,a 400179c0 <_RBTree_Postorder_next+0x34>
400179cc: 84 10 00 01 mov %g1, %g2
400179d0: c2 00 a0 04 ld [ %g2 + 4 ], %g1
} else if ( _RBTree_Right( the_node ) != NULL ) {
400179d4: 80 a0 60 00 cmp %g1, 0
400179d8: 32 bf ff fa bne,a 400179c0 <_RBTree_Postorder_next+0x34>
400179dc: 84 10 00 01 mov %g1, %g2
return _RBTree_Postorder_dive_left( _RBTree_Right( parent ), offset );
400179e0: 81 c3 e0 08 retl
400179e4: 90 20 80 09 sub %g2, %o1, %o0
}
400179e8: 81 c3 e0 08 retl
400179ec: 90 10 20 00 clr %o0
400178fc <_RBTree_Predecessor>:
RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static )
400178fc: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
40017900: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40017904: 32 80 00 05 bne,a 40017918 <_RBTree_Predecessor+0x1c>
<== NOT EXECUTED
40017908: c4 00 60 04 ld [ %g1 + 4 ], %g2
4001790c: 10 80 00 08 b 4001792c <_RBTree_Predecessor+0x30>
40017910: c2 02 20 08 ld [ %o0 + 8 ], %g1
40017914: c4 00 60 04 ld [ %g1 + 4 ], %g2
40017918: 80 a0 a0 00 cmp %g2, 0
4001791c: 32 bf ff fe bne,a 40017914 <_RBTree_Predecessor+0x18>
40017920: 82 10 00 02 mov %g2, %g1
RBTree_Node *_RBTree_Predecessor( const RBTree_Node *node )
{
return RB_PREV( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
}
40017924: 81 c3 e0 08 retl
40017928: 90 10 00 01 mov %g1, %o0
RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static )
4001792c: 80 a0 60 00 cmp %g1, 0
40017930: 02 bf ff fd be 40017924 <_RBTree_Predecessor+0x28>
40017934: 01 00 00 00 nop
40017938: c4 00 60 04 ld [ %g1 + 4 ], %g2
4001793c: 80 a2 00 02 cmp %o0, %g2
40017940: 02 bf ff f9 be 40017924 <_RBTree_Predecessor+0x28>
40017944: 01 00 00 00 nop
40017948: c4 00 40 00 ld [ %g1 ], %g2
4001794c: 80 a0 80 08 cmp %g2, %o0
40017950: 12 bf ff f5 bne 40017924 <_RBTree_Predecessor+0x28>
<== NEVER TAKEN
40017954: 01 00 00 00 nop
40017958: c4 00 60 08 ld [ %g1 + 8 ], %g2
4001795c: 80 a0 a0 00 cmp %g2, 0
40017960: 02 80 00 09 be 40017984 <_RBTree_Predecessor+0x88>
40017964: 90 10 00 01 mov %g1, %o0
40017968: 82 10 00 02 mov %g2, %g1
4001796c: c4 00 40 00 ld [ %g1 ], %g2
40017970: 80 a0 80 08 cmp %g2, %o0
40017974: 22 bf ff fa be,a 4001795c <_RBTree_Predecessor+0x60>
40017978: c4 00 60 08 ld [ %g1 + 8 ], %g2
}
4001797c: 81 c3 e0 08 retl
40017980: 90 10 00 01 mov %g1, %o0
return RB_PREV( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
40017984: 10 bf ff e8 b 40017924 <_RBTree_Predecessor+0x28>
40017988: 82 10 20 00 clr %g1
40017a34 <_RBTree_Replace_node>:
void _RBTree_Replace_node(
RBTree_Control *the_rbtree,
RBTree_Node *victim,
RBTree_Node *replacement
)
{
40017a34: c2 02 60 08 ld [ %o1 + 8 ], %g1
<== NOT EXECUTED
RBTree_Node *parent = _RBTree_Parent( victim );
RBTree_Node **link;
RBTree_Node *child;
if (parent != NULL) {
40017a38: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40017a3c: 22 80 00 07 be,a 40017a58 <_RBTree_Replace_node+0x24>
<== NOT EXECUTED
40017a40: d4 22 00 00 st %o2, [ %o0 ]
if ( victim == _RBTree_Left( parent ) ) {
40017a44: c4 00 40 00 ld [ %g1 ], %g2
40017a48: 80 a2 40 02 cmp %o1, %g2
40017a4c: 02 80 00 14 be 40017a9c <_RBTree_Replace_node+0x68>
40017a50: 90 00 60 04 add %g1, 4, %o0
link = _RBTree_Right_reference( parent );
}
} else {
link = _RBTree_Root_reference( the_rbtree );
}
*link = replacement;
40017a54: d4 22 00 00 st %o2, [ %o0 ]
40017a58: c2 02 40 00 ld [ %o1 ], %g1
child = _RBTree_Left( victim );
if ( child != NULL ) {
40017a5c: 80 a0 60 00 cmp %g1, 0
40017a60: 32 80 00 02 bne,a 40017a68 <_RBTree_Replace_node+0x34>
40017a64: d4 20 60 08 st %o2, [ %g1 + 8 ]
40017a68: c2 02 60 04 ld [ %o1 + 4 ], %g1
RB_PARENT( child, Node ) = replacement;
}
child = _RBTree_Right( victim );
if ( child != NULL ) {
40017a6c: 80 a0 60 00 cmp %g1, 0
40017a70: 32 80 00 02 bne,a 40017a78 <_RBTree_Replace_node+0x44>
40017a74: d4 20 60 08 st %o2, [ %g1 + 8 ]
RB_PARENT( child, Node ) = replacement;
}
*replacement = *victim;
40017a78: c2 02 40 00 ld [ %o1 ], %g1
40017a7c: c2 22 80 00 st %g1, [ %o2 ]
40017a80: c2 02 60 04 ld [ %o1 + 4 ], %g1
40017a84: c2 22 a0 04 st %g1, [ %o2 + 4 ]
40017a88: c2 02 60 08 ld [ %o1 + 8 ], %g1
40017a8c: c2 22 a0 08 st %g1, [ %o2 + 8 ]
40017a90: c2 02 60 0c ld [ %o1 + 0xc ], %g1
}
40017a94: 81 c3 e0 08 retl
40017a98: c2 22 a0 0c st %g1, [ %o2 + 0xc ]
40017a9c: 10 bf ff ee b 40017a54 <_RBTree_Replace_node+0x20>
40017aa0: 90 10 00 01 mov %g1, %o0
4001786c <_RBTree_Successor>:
RB_GENERATE_NEXT( RBTree_Control, RBTree_Node, Node, static )
4001786c: c2 02 20 04 ld [ %o0 + 4 ], %g1
<== NOT EXECUTED
40017870: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40017874: 32 80 00 05 bne,a 40017888 <_RBTree_Successor+0x1c>
<== NOT EXECUTED
40017878: c4 00 40 00 ld [ %g1 ], %g2
4001787c: 10 80 00 08 b 4001789c <_RBTree_Successor+0x30>
40017880: c2 02 20 08 ld [ %o0 + 8 ], %g1
40017884: c4 00 40 00 ld [ %g1 ], %g2
40017888: 80 a0 a0 00 cmp %g2, 0
4001788c: 32 bf ff fe bne,a 40017884 <_RBTree_Successor+0x18>
40017890: 82 10 00 02 mov %g2, %g1
RBTree_Node *_RBTree_Successor( const RBTree_Node *node )
{
return RB_NEXT( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
}
40017894: 81 c3 e0 08 retl
40017898: 90 10 00 01 mov %g1, %o0
RB_GENERATE_NEXT( RBTree_Control, RBTree_Node, Node, static )
4001789c: 80 a0 60 00 cmp %g1, 0
400178a0: 02 bf ff fd be 40017894 <_RBTree_Successor+0x28>
400178a4: 01 00 00 00 nop
400178a8: c4 00 40 00 ld [ %g1 ], %g2
400178ac: 80 a2 00 02 cmp %o0, %g2
400178b0: 02 bf ff f9 be 40017894 <_RBTree_Successor+0x28>
400178b4: 01 00 00 00 nop
400178b8: c4 00 60 04 ld [ %g1 + 4 ], %g2
400178bc: 80 a0 80 08 cmp %g2, %o0
400178c0: 12 bf ff f5 bne 40017894 <_RBTree_Successor+0x28>
<== NEVER TAKEN
400178c4: 01 00 00 00 nop
400178c8: c4 00 60 08 ld [ %g1 + 8 ], %g2
400178cc: 80 a0 a0 00 cmp %g2, 0
400178d0: 02 80 00 09 be 400178f4 <_RBTree_Successor+0x88>
400178d4: 90 10 00 01 mov %g1, %o0
400178d8: 82 10 00 02 mov %g2, %g1
400178dc: c4 00 60 04 ld [ %g1 + 4 ], %g2
400178e0: 80 a0 80 08 cmp %g2, %o0
400178e4: 22 bf ff fa be,a 400178cc <_RBTree_Successor+0x60>
400178e8: c4 00 60 08 ld [ %g1 + 8 ], %g2
}
400178ec: 81 c3 e0 08 retl
400178f0: 90 10 00 01 mov %g1, %o0
return RB_NEXT( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
400178f4: 10 bf ff e8 b 40017894 <_RBTree_Successor+0x28>
400178f8: 82 10 20 00 clr %g1
40008090 <_RTEMS_Allocator_is_owner>:
}
bool _RTEMS_Allocator_is_owner( void )
{
return _API_Mutex_Is_owner( &_RTEMS_Allocator_Mutex );
40008090: 11 10 00 4f sethi %hi(0x40013c00), %o0
<== NOT EXECUTED
40008094: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 40013ee8 <_RTEMS_Allocator_Mutex>
<== NOT EXECUTED
40008098: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000809c: 40 00 00 02 call 400080a4 <_API_Mutex_Is_owner>
<== NOT EXECUTED
400080a0: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40007070 <_RTEMS_Unlock_allocator>:
}
void _RTEMS_Unlock_allocator( void )
{
_API_Mutex_Unlock( &_RTEMS_Allocator_Mutex );
40007070: 11 10 00 6d sethi %hi(0x4001b400), %o0
<== NOT EXECUTED
40007074: 90 12 20 cc or %o0, 0xcc, %o0 ! 4001b4cc <_RTEMS_Allocator_Mutex>
40007078: 82 13 c0 00 mov %o7, %g1
4000707c: 40 00 00 0e call 400070b4 <_API_Mutex_Unlock>
40007080: 9e 10 40 00 mov %g1, %o7
4000e7a4 <_SMP_barrier_Wait>:
SMP_barrier_Control *control,
SMP_barrier_State *state,
unsigned int count
)
{
unsigned int sense = ~state->sense;
4000e7a4: c4 02 40 00 ld [ %o1 ], %g2
<== NOT EXECUTED
4000e7a8: 84 38 00 02 xnor %g0, %g2, %g2
<== NOT EXECUTED
unsigned int previous_value;
bool performed_release;
state->sense = sense;
4000e7ac: c4 22 40 00 st %g2, [ %o1 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e7b0: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val + arg;
4000e7b4: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
4000e7b8: 86 00 e0 01 inc %g3
<== NOT EXECUTED
4000e7bc: c6 22 00 00 st %g3, [ %o0 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e7c0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e7c4: 01 00 00 00 nop
&control->value,
1U,
ATOMIC_ORDER_RELAXED
);
if ( previous_value + 1U == count ) {
4000e7c8: 80 a2 80 03 cmp %o2, %g3
4000e7cc: 02 80 00 09 be 4000e7f0 <_SMP_barrier_Wait+0x4c>
<== ALWAYS TAKEN
4000e7d0: 01 00 00 00 nop
4000e7d4: c2 02 20 04 ld [ %o0 + 4 ], %g1
<== NOT EXECUTED
_Atomic_Store_uint( &control->value, 0U, ATOMIC_ORDER_RELAXED );
_Atomic_Store_uint( &control->sense, sense, ATOMIC_ORDER_RELEASE );
performed_release = true;
} else {
while (
4000e7d8: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4000e7dc: 32 bf ff ff bne,a 4000e7d8 <_SMP_barrier_Wait+0x34>
<== NOT EXECUTED
4000e7e0: c2 02 20 04 ld [ %o0 + 4 ], %g1
<== NOT EXECUTED
_Atomic_Load_uint( &control->sense, ATOMIC_ORDER_ACQUIRE ) != sense
) {
/* Wait */
}
performed_release = false;
4000e7e4: 82 10 20 00 clr %g1
<== NOT EXECUTED
}
return performed_release;
}
4000e7e8: 81 c3 e0 08 retl
<== NOT EXECUTED
4000e7ec: 90 08 60 01 and %g1, 1, %o0
<== NOT EXECUTED
*obj = desired;
4000e7f0: c0 22 00 00 clr [ %o0 ]
performed_release = true;
4000e7f4: 82 10 20 01 mov 1, %g1
4000e7f8: c4 22 20 04 st %g2, [ %o0 + 4 ]
}
4000e7fc: 81 c3 e0 08 retl
4000e800: 90 08 60 01 and %g1, 1, %o0
4000b4cc <_Sched_Index>:
int _Sched_Index( void )
{
Thread_Control *executing = _Thread_Get_executing();
return (int) _Scheduler_Get_index( _Thread_Scheduler_get_home( executing ) );
}
4000b4cc: 81 c3 e0 08 retl
<== NOT EXECUTED
4000b4d0: 90 10 20 00 clr %o0
4000b4d4 <_Sched_Name_to_index>:
int _Sched_Name_to_index( const char *name, size_t len )
{
uint32_t name_32 = 0;
size_t i = 0;
while ( i < 4 && i < len ) {
4000b4d4: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
4000b4d8: 02 80 00 15 be 4000b52c <_Sched_Name_to_index+0x58>
<== NOT EXECUTED
4000b4dc: 86 10 20 18 mov 0x18, %g3
size_t i = 0;
4000b4e0: 82 10 20 00 clr %g1
uint32_t name_32 = 0;
4000b4e4: 10 80 00 05 b 4000b4f8 <_Sched_Name_to_index+0x24>
4000b4e8: 88 10 20 00 clr %g4
while ( i < 4 && i < len ) {
4000b4ec: 80 a0 40 09 cmp %g1, %o1
4000b4f0: 3a 80 00 0a bcc,a 4000b518 <_Sched_Name_to_index+0x44>
4000b4f4: 03 10 00 48 sethi %hi(0x40012000), %g1
name_32 |= ( (uint32_t) ( (uint8_t) *name ) ) << ( ( 3 - i ) * 8 );
4000b4f8: c4 0a 00 01 ldub [ %o0 + %g1 ], %g2
4000b4fc: 85 28 80 03 sll %g2, %g3, %g2
++name;
++i;
4000b500: 82 00 60 01 inc %g1
name_32 |= ( (uint32_t) ( (uint8_t) *name ) ) << ( ( 3 - i ) * 8 );
4000b504: 88 11 00 02 or %g4, %g2, %g4
while ( i < 4 && i < len ) {
4000b508: 80 a0 60 03 cmp %g1, 3
4000b50c: 08 bf ff f8 bleu 4000b4ec <_Sched_Name_to_index+0x18>
4000b510: 86 00 ff f8 add %g3, -8, %g3
}
for ( i = 0 ; i < _Scheduler_Count ; ++i ) {
const Scheduler_Control *scheduler = &_Scheduler_Table[ i ];
if ( scheduler->name == name_32 ) {
4000b514: 03 10 00 48 sethi %hi(0x40012000), %g1
4000b518: c2 00 61 e8 ld [ %g1 + 0x1e8 ], %g1 ! 400121e8 <_Scheduler_Table+0x48>
4000b51c: 88 18 40 04 xor %g1, %g4, %g4
return (int) i;
}
}
return -1;
}
4000b520: 80 a0 00 04 cmp %g0, %g4
4000b524: 81 c3 e0 08 retl
4000b528: 90 60 20 00 subx %g0, 0, %o0
if ( scheduler->name == name_32 ) {
4000b52c: 03 10 00 48 sethi %hi(0x40012000), %g1
4000b530: c2 00 61 e8 ld [ %g1 + 0x1e8 ], %g1 ! 400121e8 <_Scheduler_Table+0x48>
uint32_t name_32 = 0;
4000b534: 88 10 20 00 clr %g4
if ( scheduler->name == name_32 ) {
4000b538: 88 18 40 04 xor %g1, %g4, %g4
}
4000b53c: 80 a0 00 04 cmp %g0, %g4
4000b540: 81 c3 e0 08 retl
4000b544: 90 60 20 00 subx %g0, 0, %o0
4000b548 <_Sched_Processor_count>:
if ( i < _Scheduler_Count ) {
return _Scheduler_Get_processor_count( &_Scheduler_Table[ i ] );
} else {
return 0;
}
}
4000b548: 80 a0 00 08 cmp %g0, %o0
<== NOT EXECUTED
4000b54c: 81 c3 e0 08 retl
<== NOT EXECUTED
4000b550: 90 60 3f ff subx %g0, -1, %o0
4000ae8c <_Scheduler_CBS_Attach_thread>:
int _Scheduler_CBS_Attach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
4000ae8c: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
Scheduler_CBS_Server *server;
ISR_lock_Context lock_context;
Thread_Control *the_thread;
Scheduler_CBS_Node *node;
if ( server_id >= _Scheduler_CBS_Maximum_servers ) {
4000ae90: 03 10 00 4b sethi %hi(0x40012c00), %g1
<== NOT EXECUTED
4000ae94: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 40012fd0 <_Scheduler_CBS_Maximum_servers>
<== NOT EXECUTED
4000ae98: 80 a0 40 18 cmp %g1, %i0
<== NOT EXECUTED
4000ae9c: 08 80 00 2c bleu 4000af4c <_Scheduler_CBS_Attach_thread+0xc0>
<== NOT EXECUTED
4000aea0: 3b 10 00 56 sethi %hi(0x40015800), %i5
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
}
server = &_Scheduler_CBS_Server_list[ server_id ];
4000aea4: b1 2e 20 05 sll %i0, 5, %i0
4000aea8: ba 17 62 08 or %i5, 0x208, %i5
4000aeac: b8 06 00 1d add %i0, %i5, %i4
if ( !server->initialized ) {
4000aeb0: c2 0f 20 1c ldub [ %i4 + 0x1c ], %g1
4000aeb4: 80 a0 60 00 cmp %g1, 0
4000aeb8: 02 80 00 27 be 4000af54 <_Scheduler_CBS_Attach_thread+0xc8>
4000aebc: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_NOSERVER;
}
if ( server->task_id != -1 ) {
4000aec0: c2 07 40 18 ld [ %i5 + %i0 ], %g1
4000aec4: 80 a0 7f ff cmp %g1, -1
4000aec8: 12 80 00 1a bne 4000af30 <_Scheduler_CBS_Attach_thread+0xa4>
4000aecc: 92 07 bf fc add %fp, -4, %o1
return SCHEDULER_CBS_ERROR_FULL;
}
the_thread = _Thread_Get( task_id, &lock_context );
4000aed0: 40 00 05 5b call 4000c43c <_Thread_Get>
4000aed4: 90 10 00 19 mov %i1, %o0
if ( the_thread == NULL ) {
4000aed8: 80 a2 20 00 cmp %o0, 0
4000aedc: 02 80 00 1c be 4000af4c <_Scheduler_CBS_Attach_thread+0xc0>
4000aee0: 01 00 00 00 nop
4000aee4: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
}
node = _Scheduler_CBS_Thread_get_node( the_thread );
if ( node->cbs_server != NULL ) {
4000aee8: c4 00 60 50 ld [ %g1 + 0x50 ], %g2
4000aeec: 80 a0 a0 00 cmp %g2, 0
4000aef0: 12 80 00 12 bne 4000af38 <_Scheduler_CBS_Attach_thread+0xac> <== NEVER TAKEN
4000aef4: 01 00 00 00 nop
<== NOT EXECUTED
_ISR_lock_ISR_enable( &lock_context );
return SCHEDULER_CBS_ERROR_FULL;
}
node->cbs_server = server;
4000aef8: f8 20 60 50 st %i4, [ %g1 + 0x50 ]
<== NOT EXECUTED
server->task_id = task_id;
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
4000aefc: 03 10 00 2d sethi %hi(0x4000b400), %g1
<== NOT EXECUTED
server->task_id = task_id;
4000af00: f2 27 40 18 st %i1, [ %i5 + %i0 ]
<== NOT EXECUTED
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
4000af04: 82 10 60 40 or %g1, 0x40, %g1
<== NOT EXECUTED
4000af08: c2 22 20 94 st %g1, [ %o0 + 0x94 ]
<== NOT EXECUTED
the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
4000af0c: 82 10 20 03 mov 3, %g1
<== NOT EXECUTED
4000af10: c2 22 20 90 st %g1, [ %o0 + 0x90 ]
<== NOT EXECUTED
the_thread->is_preemptible = true;
4000af14: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
4000af18: c2 2a 20 89 stb %g1, [ %o0 + 0x89 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000af1c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000af20: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000af24: 01 00 00 00 nop
_ISR_lock_ISR_enable( &lock_context );
return SCHEDULER_CBS_OK;
4000af28: 81 c7 e0 08 ret
4000af2c: 91 e8 20 00 restore %g0, 0, %o0
}
4000af30: 81 c7 e0 08 ret
4000af34: 91 e8 3f e6 restore %g0, -26, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000af38: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000af3c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000af40: 01 00 00 00 nop
<== NOT EXECUTED
return SCHEDULER_CBS_ERROR_FULL;
4000af44: 81 c7 e0 08 ret
<== NOT EXECUTED
4000af48: 91 e8 3f e6 restore %g0, -26, %o0
<== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
4000af4c: 81 c7 e0 08 ret
4000af50: 91 e8 3f ee restore %g0, -18, %o0
return SCHEDULER_CBS_ERROR_NOSERVER;
4000af54: 81 c7 e0 08 ret
4000af58: 91 e8 3f e7 restore %g0, -25, %o0
4000b440 <_Scheduler_CBS_Budget_callout>:
#include <rtems/score/schedulercbsimpl.h>
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
4000b440: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
4000b444: fa 06 20 38 ld [ %i0 + 0x38 ], %i5
<== NOT EXECUTED
node = _Scheduler_CBS_Thread_get_node( the_thread );
/* Put violating task to background until the end of period. */
_Thread_queue_Context_clear_priority_updates( &queue_context );
_Scheduler_CBS_Cancel_job(
4000b448: d4 07 60 54 ld [ %i5 + 0x54 ], %o2
<== NOT EXECUTED
4000b44c: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
4000b450: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4000b454: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000b458: 40 00 00 21 call 4000b4dc <_Scheduler_CBS_Cancel_job>
<== NOT EXECUTED
4000b45c: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
NULL,
the_thread,
node->deadline_node,
&queue_context
);
_Thread_Priority_update( &queue_context );
4000b460: 40 00 02 f5 call 4000c034 <_Thread_Priority_update>
4000b464: 90 07 bf dc add %fp, -36, %o0
/* Invoke callback function if any. */
if ( node->cbs_server->cbs_budget_overrun ) {
4000b468: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
4000b46c: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4000b470: 80 a0 a0 00 cmp %g2, 0
4000b474: 02 80 00 09 be 4000b498 <_Scheduler_CBS_Budget_callout+0x58> <== NEVER TAKEN
4000b478: 01 00 00 00 nop
_Scheduler_CBS_Get_server_id(
4000b47c: d0 00 40 00 ld [ %g1 ], %o0
4000b480: 7f ff ff ce call 4000b3b8 <_Scheduler_CBS_Get_server_id>
4000b484: 92 07 bf d8 add %fp, -40, %o1
node->cbs_server->task_id,
&server_id
);
node->cbs_server->cbs_budget_overrun( server_id );
4000b488: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
4000b48c: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
4000b490: 9f c0 40 00 call %g1
4000b494: d0 07 bf d8 ld [ %fp + -40 ], %o0
}
}
4000b498: 81 c7 e0 08 ret
4000b49c: 81 e8 00 00 restore
4000a4e0 <_Scheduler_CBS_Cancel_job>:
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Priority_Node *priority_node,
Thread_queue_Context *queue_context
)
{
4000a4e0: c2 02 60 38 ld [ %o1 + 0x38 ], %g1
<== NOT EXECUTED
Scheduler_CBS_Node *node;
node = _Scheduler_CBS_Thread_get_node( the_thread );
if ( node->deadline_node != NULL ) {
4000a4e4: c4 00 60 54 ld [ %g1 + 0x54 ], %g2
<== NOT EXECUTED
4000a4e8: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000a4ec: 02 80 00 06 be 4000a504 <_Scheduler_CBS_Cancel_job+0x24>
<== NOT EXECUTED
4000a4f0: 01 00 00 00 nop
_Assert( node->deadline_node == priority_node );
node->deadline_node = NULL;
4000a4f4: c0 20 60 54 clr [ %g1 + 0x54 ]
_Scheduler_EDF_Cancel_job(
4000a4f8: 82 13 c0 00 mov %o7, %g1
4000a4fc: 40 00 01 0e call 4000a934 <_Scheduler_EDF_Cancel_job>
4000a500: 9e 10 40 00 mov %g1, %o7
the_thread,
priority_node,
queue_context
);
}
}
4000a504: 81 c3 e0 08 retl
4000a508: 01 00 00 00 nop
4000af5c <_Scheduler_CBS_Cleanup>:
#include <rtems/score/schedulercbs.h>
#include <rtems/score/wkspace.h>
int _Scheduler_CBS_Cleanup (void)
{
4000af5c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000af60: 03 10 00 4b sethi %hi(0x40012c00), %g1
<== NOT EXECUTED
4000af64: f6 00 63 d0 ld [ %g1 + 0x3d0 ], %i3 ! 40012fd0 <_Scheduler_CBS_Maximum_servers>
<== NOT EXECUTED
4000af68: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
4000af6c: 02 80 00 12 be 4000afb4 <_Scheduler_CBS_Cleanup+0x58>
<== NOT EXECUTED
4000af70: 39 10 00 56 sethi %hi(0x40015800), %i4
4000af74: ba 10 20 00 clr %i5
4000af78: 10 80 00 05 b 4000af8c <_Scheduler_CBS_Cleanup+0x30>
4000af7c: b8 17 22 24 or %i4, 0x224, %i4
4000af80: 80 a7 40 1b cmp %i5, %i3
4000af84: 02 80 00 0c be 4000afb4 <_Scheduler_CBS_Cleanup+0x58>
4000af88: b8 07 20 20 add %i4, 0x20, %i4
if ( _Scheduler_CBS_Server_list[ i ].initialized )
4000af8c: c2 0f 00 00 ldub [ %i4 ], %g1
4000af90: 80 a0 60 00 cmp %g1, 0
4000af94: 22 bf ff fb be,a 4000af80 <_Scheduler_CBS_Cleanup+0x24>
4000af98: ba 07 60 01 inc %i5
_Scheduler_CBS_Destroy_server( i );
4000af9c: 40 00 00 43 call 4000b0a8 <_Scheduler_CBS_Destroy_server>
4000afa0: 90 10 00 1d mov %i5, %o0
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000afa4: ba 07 60 01 inc %i5
4000afa8: 80 a7 40 1b cmp %i5, %i3
4000afac: 12 bf ff f8 bne 4000af8c <_Scheduler_CBS_Cleanup+0x30> <== ALWAYS TAKEN
4000afb0: b8 07 20 20 add %i4, 0x20, %i4
}
return SCHEDULER_CBS_OK;
}
4000afb4: 81 c7 e0 08 ret
4000afb8: 91 e8 20 00 restore %g0, 0, %o0
4000afbc <_Scheduler_CBS_Create_server>:
)
{
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
4000afbc: c2 02 20 08 ld [ %o0 + 8 ], %g1
<== NOT EXECUTED
4000afc0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000afc4: 04 80 00 2a ble 4000b06c <_Scheduler_CBS_Create_server+0xb0>
<== NOT EXECUTED
4000afc8: 01 00 00 00 nop
4000afcc: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
4000afd0: 80 a0 60 00 cmp %g1, 0
4000afd4: 04 80 00 2e ble 4000b08c <_Scheduler_CBS_Create_server+0xd0> <== ALWAYS TAKEN
4000afd8: 03 10 00 4b sethi %hi(0x40012c00), %g1
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000afdc: c8 00 63 d0 ld [ %g1 + 0x3d0 ], %g4 ! 40012fd0 <_Scheduler_CBS_Maximum_servers>
4000afe0: 80 a1 20 00 cmp %g4, 0
4000afe4: 02 80 00 11 be 4000b028 <_Scheduler_CBS_Create_server+0x6c> <== NEVER TAKEN
4000afe8: 1b 10 00 56 sethi %hi(0x40015800), %o5
if ( !_Scheduler_CBS_Server_list[i].initialized )
4000afec: 9a 13 62 08 or %o5, 0x208, %o5 ! 40015a08 <_Scheduler_CBS_Server_list>
4000aff0: c2 0b 60 1c ldub [ %o5 + 0x1c ], %g1
4000aff4: 80 a0 60 00 cmp %g1, 0
4000aff8: 02 80 00 0e be 4000b030 <_Scheduler_CBS_Create_server+0x74>
4000affc: 84 03 60 3c add %o5, 0x3c, %g2
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000b000: 10 80 00 06 b 4000b018 <_Scheduler_CBS_Create_server+0x5c>
4000b004: 82 10 20 00 clr %g1
if ( !_Scheduler_CBS_Server_list[i].initialized )
4000b008: c6 08 bf e0 ldub [ %g2 + -32 ], %g3
4000b00c: 80 a0 e0 00 cmp %g3, 0
4000b010: 22 80 00 0a be,a 4000b038 <_Scheduler_CBS_Create_server+0x7c>
4000b014: c2 22 80 00 st %g1, [ %o2 ]
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000b018: 82 00 60 01 inc %g1
4000b01c: 80 a1 00 01 cmp %g4, %g1
4000b020: 12 bf ff fa bne 4000b008 <_Scheduler_CBS_Create_server+0x4c>
4000b024: 84 00 a0 20 add %g2, 0x20, %g2
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
4000b028: 81 c3 e0 08 retl
4000b02c: 90 10 3f e6 mov -26, %o0
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000b030: 82 10 20 00 clr %g1
*server_id = i;
4000b034: c2 22 80 00 st %g1, [ %o2 ]
the_server = &_Scheduler_CBS_Server_list[*server_id];
the_server->parameters = *params;
4000b038: 83 28 60 05 sll %g1, 5, %g1
4000b03c: d4 1a 00 00 ldd [ %o0 ], %o2
4000b040: 84 03 40 01 add %o5, %g1, %g2
4000b044: d4 38 a0 08 std %o2, [ %g2 + 8 ]
the_server->task_id = -1;
4000b048: 86 10 3f ff mov -1, %g3
the_server->parameters = *params;
4000b04c: d4 1a 20 08 ldd [ %o0 + 8 ], %o2
4000b050: d4 38 a0 10 std %o2, [ %g2 + 0x10 ]
the_server->cbs_budget_overrun = budget_overrun_callback;
the_server->initialized = true;
return SCHEDULER_CBS_OK;
4000b054: 90 10 20 00 clr %o0
the_server->task_id = -1;
4000b058: c6 23 40 01 st %g3, [ %o5 + %g1 ]
the_server->initialized = true;
4000b05c: 82 10 20 01 mov 1, %g1
the_server->cbs_budget_overrun = budget_overrun_callback;
4000b060: d2 20 a0 18 st %o1, [ %g2 + 0x18 ]
}
4000b064: 81 c3 e0 08 retl
4000b068: c2 28 a0 1c stb %g1, [ %g2 + 0x1c ]
if ( params->budget <= 0 ||
4000b06c: 12 80 00 06 bne 4000b084 <_Scheduler_CBS_Create_server+0xc8>
4000b070: 01 00 00 00 nop
4000b074: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4000b078: 80 a0 60 00 cmp %g1, 0
4000b07c: 32 bf ff d5 bne,a 4000afd0 <_Scheduler_CBS_Create_server+0x14> <== ALWAYS TAKEN
4000b080: c2 02 00 00 ld [ %o0 ], %g1
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
4000b084: 81 c3 e0 08 retl
4000b088: 90 10 3f ee mov -18, %o0
if ( params->budget <= 0 ||
4000b08c: 12 bf ff fe bne 4000b084 <_Scheduler_CBS_Create_server+0xc8>
4000b090: 01 00 00 00 nop
4000b094: c2 02 20 04 ld [ %o0 + 4 ], %g1
4000b098: 80 a0 60 00 cmp %g1, 0
4000b09c: 12 bf ff d0 bne 4000afdc <_Scheduler_CBS_Create_server+0x20> <== ALWAYS TAKEN
4000b0a0: 03 10 00 4b sethi %hi(0x40012c00), %g1
4000b0a4: 30 bf ff f8 b,a 4000b084 <_Scheduler_CBS_Create_server+0xc8> <== NOT EXECUTED
4000b0a8 <_Scheduler_CBS_Destroy_server>:
#include <rtems/score/wkspace.h>
int _Scheduler_CBS_Destroy_server (
Scheduler_CBS_Server_id server_id
)
{
4000b0a8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int ret = SCHEDULER_CBS_OK;
rtems_id tid;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
4000b0ac: 05 10 00 4b sethi %hi(0x40012c00), %g2
<== NOT EXECUTED
4000b0b0: c4 00 a3 d0 ld [ %g2 + 0x3d0 ], %g2 ! 40012fd0 <_Scheduler_CBS_Maximum_servers>
<== NOT EXECUTED
4000b0b4: 80 a0 80 18 cmp %g2, %i0
<== NOT EXECUTED
4000b0b8: 08 80 00 17 bleu 4000b114 <_Scheduler_CBS_Destroy_server+0x6c>
<== NOT EXECUTED
4000b0bc: 90 10 00 18 mov %i0, %o0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id].initialized )
4000b0c0: b9 2e 20 05 sll %i0, 5, %i4
4000b0c4: 3b 10 00 56 sethi %hi(0x40015800), %i5
4000b0c8: ba 17 62 08 or %i5, 0x208, %i5 ! 40015a08 <_Scheduler_CBS_Server_list>
4000b0cc: 84 07 40 1c add %i5, %i4, %g2
4000b0d0: c4 08 a0 1c ldub [ %g2 + 0x1c ], %g2
4000b0d4: 80 a0 a0 00 cmp %g2, 0
4000b0d8: 02 80 00 11 be 4000b11c <_Scheduler_CBS_Destroy_server+0x74>
4000b0dc: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_NOSERVER;
if ( (tid = _Scheduler_CBS_Server_list[server_id].task_id) != -1 )
4000b0e0: d2 07 40 1c ld [ %i5 + %i4 ], %o1
4000b0e4: 80 a2 7f ff cmp %o1, -1
4000b0e8: 12 80 00 06 bne 4000b100 <_Scheduler_CBS_Destroy_server+0x58>
4000b0ec: b0 10 20 00 clr %i0
ret = _Scheduler_CBS_Detach_thread ( server_id, tid );
_Scheduler_CBS_Server_list[server_id].initialized = false;
4000b0f0: ba 07 40 1c add %i5, %i4, %i5
4000b0f4: c0 2f 60 1c clrb [ %i5 + 0x1c ]
return ret;
4000b0f8: 81 c7 e0 08 ret
4000b0fc: 81 e8 00 00 restore
ret = _Scheduler_CBS_Detach_thread ( server_id, tid );
4000b100: 40 00 00 09 call 4000b124 <_Scheduler_CBS_Detach_thread>
4000b104: ba 07 40 1c add %i5, %i4, %i5
_Scheduler_CBS_Server_list[server_id].initialized = false;
4000b108: c0 2f 60 1c clrb [ %i5 + 0x1c ]
return ret;
4000b10c: 81 c7 e0 08 ret
4000b110: 91 e8 00 08 restore %g0, %o0, %o0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
4000b114: 81 c7 e0 08 ret
4000b118: 91 e8 3f ee restore %g0, -18, %o0
}
4000b11c: 81 c7 e0 08 ret
4000b120: 91 e8 3f e7 restore %g0, -25, %o0
4000b124 <_Scheduler_CBS_Detach_thread>:
int _Scheduler_CBS_Detach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
4000b124: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
Scheduler_CBS_Server *server;
ISR_lock_Context lock_context;
Thread_Control *the_thread;
Scheduler_CBS_Node *node;
if ( server_id >= _Scheduler_CBS_Maximum_servers ) {
4000b128: 03 10 00 4b sethi %hi(0x40012c00), %g1
<== NOT EXECUTED
4000b12c: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 40012fd0 <_Scheduler_CBS_Maximum_servers>
<== NOT EXECUTED
4000b130: 80 a0 40 18 cmp %g1, %i0
<== NOT EXECUTED
4000b134: 08 80 00 21 bleu 4000b1b8 <_Scheduler_CBS_Detach_thread+0x94>
<== NOT EXECUTED
4000b138: 3b 10 00 56 sethi %hi(0x40015800), %i5
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
}
server = &_Scheduler_CBS_Server_list[ server_id ];
if ( !server->initialized ) {
4000b13c: b1 2e 20 05 sll %i0, 5, %i0
4000b140: ba 17 62 08 or %i5, 0x208, %i5
4000b144: 82 07 40 18 add %i5, %i0, %g1
4000b148: c2 08 60 1c ldub [ %g1 + 0x1c ], %g1
4000b14c: 80 a0 60 00 cmp %g1, 0
4000b150: 02 80 00 1c be 4000b1c0 <_Scheduler_CBS_Detach_thread+0x9c>
4000b154: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_NOSERVER;
}
if ( server->task_id != task_id ) {
4000b158: d0 07 40 18 ld [ %i5 + %i0 ], %o0
4000b15c: 80 a2 00 19 cmp %o0, %i1
4000b160: 12 80 00 16 bne 4000b1b8 <_Scheduler_CBS_Detach_thread+0x94>
4000b164: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
}
the_thread = _Thread_Get( task_id, &lock_context );
4000b168: 40 00 04 b5 call 4000c43c <_Thread_Get>
4000b16c: 92 07 bf fc add %fp, -4, %o1
if ( the_thread == NULL ) {
4000b170: 80 a2 20 00 cmp %o0, 0
4000b174: 02 80 00 11 be 4000b1b8 <_Scheduler_CBS_Detach_thread+0x94>
4000b178: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
}
node = _Scheduler_CBS_Thread_get_node( the_thread );
node->cbs_server = NULL;
4000b17c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
<== NOT EXECUTED
4000b180: c0 20 60 50 clr [ %g1 + 0x50 ]
<== NOT EXECUTED
server->task_id = -1;
4000b184: 82 10 3f ff mov -1, %g1
<== NOT EXECUTED
4000b188: c2 27 40 18 st %g1, [ %i5 + %i0 ]
<== NOT EXECUTED
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
4000b18c: c6 02 20 b0 ld [ %o0 + 0xb0 ], %g3
<== NOT EXECUTED
the_thread->budget_callout = the_thread->Start.budget_callout;
4000b190: c4 02 20 b4 ld [ %o0 + 0xb4 ], %g2
<== NOT EXECUTED
the_thread->is_preemptible = the_thread->Start.is_preemptible;
4000b194: c2 0a 20 ac ldub [ %o0 + 0xac ], %g1
<== NOT EXECUTED
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
4000b198: c6 22 20 90 st %g3, [ %o0 + 0x90 ]
<== NOT EXECUTED
the_thread->budget_callout = the_thread->Start.budget_callout;
4000b19c: c4 22 20 94 st %g2, [ %o0 + 0x94 ]
<== NOT EXECUTED
the_thread->is_preemptible = the_thread->Start.is_preemptible;
4000b1a0: c2 2a 20 89 stb %g1, [ %o0 + 0x89 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000b1a4: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b1a8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b1ac: 01 00 00 00 nop
_ISR_lock_ISR_enable( &lock_context );
return SCHEDULER_CBS_OK;
4000b1b0: 81 c7 e0 08 ret
4000b1b4: 91 e8 20 00 restore %g0, 0, %o0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
4000b1b8: 81 c7 e0 08 ret
4000b1bc: 91 e8 3f ee restore %g0, -18, %o0
}
4000b1c0: 81 c7 e0 08 ret
4000b1c4: 91 e8 3f e7 restore %g0, -25, %o0
4000b1c8 <_Scheduler_CBS_Get_approved_budget>:
int _Scheduler_CBS_Get_approved_budget (
Scheduler_CBS_Server_id server_id,
time_t *approved_budget
)
{
if ( server_id >= _Scheduler_CBS_Maximum_servers )
4000b1c8: 03 10 00 4b sethi %hi(0x40012c00), %g1
<== NOT EXECUTED
4000b1cc: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 40012fd0 <_Scheduler_CBS_Maximum_servers>
<== NOT EXECUTED
4000b1d0: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000b1d4: 08 80 00 0d bleu 4000b208 <_Scheduler_CBS_Get_approved_budget+0x40>
<== NOT EXECUTED
4000b1d8: 83 2a 20 05 sll %o0, 5, %g1
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id].initialized )
4000b1dc: 11 10 00 56 sethi %hi(0x40015800), %o0
4000b1e0: 90 12 22 08 or %o0, 0x208, %o0 ! 40015a08 <_Scheduler_CBS_Server_list>
4000b1e4: 90 02 00 01 add %o0, %g1, %o0
4000b1e8: c2 0a 20 1c ldub [ %o0 + 0x1c ], %g1
4000b1ec: 80 a0 60 00 cmp %g1, 0
4000b1f0: 02 80 00 08 be 4000b210 <_Scheduler_CBS_Get_approved_budget+0x48>
4000b1f4: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_NOSERVER;
*approved_budget = _Scheduler_CBS_Server_list[server_id].parameters.budget;
4000b1f8: c4 1a 20 10 ldd [ %o0 + 0x10 ], %g2
4000b1fc: c4 3a 40 00 std %g2, [ %o1 ]
return SCHEDULER_CBS_OK;
4000b200: 81 c3 e0 08 retl
4000b204: 90 10 20 00 clr %o0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
4000b208: 81 c3 e0 08 retl
4000b20c: 90 10 3f ee mov -18, %o0
}
4000b210: 81 c3 e0 08 retl
4000b214: 90 10 3f e7 mov -25, %o0
4000b218 <_Scheduler_CBS_Get_execution_time>:
int _Scheduler_CBS_Get_execution_time (
Scheduler_CBS_Server_id server_id,
time_t *exec_time,
time_t *abs_time
)
{
4000b218: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
Scheduler_CBS_Server *server;
ISR_lock_Context lock_context;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers ) {
4000b21c: 03 10 00 4b sethi %hi(0x40012c00), %g1
<== NOT EXECUTED
4000b220: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 40012fd0 <_Scheduler_CBS_Maximum_servers>
<== NOT EXECUTED
4000b224: 80 a0 40 18 cmp %g1, %i0
<== NOT EXECUTED
4000b228: 08 80 00 22 bleu 4000b2b0 <_Scheduler_CBS_Get_execution_time+0x98>
<== NOT EXECUTED
4000b22c: 03 10 00 56 sethi %hi(0x40015800), %g1
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
}
server = &_Scheduler_CBS_Server_list[ server_id ];
if ( !server->initialized ) {
4000b230: b1 2e 20 05 sll %i0, 5, %i0
4000b234: 82 10 62 08 or %g1, 0x208, %g1
4000b238: ba 00 40 18 add %g1, %i0, %i5
4000b23c: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
4000b240: 80 a0 a0 00 cmp %g2, 0
4000b244: 02 80 00 1d be 4000b2b8 <_Scheduler_CBS_Get_execution_time+0xa0>
4000b248: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_NOSERVER;
}
if ( server->task_id == -1 ) {
4000b24c: d0 00 40 18 ld [ %g1 + %i0 ], %o0
4000b250: 80 a2 3f ff cmp %o0, -1
4000b254: 22 80 00 11 be,a 4000b298 <_Scheduler_CBS_Get_execution_time+0x80>
4000b258: c0 26 40 00 clr [ %i1 ]
*exec_time = 0;
return SCHEDULER_CBS_OK;
}
the_thread = _Thread_Get( server->task_id, &lock_context );
4000b25c: 40 00 04 78 call 4000c43c <_Thread_Get>
4000b260: 92 07 bf fc add %fp, -4, %o1
if ( the_thread != NULL ) {
4000b264: 80 a2 20 00 cmp %o0, 0
4000b268: 22 80 00 0f be,a 4000b2a4 <_Scheduler_CBS_Get_execution_time+0x8c>
4000b26c: c4 1f 60 10 ldd [ %i5 + 0x10 ], %g2
*exec_time = server->parameters.budget - the_thread->cpu_time_budget;
4000b270: f8 1f 60 10 ldd [ %i5 + 0x10 ], %i4
<== NOT EXECUTED
4000b274: c2 02 20 8c ld [ %o0 + 0x8c ], %g1
<== NOT EXECUTED
4000b278: 86 a7 40 01 subcc %i5, %g1, %g3
<== NOT EXECUTED
4000b27c: 84 67 20 00 subx %i4, 0, %g2
<== NOT EXECUTED
4000b280: c4 3e 40 00 std %g2, [ %i1 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000b284: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b288: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b28c: 01 00 00 00 nop
_ISR_lock_ISR_enable( &lock_context );
} else {
*exec_time = server->parameters.budget;
}
return SCHEDULER_CBS_OK;
4000b290: 81 c7 e0 08 ret
4000b294: 91 e8 20 00 restore %g0, 0, %o0
*exec_time = 0;
4000b298: c0 26 60 04 clr [ %i1 + 4 ]
return SCHEDULER_CBS_OK;
4000b29c: 81 c7 e0 08 ret
4000b2a0: 91 e8 20 00 restore %g0, 0, %o0
*exec_time = server->parameters.budget;
4000b2a4: c4 3e 40 00 std %g2, [ %i1 ]
return SCHEDULER_CBS_OK;
4000b2a8: 81 c7 e0 08 ret
4000b2ac: 91 e8 20 00 restore %g0, 0, %o0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
4000b2b0: 81 c7 e0 08 ret
4000b2b4: 91 e8 3f ee restore %g0, -18, %o0
}
4000b2b8: 81 c7 e0 08 ret
4000b2bc: 91 e8 3f e7 restore %g0, -25, %o0
4000b2c0 <_Scheduler_CBS_Get_parameters>:
int _Scheduler_CBS_Get_parameters (
Scheduler_CBS_Server_id server_id,
Scheduler_CBS_Parameters *params
)
{
if ( server_id >= _Scheduler_CBS_Maximum_servers )
4000b2c0: 03 10 00 4b sethi %hi(0x40012c00), %g1
<== NOT EXECUTED
4000b2c4: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 40012fd0 <_Scheduler_CBS_Maximum_servers>
<== NOT EXECUTED
4000b2c8: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000b2cc: 08 80 00 0f bleu 4000b308 <_Scheduler_CBS_Get_parameters+0x48>
<== NOT EXECUTED
4000b2d0: 03 10 00 56 sethi %hi(0x40015800), %g1
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id].initialized )
4000b2d4: 91 2a 20 05 sll %o0, 5, %o0
4000b2d8: 82 10 62 08 or %g1, 0x208, %g1
4000b2dc: 82 00 40 08 add %g1, %o0, %g1
4000b2e0: c4 08 60 1c ldub [ %g1 + 0x1c ], %g2
4000b2e4: 80 a0 a0 00 cmp %g2, 0
4000b2e8: 02 80 00 0a be 4000b310 <_Scheduler_CBS_Get_parameters+0x50>
4000b2ec: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_NOSERVER;
*params = _Scheduler_CBS_Server_list[server_id].parameters;
4000b2f0: c4 18 60 08 ldd [ %g1 + 8 ], %g2
4000b2f4: c4 3a 40 00 std %g2, [ %o1 ]
return SCHEDULER_CBS_OK;
4000b2f8: 90 10 20 00 clr %o0
*params = _Scheduler_CBS_Server_list[server_id].parameters;
4000b2fc: c4 18 60 10 ldd [ %g1 + 0x10 ], %g2
return SCHEDULER_CBS_OK;
4000b300: 81 c3 e0 08 retl
4000b304: c4 3a 60 08 std %g2, [ %o1 + 8 ]
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
4000b308: 81 c3 e0 08 retl
4000b30c: 90 10 3f ee mov -18, %o0
}
4000b310: 81 c3 e0 08 retl
4000b314: 90 10 3f e7 mov -25, %o0
4000b318 <_Scheduler_CBS_Get_remaining_budget>:
int _Scheduler_CBS_Get_remaining_budget (
Scheduler_CBS_Server_id server_id,
time_t *remaining_budget
)
{
4000b318: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
Scheduler_CBS_Server *server;
ISR_lock_Context lock_context;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers ) {
4000b31c: 03 10 00 4b sethi %hi(0x40012c00), %g1
<== NOT EXECUTED
4000b320: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 40012fd0 <_Scheduler_CBS_Maximum_servers>
<== NOT EXECUTED
4000b324: 80 a0 40 18 cmp %g1, %i0
<== NOT EXECUTED
4000b328: 08 80 00 20 bleu 4000b3a8 <_Scheduler_CBS_Get_remaining_budget+0x90>
<== NOT EXECUTED
4000b32c: 03 10 00 56 sethi %hi(0x40015800), %g1
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
}
server = &_Scheduler_CBS_Server_list[ server_id ];
if ( !server->initialized ) {
4000b330: b1 2e 20 05 sll %i0, 5, %i0
4000b334: 82 10 62 08 or %g1, 0x208, %g1
4000b338: 84 00 40 18 add %g1, %i0, %g2
4000b33c: c6 08 a0 1c ldub [ %g2 + 0x1c ], %g3
4000b340: 80 a0 e0 00 cmp %g3, 0
4000b344: 02 80 00 1b be 4000b3b0 <_Scheduler_CBS_Get_remaining_budget+0x98>
4000b348: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_NOSERVER;
}
if ( server->task_id == -1 ) {
4000b34c: d0 00 40 18 ld [ %g1 + %i0 ], %o0
4000b350: 80 a2 3f ff cmp %o0, -1
4000b354: 22 80 00 0f be,a 4000b390 <_Scheduler_CBS_Get_remaining_budget+0x78>
4000b358: c4 18 a0 10 ldd [ %g2 + 0x10 ], %g2
*remaining_budget = server->parameters.budget;
return SCHEDULER_CBS_OK;
}
the_thread = _Thread_Get( server->task_id, &lock_context );
4000b35c: 40 00 04 38 call 4000c43c <_Thread_Get>
4000b360: 92 07 bf fc add %fp, -4, %o1
if ( the_thread != NULL ) {
4000b364: 80 a2 20 00 cmp %o0, 0
4000b368: 22 80 00 0d be,a 4000b39c <_Scheduler_CBS_Get_remaining_budget+0x84>
4000b36c: c0 26 40 00 clr [ %i1 ]
*remaining_budget = the_thread->cpu_time_budget;
4000b370: c2 02 20 8c ld [ %o0 + 0x8c ], %g1
<== NOT EXECUTED
4000b374: c2 26 60 04 st %g1, [ %i1 + 4 ]
<== NOT EXECUTED
4000b378: c0 26 40 00 clr [ %i1 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000b37c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b380: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b384: 01 00 00 00 nop
_ISR_lock_ISR_enable( &lock_context );
} else {
*remaining_budget = 0;
}
return SCHEDULER_CBS_OK;
4000b388: 81 c7 e0 08 ret
4000b38c: 91 e8 20 00 restore %g0, 0, %o0
*remaining_budget = server->parameters.budget;
4000b390: c4 3e 40 00 std %g2, [ %i1 ]
return SCHEDULER_CBS_OK;
4000b394: 81 c7 e0 08 ret
4000b398: 91 e8 20 00 restore %g0, 0, %o0
*remaining_budget = 0;
4000b39c: c0 26 60 04 clr [ %i1 + 4 ]
return SCHEDULER_CBS_OK;
4000b3a0: 81 c7 e0 08 ret
4000b3a4: 91 e8 20 00 restore %g0, 0, %o0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
4000b3a8: 81 c7 e0 08 ret
4000b3ac: 91 e8 3f ee restore %g0, -18, %o0
}
4000b3b0: 81 c7 e0 08 ret
4000b3b4: 91 e8 3f e7 restore %g0, -25, %o0
4000b3b8 <_Scheduler_CBS_Get_server_id>:
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000b3b8: 03 10 00 4b sethi %hi(0x40012c00), %g1
<== NOT EXECUTED
4000b3bc: c8 00 63 d0 ld [ %g1 + 0x3d0 ], %g4 ! 40012fd0 <_Scheduler_CBS_Maximum_servers>
<== NOT EXECUTED
4000b3c0: 80 a1 20 00 cmp %g4, 0
<== NOT EXECUTED
4000b3c4: 02 80 00 10 be 4000b404 <_Scheduler_CBS_Get_server_id+0x4c>
<== NOT EXECUTED
4000b3c8: 03 10 00 56 sethi %hi(0x40015800), %g1
4000b3cc: 84 10 20 00 clr %g2
4000b3d0: 82 10 62 08 or %g1, 0x208, %g1
if ( _Scheduler_CBS_Server_list[i].initialized &&
4000b3d4: c6 08 60 1c ldub [ %g1 + 0x1c ], %g3
4000b3d8: 80 a0 e0 00 cmp %g3, 0
4000b3dc: 22 80 00 07 be,a 4000b3f8 <_Scheduler_CBS_Get_server_id+0x40>
4000b3e0: 84 00 a0 01 inc %g2
4000b3e4: c6 00 40 00 ld [ %g1 ], %g3
4000b3e8: 80 a0 c0 08 cmp %g3, %o0
4000b3ec: 22 80 00 08 be,a 4000b40c <_Scheduler_CBS_Get_server_id+0x54>
4000b3f0: c4 22 40 00 st %g2, [ %o1 ]
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000b3f4: 84 00 a0 01 inc %g2
4000b3f8: 80 a0 80 04 cmp %g2, %g4
4000b3fc: 12 bf ff f6 bne 4000b3d4 <_Scheduler_CBS_Get_server_id+0x1c>
4000b400: 82 00 60 20 add %g1, 0x20, %g1
*server_id = i;
return SCHEDULER_CBS_OK;
}
}
return SCHEDULER_CBS_ERROR_NOSERVER;
}
4000b404: 81 c3 e0 08 retl
4000b408: 90 10 3f e7 mov -25, %o0
return SCHEDULER_CBS_OK;
4000b40c: 81 c3 e0 08 retl
4000b410: 90 10 20 00 clr %o0
4000b4a0 <_Scheduler_CBS_Initialize>:
int _Scheduler_CBS_Initialize(void)
{
return SCHEDULER_CBS_OK;
}
4000b4a0: 81 c3 e0 08 retl
<== NOT EXECUTED
4000b4a4: 90 10 20 00 clr %o0
4000a480 <_Scheduler_CBS_Node_initialize>:
const Scheduler_Control *scheduler,
Scheduler_Node *node,
Thread_Control *the_thread,
Priority_Control priority
)
{
4000a480: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Scheduler_CBS_Node *the_node;
_Scheduler_EDF_Node_initialize( scheduler, node, the_thread, priority );
4000a484: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000a488: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
4000a48c: 98 10 00 1c mov %i4, %o4
<== NOT EXECUTED
4000a490: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000a494: 40 00 00 fc call 4000a884 <_Scheduler_EDF_Node_initialize>
<== NOT EXECUTED
4000a498: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
the_node = _Scheduler_CBS_Node_downcast( node );
the_node->cbs_server = NULL;
4000a49c: c0 26 60 50 clr [ %i1 + 0x50 ]
the_node->deadline_node = NULL;
4000a4a0: c0 26 60 54 clr [ %i1 + 0x54 ]
}
4000a4a4: 81 c7 e0 08 ret
4000a4a8: 81 e8 00 00 restore
4000a4ac <_Scheduler_CBS_Release_job>:
Thread_Control *the_thread,
Priority_Node *priority_node,
uint64_t deadline,
Thread_queue_Context *queue_context
)
{
4000a4ac: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
4000a4b0: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
<== NOT EXECUTED
Scheduler_CBS_Node *node;
Scheduler_CBS_Server *serv_info;
node = _Scheduler_CBS_Thread_get_node( the_thread );
serv_info = node->cbs_server;
4000a4b4: c4 00 60 50 ld [ %g1 + 0x50 ], %g2
<== NOT EXECUTED
{
4000a4b8: 98 10 00 1b mov %i3, %o4
<== NOT EXECUTED
/* Budget replenishment for the next job. */
if ( serv_info != NULL ) {
4000a4bc: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000a4c0: 02 80 00 04 be 4000a4d0 <_Scheduler_CBS_Release_job+0x24>
<== NOT EXECUTED
4000a4c4: 9a 10 00 1c mov %i4, %o5
the_thread->cpu_time_budget = serv_info->parameters.budget;
4000a4c8: c4 00 a0 14 ld [ %g2 + 0x14 ], %g2
4000a4cc: c4 26 60 8c st %g2, [ %i1 + 0x8c ]
}
node->deadline_node = priority_node;
_Scheduler_EDF_Release_job(
4000a4d0: b6 10 00 0c mov %o4, %i3
node->deadline_node = priority_node;
4000a4d4: f4 20 60 54 st %i2, [ %g1 + 0x54 ]
_Scheduler_EDF_Release_job(
4000a4d8: 40 00 01 01 call 4000a8dc <_Scheduler_EDF_Release_job>
4000a4dc: 99 e8 00 0d restore %g0, %o5, %o4
4000b508 <_Scheduler_CBS_Set_parameters>:
int _Scheduler_CBS_Set_parameters (
Scheduler_CBS_Server_id server_id,
Scheduler_CBS_Parameters *params
)
{
if ( server_id >= _Scheduler_CBS_Maximum_servers )
4000b508: 03 10 00 4b sethi %hi(0x40012c00), %g1
<== NOT EXECUTED
4000b50c: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 40012fd0 <_Scheduler_CBS_Maximum_servers>
<== NOT EXECUTED
4000b510: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000b514: 08 80 00 1e bleu 4000b58c <_Scheduler_CBS_Set_parameters+0x84>
<== NOT EXECUTED
4000b518: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( params->budget <= 0 ||
4000b51c: c2 02 60 08 ld [ %o1 + 8 ], %g1
4000b520: 80 a0 60 00 cmp %g1, 0
4000b524: 04 80 00 1e ble 4000b59c <_Scheduler_CBS_Set_parameters+0x94> <== ALWAYS TAKEN
4000b528: 01 00 00 00 nop
4000b52c: c2 02 40 00 ld [ %o1 ], %g1
<== NOT EXECUTED
4000b530: 80 a0 60 00 cmp %g1, 0
4000b534: 04 80 00 10 ble 4000b574 <_Scheduler_CBS_Set_parameters+0x6c> <== ALWAYS TAKEN
4000b538: 01 00 00 00 nop
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id].initialized )
4000b53c: 91 2a 20 05 sll %o0, 5, %o0
<== NOT EXECUTED
4000b540: 03 10 00 56 sethi %hi(0x40015800), %g1
4000b544: 82 10 62 08 or %g1, 0x208, %g1 ! 40015a08 <_Scheduler_CBS_Server_list>
4000b548: 82 00 40 08 add %g1, %o0, %g1
4000b54c: c4 08 60 1c ldub [ %g1 + 0x1c ], %g2
4000b550: 80 a0 a0 00 cmp %g2, 0
4000b554: 02 80 00 10 be 4000b594 <_Scheduler_CBS_Set_parameters+0x8c>
4000b558: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_NOSERVER;
_Scheduler_CBS_Server_list[server_id].parameters = *params;
4000b55c: c4 1a 40 00 ldd [ %o1 ], %g2
4000b560: c4 38 60 08 std %g2, [ %g1 + 8 ]
return SCHEDULER_CBS_OK;
4000b564: 90 10 20 00 clr %o0
_Scheduler_CBS_Server_list[server_id].parameters = *params;
4000b568: c4 1a 60 08 ldd [ %o1 + 8 ], %g2
return SCHEDULER_CBS_OK;
4000b56c: 81 c3 e0 08 retl
4000b570: c4 38 60 10 std %g2, [ %g1 + 0x10 ]
if ( params->budget <= 0 ||
4000b574: 12 80 00 06 bne 4000b58c <_Scheduler_CBS_Set_parameters+0x84>
4000b578: 01 00 00 00 nop
4000b57c: c2 02 60 04 ld [ %o1 + 4 ], %g1
4000b580: 80 a0 60 00 cmp %g1, 0
4000b584: 32 bf ff ef bne,a 4000b540 <_Scheduler_CBS_Set_parameters+0x38> <== ALWAYS TAKEN
4000b588: 91 2a 20 05 sll %o0, 5, %o0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
4000b58c: 81 c3 e0 08 retl
4000b590: 90 10 3f ee mov -18, %o0
}
4000b594: 81 c3 e0 08 retl
4000b598: 90 10 3f e7 mov -25, %o0
if ( params->budget <= 0 ||
4000b59c: 12 bf ff fc bne 4000b58c <_Scheduler_CBS_Set_parameters+0x84>
4000b5a0: 01 00 00 00 nop
4000b5a4: c2 02 60 0c ld [ %o1 + 0xc ], %g1
4000b5a8: 80 a0 60 00 cmp %g1, 0
4000b5ac: 32 bf ff e1 bne,a 4000b530 <_Scheduler_CBS_Set_parameters+0x28> <== ALWAYS TAKEN
4000b5b0: c2 02 40 00 ld [ %o1 ], %g1
4000b5b4: 30 bf ff f6 b,a 4000b58c <_Scheduler_CBS_Set_parameters+0x84> <== NOT EXECUTED
4000a50c <_Scheduler_CBS_Unblock>:
void _Scheduler_CBS_Unblock(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
4000a50c: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
Scheduler_CBS_Node *the_node;
Scheduler_CBS_Server *serv_info;
Priority_Control priority;
the_node = _Scheduler_CBS_Node_downcast( node );
serv_info = the_node->cbs_server;
4000a510: c2 06 a0 50 ld [ %i2 + 0x50 ], %g1
<== NOT EXECUTED
priority = _Scheduler_Node_get_priority( &the_node->Base.Base );
priority = SCHEDULER_PRIORITY_PURIFY( priority );
4000a514: c8 06 a0 34 ld [ %i2 + 0x34 ], %g4
<== NOT EXECUTED
4000a518: c4 06 a0 30 ld [ %i2 + 0x30 ], %g2
<== NOT EXECUTED
* Late unblock rule for deadline-driven tasks. The remaining time to
* deadline must be sufficient to serve the remaining computation time
* without increased utilization of this task. It might cause a deadline
* miss of another task.
*/
if ( serv_info != NULL && ( priority & SCHEDULER_EDF_PRIO_MSB ) == 0 ) {
4000a51c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000a520: 02 80 00 1c be 4000a590 <_Scheduler_CBS_Unblock+0x84>
<== NOT EXECUTED
4000a524: 86 09 3f fe and %g4, -2, %g3
4000a528: 80 a0 a0 00 cmp %g2, 0
4000a52c: 06 80 00 19 bl 4000a590 <_Scheduler_CBS_Unblock+0x84>
4000a530: 09 10 00 50 sethi %hi(0x40014000), %g4
time_t deadline = serv_info->parameters.deadline;
time_t budget = serv_info->parameters.budget;
uint32_t deadline_left = the_thread->cpu_time_budget;
Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot;
if ( deadline * budget_left > budget * deadline_left ) {
4000a534: fa 00 60 08 ld [ %g1 + 8 ], %i5
Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot;
4000a538: c8 01 21 dc ld [ %g4 + 0x1dc ], %g4
4000a53c: 9a a0 c0 04 subcc %g3, %g4, %o5
if ( deadline * budget_left > budget * deadline_left ) {
4000a540: f6 06 60 8c ld [ %i1 + 0x8c ], %i3
Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot;
4000a544: 98 60 a0 00 subx %g2, 0, %o4
if ( deadline * budget_left > budget * deadline_left ) {
4000a548: f8 00 60 14 ld [ %g1 + 0x14 ], %i4
4000a54c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000a550: ba 5f 40 0d smul %i5, %o5, %i5
4000a554: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000a558: 88 58 80 0c smul %g2, %o4, %g4
4000a55c: 82 58 40 1b smul %g1, %i3, %g1
4000a560: 88 01 00 1d add %g4, %i5, %g4
4000a564: 86 50 80 0d umul %g2, %o5, %g3
4000a568: 85 40 00 00 rd %y, %g2
4000a56c: ba 57 00 1b umul %i4, %i3, %i5
4000a570: b9 40 00 00 rd %y, %i4
4000a574: 84 01 00 02 add %g4, %g2, %g2
4000a578: b8 00 40 1c add %g1, %i4, %i4
4000a57c: 80 a0 80 1c cmp %g2, %i4
4000a580: 38 80 00 0d bgu,a 4000a5b4 <_Scheduler_CBS_Unblock+0xa8> <== NEVER TAKEN
4000a584: d4 06 a0 54 ld [ %i2 + 0x54 ], %o2
<== NOT EXECUTED
4000a588: 02 80 00 08 be 4000a5a8 <_Scheduler_CBS_Unblock+0x9c>
<== ALWAYS TAKEN
4000a58c: 80 a0 c0 1d cmp %g3, %i5
&queue_context
);
}
}
_Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base );
4000a590: 94 10 00 1a mov %i2, %o2
4000a594: 92 10 00 19 mov %i1, %o1
4000a598: 40 00 01 0c call 4000a9c8 <_Scheduler_EDF_Unblock>
4000a59c: 90 10 00 18 mov %i0, %o0
}
4000a5a0: 81 c7 e0 08 ret
4000a5a4: 81 e8 00 00 restore
if ( deadline * budget_left > budget * deadline_left ) {
4000a5a8: 08 bf ff fb bleu 4000a594 <_Scheduler_CBS_Unblock+0x88> <== NEVER TAKEN
4000a5ac: 94 10 00 1a mov %i2, %o2
_Scheduler_CBS_Cancel_job(
4000a5b0: d4 06 a0 54 ld [ %i2 + 0x54 ], %o2
4000a5b4: 92 10 00 19 mov %i1, %o1
4000a5b8: 90 10 00 18 mov %i0, %o0
RTEMS_INLINE_ROUTINE void _Thread_queue_Context_clear_priority_updates(
Thread_queue_Context *queue_context
)
{
queue_context->Priority.update_count = 0;
4000a5bc: c0 27 bf f0 clr [ %fp + -16 ]
4000a5c0: 7f ff ff c8 call 4000a4e0 <_Scheduler_CBS_Cancel_job>
4000a5c4: 96 07 bf dc add %fp, -36, %o3
_Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base );
4000a5c8: 94 10 00 1a mov %i2, %o2
4000a5cc: 92 10 00 19 mov %i1, %o1
4000a5d0: 40 00 00 fe call 4000a9c8 <_Scheduler_EDF_Unblock>
4000a5d4: 90 10 00 18 mov %i0, %o0
}
4000a5d8: 81 c7 e0 08 ret
4000a5dc: 81 e8 00 00 restore
4000a6b0 <_Scheduler_EDF_Block>:
void _Scheduler_EDF_Block(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
4000a6b0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Scheduler_EDF_Extract(
Scheduler_EDF_Context *context,
Scheduler_EDF_Node *node
)
{
_RBTree_Extract( &context->Ready, &node->Node );
4000a6b4: d0 06 00 00 ld [ %i0 ], %o0
<== NOT EXECUTED
4000a6b8: 7f ff fd 74 call 40009c88 <_RBTree_Extract>
<== NOT EXECUTED
4000a6bc: 92 06 a0 38 add %i2, 0x38, %o1
<== NOT EXECUTED
{
( *extract )( scheduler, the_thread, node );
/* TODO: flash critical section? */
if ( _Thread_Is_executing( the_thread ) || _Thread_Is_heir( the_thread ) ) {
4000a6c0: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2
4000a6c4: 80 a6 40 02 cmp %i1, %g2
4000a6c8: 02 80 00 08 be 4000a6e8 <_Scheduler_EDF_Block+0x38>
4000a6cc: 01 00 00 00 nop
4000a6d0: c2 01 a0 24 ld [ %g6 + 0x24 ], %g1
4000a6d4: 80 a6 40 01 cmp %i1, %g1
4000a6d8: 02 80 00 04 be 4000a6e8 <_Scheduler_EDF_Block+0x38>
<== NEVER TAKEN
4000a6dc: 01 00 00 00 nop
the_thread,
node,
_Scheduler_EDF_Extract_body,
_Scheduler_EDF_Schedule_body
);
}
4000a6e0: 81 c7 e0 08 ret
4000a6e4: 81 e8 00 00 restore
Scheduler_EDF_Node *node;
(void) the_thread;
context = _Scheduler_EDF_Get_context( scheduler );
first = _RBTree_Minimum( &context->Ready );
4000a6e8: 40 00 12 7d call 4000f0dc <_RBTree_Minimum>
4000a6ec: d0 06 00 00 ld [ %i0 ], %o0
node = RTEMS_CONTAINER_OF( first, Scheduler_EDF_Node, Node );
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
4000a6f0: f6 02 3f c8 ld [ %o0 + -56 ], %i3
RTEMS_INLINE_ROUTINE void _Scheduler_Update_heir(
Thread_Control *new_heir,
bool force_dispatch
)
{
Thread_Control *heir = _Thread_Heir;
4000a6f4: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4000a6f8: 80 a6 c0 1d cmp %i3, %i5
4000a6fc: 02 bf ff f9 be 4000a6e0 <_Scheduler_EDF_Block+0x30>
<== NEVER TAKEN
4000a700: b8 10 00 06 mov %g6, %i4
*time = _Timecounter_Sbinuptime();
4000a704: 7f ff fa 04 call 40008f14 <_Timecounter_Sbinuptime>
4000a708: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0
4000a70c: d0 3f 20 28 std %o0, [ %i4 + 0x28 ]
const Timestamp_Control *_start,
const Timestamp_Control *_end,
Timestamp_Control *_result
)
{
*_result = *_end - *_start;
4000a710: b2 a2 40 11 subcc %o1, %l1, %i1
*_time += *_add;
4000a714: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4
*_result = *_end - *_start;
4000a718: b0 62 00 10 subx %o0, %l0, %i0
*_time += *_add;
4000a71c: 86 83 40 19 addcc %o5, %i1, %g3
4000a720: 84 43 00 18 addx %o4, %i0, %g2
4000a724: c4 3f 60 98 std %g2, [ %i5 + 0x98 ]
heir->Scheduler.state = THREAD_SCHEDULER_BLOCKED;
new_heir->Scheduler.state = THREAD_SCHEDULER_SCHEDULED;
#endif
_Thread_Update_CPU_time_used( heir, _Thread_Get_CPU( heir ) );
_Thread_Heir = new_heir;
_Thread_Dispatch_necessary = true;
4000a728: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
4000a72c: f6 21 a0 24 st %i3, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
4000a730: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
4000a734: 81 c7 e0 08 ret
4000a738: 81 e8 00 00 restore
4000a934 <_Scheduler_EDF_Cancel_job>:
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Priority_Node *priority_node,
Thread_queue_Context *queue_context
)
{
4000a934: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
(void) scheduler;
_Thread_Wait_acquire_critical( the_thread, queue_context );
_Thread_Priority_remove( the_thread, priority_node, queue_context );
4000a938: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
4000a93c: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4000a940: 40 00 01 86 call 4000af58 <_Thread_Priority_remove>
<== NOT EXECUTED
4000a944: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
RB_COLOR( the_node, Node ) = -1;
4000a948: 82 10 3f ff mov -1, %g1
4000a94c: c2 26 a0 0c st %g1, [ %i2 + 0xc ]
_Priority_Node_set_inactive( priority_node );
_Thread_Wait_release_critical( the_thread, queue_context );
}
4000a950: 81 c7 e0 08 ret
4000a954: 81 e8 00 00 restore
4000a89c <_Scheduler_EDF_Initialize>:
RB_INIT( the_rbtree );
4000a89c: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
{
Scheduler_EDF_Context *context =
_Scheduler_EDF_Get_context( scheduler );
_RBTree_Initialize_empty( &context->Ready );
}
4000a8a0: 81 c3 e0 08 retl
<== NOT EXECUTED
4000a8a4: c0 20 40 00 clr [ %g1 ]
4000a8a8 <_Scheduler_EDF_Map_priority>:
Priority_Control _Scheduler_EDF_Map_priority(
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
return SCHEDULER_EDF_PRIO_MSB | SCHEDULER_PRIORITY_MAP( priority );
4000a8a8: 83 2a 60 01 sll %o1, 1, %g1
<== NOT EXECUTED
4000a8ac: 85 32 a0 1f srl %o2, 0x1f, %g2
<== NOT EXECUTED
}
4000a8b0: 93 2a a0 01 sll %o2, 1, %o1
<== NOT EXECUTED
return SCHEDULER_EDF_PRIO_MSB | SCHEDULER_PRIORITY_MAP( priority );
4000a8b4: 82 10 80 01 or %g2, %g1, %g1
<== NOT EXECUTED
}
4000a8b8: 11 20 00 00 sethi %hi(0x80000000), %o0
<== NOT EXECUTED
4000a8bc: 81 c3 e0 08 retl
<== NOT EXECUTED
4000a8c0: 90 10 40 08 or %g1, %o0, %o0
4000a884 <_Scheduler_EDF_Node_initialize>:
const Scheduler_Control *scheduler,
Scheduler_Node *node,
Thread_Control *the_thread,
Priority_Control priority
)
{
4000a884: 84 10 00 0b mov %o3, %g2
<== NOT EXECUTED
4000a888: 86 10 00 0c mov %o4, %g3
<== NOT EXECUTED
Scheduler_Node *node,
Thread_Control *the_thread,
Priority_Control priority
)
{
node->owner = the_thread;
4000a88c: d4 22 40 00 st %o2, [ %o1 ]
<== NOT EXECUTED
node->Priority.value = priority;
4000a890: c4 3a 60 30 std %g2, [ %o1 + 0x30 ]
<== NOT EXECUTED
_Scheduler_Node_do_initialize( scheduler, node, the_thread, priority );
the_node = _Scheduler_EDF_Node_downcast( node );
_RBTree_Initialize_node( &the_node->Node );
the_node->priority = priority;
}
4000a894: 81 c3 e0 08 retl
<== NOT EXECUTED
4000a898: c4 3a 60 48 std %g2, [ %o1 + 0x48 ]
4000a8dc <_Scheduler_EDF_Release_job>:
* There is no integer overflow problem here due to the
* SCHEDULER_PRIORITY_MAP(). The deadline is in clock ticks. With the
* minimum clock tick interval of 1us, the uptime is limited to about 146235
* years.
*/
_Priority_Node_set_priority(
4000a8dc: 85 33 20 1f srl %o4, 0x1f, %g2
<== NOT EXECUTED
4000a8e0: 97 2a e0 01 sll %o3, 1, %o3
<== NOT EXECUTED
4000a8e4: 99 2b 20 01 sll %o4, 1, %o4
<== NOT EXECUTED
4000a8e8: 96 12 c0 02 or %o3, %g2, %o3
<== NOT EXECUTED
4000a8ec: d8 22 a0 14 st %o4, [ %o2 + 0x14 ]
<== NOT EXECUTED
{
4000a8f0: 82 10 00 0a mov %o2, %g1
<== NOT EXECUTED
_Priority_Node_set_priority(
4000a8f4: d6 22 a0 10 st %o3, [ %o2 + 0x10 ]
<== NOT EXECUTED
priority_node,
SCHEDULER_PRIORITY_MAP( deadline )
);
if ( _Priority_Node_is_active( priority_node ) ) {
4000a8f8: c4 02 a0 0c ld [ %o2 + 0xc ], %g2
<== NOT EXECUTED
4000a8fc: 80 a0 bf ff cmp %g2, -1
<== NOT EXECUTED
4000a900: 02 80 00 08 be 4000a920 <_Scheduler_EDF_Release_job+0x44>
<== NOT EXECUTED
4000a904: 90 10 00 09 mov %o1, %o0
_Thread_Priority_changed(
4000a908: 96 10 00 0d mov %o5, %o3
4000a90c: 94 10 20 00 clr %o2
4000a910: 92 10 00 01 mov %g1, %o1
4000a914: 82 13 c0 00 mov %o7, %g1
4000a918: 40 00 01 95 call 4000af6c <_Thread_Priority_changed>
4000a91c: 9e 10 40 00 mov %g1, %o7
priority_node,
false,
queue_context
);
} else {
_Thread_Priority_add( the_thread, priority_node, queue_context );
4000a920: 94 10 00 0d mov %o5, %o2
4000a924: 92 10 00 01 mov %g1, %o1
4000a928: 82 13 c0 00 mov %o7, %g1
4000a92c: 40 00 01 86 call 4000af44 <_Thread_Priority_add>
4000a930: 9e 10 40 00 mov %g1, %o7
4000a958 <_Scheduler_EDF_Schedule>:
void _Scheduler_EDF_Schedule(
const Scheduler_Control *scheduler,
Thread_Control *the_thread
)
{
4000a958: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
first = _RBTree_Minimum( &context->Ready );
4000a95c: 40 00 11 e0 call 4000f0dc <_RBTree_Minimum>
<== NOT EXECUTED
4000a960: d0 06 00 00 ld [ %i0 ], %o0
<== NOT EXECUTED
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
4000a964: f6 02 3f c8 ld [ %o0 + -56 ], %i3
Thread_Control *heir = _Thread_Heir;
4000a968: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4000a96c: 80 a6 c0 1d cmp %i3, %i5
4000a970: 02 80 00 06 be 4000a988 <_Scheduler_EDF_Schedule+0x30> <== ALWAYS TAKEN
4000a974: b8 10 00 06 mov %g6, %i4
4000a978: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1
<== NOT EXECUTED
4000a97c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000a980: 12 80 00 04 bne 4000a990 <_Scheduler_EDF_Schedule+0x38>
<== NOT EXECUTED
4000a984: 01 00 00 00 nop
<== NOT EXECUTED
_Scheduler_EDF_Schedule_body( scheduler, the_thread, false );
}
4000a988: 81 c7 e0 08 ret
4000a98c: 81 e8 00 00 restore
4000a990: 7f ff f9 61 call 40008f14 <_Timecounter_Sbinuptime>
<== NOT EXECUTED
4000a994: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0
<== NOT EXECUTED
4000a998: d0 3f 20 28 std %o0, [ %i4 + 0x28 ]
<== NOT EXECUTED
*_result = *_end - *_start;
4000a99c: b2 a2 40 11 subcc %o1, %l1, %i1
<== NOT EXECUTED
*_time += *_add;
4000a9a0: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4
<== NOT EXECUTED
*_result = *_end - *_start;
4000a9a4: b0 62 00 10 subx %o0, %l0, %i0
<== NOT EXECUTED
*_time += *_add;
4000a9a8: 86 83 40 19 addcc %o5, %i1, %g3
<== NOT EXECUTED
4000a9ac: 84 43 00 18 addx %o4, %i0, %g2
<== NOT EXECUTED
4000a9b0: c4 3f 60 98 std %g2, [ %i5 + 0x98 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
4000a9b4: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
_Thread_Heir = new_heir;
4000a9b8: f6 21 a0 24 st %i3, [ %g6 + 0x24 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
4000a9bc: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
<== NOT EXECUTED
4000a9c0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a9c4: 81 e8 00 00 restore
<== NOT EXECUTED
4000a9c8 <_Scheduler_EDF_Unblock>:
void _Scheduler_EDF_Unblock(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
4000a9c8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Priority_Control insert_priority;
context = _Scheduler_EDF_Get_context( scheduler );
the_node = _Scheduler_EDF_Node_downcast( node );
priority = _Scheduler_Node_get_priority( &the_node->Base );
priority = SCHEDULER_PRIORITY_PURIFY( priority );
4000a9cc: fa 06 a0 30 ld [ %i2 + 0x30 ], %i5
<== NOT EXECUTED
4000a9d0: f8 06 a0 34 ld [ %i2 + 0x34 ], %i4
<== NOT EXECUTED
4000a9d4: d0 06 00 00 ld [ %i0 ], %o0
<== NOT EXECUTED
4000a9d8: b8 0f 3f fe and %i4, -2, %i4
<== NOT EXECUTED
insert_priority = SCHEDULER_PRIORITY_APPEND( priority );
the_node->priority = priority;
4000a9dc: fa 26 a0 48 st %i5, [ %i2 + 0x48 ]
<== NOT EXECUTED
link = _RBTree_Root_reference( the_rbtree );
4000a9e0: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
4000a9e4: f8 26 a0 4c st %i4, [ %i2 + 0x4c ]
<== NOT EXECUTED
insert_priority = SCHEDULER_PRIORITY_APPEND( priority );
4000a9e8: b6 17 20 01 or %i4, 1, %i3
<== NOT EXECUTED
while ( *link != NULL ) {
4000a9ec: c2 00 80 00 ld [ %g2 ], %g1
<== NOT EXECUTED
_RBTree_Insert_inline(
4000a9f0: 88 06 a0 38 add %i2, 0x38, %g4
<== NOT EXECUTED
4000a9f4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000a9f8: 02 80 00 12 be 4000aa40 <_Scheduler_EDF_Unblock+0x78>
<== NOT EXECUTED
4000a9fc: 86 10 20 00 clr %g3
if ( ( *less )( key, parent ) ) {
4000aa00: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000aa04: 80 a0 80 1d cmp %g2, %i5
4000aa08: 0a 80 00 09 bcs 4000aa2c <_Scheduler_EDF_Unblock+0x64>
4000aa0c: 84 00 60 04 add %g1, 4, %g2
4000aa10: 12 80 00 1e bne 4000aa88 <_Scheduler_EDF_Unblock+0xc0>
4000aa14: 84 10 00 01 mov %g1, %g2
4000aa18: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4000aa1c: 80 a0 80 1b cmp %g2, %i3
4000aa20: 1a 80 00 1a bcc 4000aa88 <_Scheduler_EDF_Unblock+0xc0>
4000aa24: 84 10 00 01 mov %g1, %g2
return &RB_RIGHT( the_node, Node );
4000aa28: 84 00 60 04 add %g1, 4, %g2
{
4000aa2c: 86 10 00 01 mov %g1, %g3
while ( *link != NULL ) {
4000aa30: c2 00 80 00 ld [ %g2 ], %g1
4000aa34: 80 a0 60 00 cmp %g1, 0
4000aa38: 32 bf ff f3 bne,a 4000aa04 <_Scheduler_EDF_Unblock+0x3c>
4000aa3c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
RB_SET( child, parent, Node );
4000aa40: c6 26 a0 40 st %g3, [ %i2 + 0x40 ]
4000aa44: 82 10 20 01 mov 1, %g1
4000aa48: c0 26 a0 3c clr [ %i2 + 0x3c ]
_RBTree_Insert_color( the_rbtree, the_node );
4000aa4c: 92 10 00 04 mov %g4, %o1
RB_SET( child, parent, Node );
4000aa50: c2 26 a0 44 st %g1, [ %i2 + 0x44 ]
4000aa54: c0 26 a0 38 clr [ %i2 + 0x38 ]
_RBTree_Insert_color( the_rbtree, the_node );
4000aa58: 7f ff fd ee call 4000a210 <_RBTree_Insert_color>
4000aa5c: c8 20 80 00 st %g4, [ %g2 ]
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
4000aa60: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3
4000aa64: c2 06 e0 38 ld [ %i3 + 0x38 ], %g1
4000aa68: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4000aa6c: 80 a0 80 1d cmp %g2, %i5
4000aa70: 18 80 00 0b bgu 4000aa9c <_Scheduler_EDF_Unblock+0xd4>
4000aa74: b4 10 00 06 mov %g6, %i2
4000aa78: 22 80 00 06 be,a 4000aa90 <_Scheduler_EDF_Unblock+0xc8>
4000aa7c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
_Scheduler_Update_heir(
the_thread,
priority == ( SCHEDULER_EDF_PRIO_MSB | PRIORITY_PSEUDO_ISR )
);
}
}
4000aa80: 81 c7 e0 08 ret
4000aa84: 81 e8 00 00 restore
{
4000aa88: 10 bf ff ea b 4000aa30 <_Scheduler_EDF_Unblock+0x68>
4000aa8c: 86 10 00 01 mov %g1, %g3
if ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
4000aa90: 80 a0 40 1c cmp %g1, %i4
4000aa94: 08 80 00 19 bleu 4000aaf8 <_Scheduler_EDF_Unblock+0x130>
4000aa98: 01 00 00 00 nop
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4000aa9c: 80 a6 c0 19 cmp %i3, %i1
4000aaa0: 02 bf ff f8 be 4000aa80 <_Scheduler_EDF_Unblock+0xb8>
<== NEVER TAKEN
4000aaa4: 03 20 00 00 sethi %hi(0x80000000), %g1
_Scheduler_Update_heir(
4000aaa8: ba 1f 40 01 xor %i5, %g1, %i5
4000aaac: 80 97 40 1c orcc %i5, %i4, %g0
4000aab0: 02 80 00 06 be 4000aac8 <_Scheduler_EDF_Unblock+0x100> <== NEVER TAKEN
4000aab4: 01 00 00 00 nop
4000aab8: c2 0e e0 89 ldub [ %i3 + 0x89 ], %g1
4000aabc: 80 a0 60 00 cmp %g1, 0
4000aac0: 02 80 00 0e be 4000aaf8 <_Scheduler_EDF_Unblock+0x130>
4000aac4: 01 00 00 00 nop
4000aac8: 7f ff f9 13 call 40008f14 <_Timecounter_Sbinuptime>
4000aacc: e0 1e a0 28 ldd [ %i2 + 0x28 ], %l0
4000aad0: d0 3e a0 28 std %o0, [ %i2 + 0x28 ]
*_result = *_end - *_start;
4000aad4: ba a2 40 11 subcc %o1, %l1, %i5
*_time += *_add;
4000aad8: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4
*_result = *_end - *_start;
4000aadc: b8 62 00 10 subx %o0, %l0, %i4
*_time += *_add;
4000aae0: 86 83 40 1d addcc %o5, %i5, %g3
4000aae4: 84 43 00 1c addx %o4, %i4, %g2
4000aae8: c4 3e e0 98 std %g2, [ %i3 + 0x98 ]
_Thread_Dispatch_necessary = true;
4000aaec: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
4000aaf0: f2 21 a0 24 st %i1, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
4000aaf4: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
}
4000aaf8: 81 c7 e0 08 ret
4000aafc: 81 e8 00 00 restore
4000a8c4 <_Scheduler_EDF_Unmap_priority>:
Priority_Control _Scheduler_EDF_Unmap_priority(
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
return SCHEDULER_PRIORITY_UNMAP( priority & ~SCHEDULER_EDF_PRIO_MSB );
4000a8c4: 95 32 a0 01 srl %o2, 1, %o2
<== NOT EXECUTED
4000a8c8: 83 2a 60 1f sll %o1, 0x1f, %g1
<== NOT EXECUTED
4000a8cc: 91 2a 60 01 sll %o1, 1, %o0
<== NOT EXECUTED
}
4000a8d0: 92 10 40 0a or %g1, %o2, %o1
<== NOT EXECUTED
4000a8d4: 81 c3 e0 08 retl
<== NOT EXECUTED
4000a8d8: 91 32 20 02 srl %o0, 2, %o0
<== NOT EXECUTED
4000a73c <_Scheduler_EDF_Update_priority>:
void _Scheduler_EDF_Update_priority(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
4000a73c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Scheduler_EDF_Context *context;
Scheduler_EDF_Node *the_node;
Priority_Control priority;
Priority_Control insert_priority;
if ( !_Thread_Is_ready( the_thread ) ) {
4000a740: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
<== NOT EXECUTED
4000a744: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000a748: 12 80 00 4d bne 4000a87c <_Scheduler_EDF_Update_priority+0x140>
<== NOT EXECUTED
4000a74c: 01 00 00 00 nop
4000a750: fa 06 a0 30 ld [ %i2 + 0x30 ], %i5
4000a754: f8 06 a0 34 ld [ %i2 + 0x34 ], %i4
the_node = _Scheduler_EDF_Node_downcast( node );
insert_priority = _Scheduler_Node_get_priority( &the_node->Base );
priority = SCHEDULER_PRIORITY_PURIFY( insert_priority );
if ( priority == the_node->priority ) {
4000a758: c4 06 a0 48 ld [ %i2 + 0x48 ], %g2
4000a75c: 80 a0 80 1d cmp %g2, %i5
4000a760: 02 80 00 34 be 4000a830 <_Scheduler_EDF_Update_priority+0xf4>
4000a764: 82 0f 3f fe and %i4, -2, %g1
/* Nothing to do */
return;
}
the_node->priority = priority;
4000a768: c2 26 a0 4c st %g1, [ %i2 + 0x4c ]
_RBTree_Extract( &context->Ready, &node->Node );
4000a76c: b6 06 a0 38 add %i2, 0x38, %i3
4000a770: fa 26 a0 48 st %i5, [ %i2 + 0x48 ]
4000a774: 92 10 00 1b mov %i3, %o1
4000a778: f2 06 00 00 ld [ %i0 ], %i1
4000a77c: 7f ff fd 43 call 40009c88 <_RBTree_Extract>
4000a780: 90 10 00 19 mov %i1, %o0
link = _RBTree_Root_reference( the_rbtree );
4000a784: 84 10 00 19 mov %i1, %g2
while ( *link != NULL ) {
4000a788: c2 00 80 00 ld [ %g2 ], %g1
4000a78c: 80 a0 60 00 cmp %g1, 0
4000a790: 02 80 00 12 be 4000a7d8 <_Scheduler_EDF_Update_priority+0x9c> <== NEVER TAKEN
4000a794: 86 10 20 00 clr %g3
if ( ( *less )( key, parent ) ) {
4000a798: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000a79c: 80 a0 80 1d cmp %g2, %i5
4000a7a0: 0a 80 00 09 bcs 4000a7c4 <_Scheduler_EDF_Update_priority+0x88>
4000a7a4: 84 00 60 04 add %g1, 4, %g2
4000a7a8: 12 80 00 28 bne 4000a848 <_Scheduler_EDF_Update_priority+0x10c>
4000a7ac: 84 10 00 01 mov %g1, %g2
4000a7b0: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4000a7b4: 80 a0 80 1c cmp %g2, %i4
4000a7b8: 1a 80 00 24 bcc 4000a848 <_Scheduler_EDF_Update_priority+0x10c>
4000a7bc: 84 10 00 01 mov %g1, %g2
return &RB_RIGHT( the_node, Node );
4000a7c0: 84 00 60 04 add %g1, 4, %g2
{
4000a7c4: 86 10 00 01 mov %g1, %g3
while ( *link != NULL ) {
4000a7c8: c2 00 80 00 ld [ %g2 ], %g1
4000a7cc: 80 a0 60 00 cmp %g1, 0
4000a7d0: 32 bf ff f3 bne,a 4000a79c <_Scheduler_EDF_Update_priority+0x60>
4000a7d4: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
RB_SET( child, parent, Node );
4000a7d8: c6 26 a0 40 st %g3, [ %i2 + 0x40 ]
4000a7dc: a0 10 20 01 mov 1, %l0
4000a7e0: c0 26 a0 3c clr [ %i2 + 0x3c ]
_RBTree_Insert_color( the_rbtree, the_node );
4000a7e4: 92 10 00 1b mov %i3, %o1
RB_SET( child, parent, Node );
4000a7e8: c0 26 a0 38 clr [ %i2 + 0x38 ]
_RBTree_Insert_color( the_rbtree, the_node );
4000a7ec: 90 10 00 19 mov %i1, %o0
RB_SET( child, parent, Node );
4000a7f0: e0 26 a0 44 st %l0, [ %i2 + 0x44 ]
_RBTree_Insert_color( the_rbtree, the_node );
4000a7f4: 7f ff fe 87 call 4000a210 <_RBTree_Insert_color>
4000a7f8: f6 20 80 00 st %i3, [ %g2 ]
first = _RBTree_Minimum( &context->Ready );
4000a7fc: 40 00 12 38 call 4000f0dc <_RBTree_Minimum>
4000a800: d0 06 00 00 ld [ %i0 ], %o0
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
4000a804: f6 02 3f c8 ld [ %o0 + -56 ], %i3
Thread_Control *heir = _Thread_Heir;
4000a808: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4000a80c: 80 a6 c0 1d cmp %i3, %i5
4000a810: 02 80 00 06 be 4000a828 <_Scheduler_EDF_Update_priority+0xec>
4000a814: b8 10 00 06 mov %g6, %i4
4000a818: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1
4000a81c: 80 a0 60 00 cmp %g1, 0
4000a820: 12 80 00 0c bne 4000a850 <_Scheduler_EDF_Update_priority+0x114> <== ALWAYS TAKEN
4000a824: 01 00 00 00 nop
context = _Scheduler_EDF_Get_context( scheduler );
_Scheduler_EDF_Extract( context, the_node );
_Scheduler_EDF_Enqueue( context, the_node, insert_priority );
_Scheduler_EDF_Schedule_body( scheduler, the_thread, false );
}
4000a828: 81 c7 e0 08 ret
4000a82c: 81 e8 00 00 restore
if ( priority == the_node->priority ) {
4000a830: c4 06 a0 4c ld [ %i2 + 0x4c ], %g2
4000a834: 80 a0 80 01 cmp %g2, %g1
4000a838: 32 bf ff cd bne,a 4000a76c <_Scheduler_EDF_Update_priority+0x30> <== ALWAYS TAKEN
4000a83c: c2 26 a0 4c st %g1, [ %i2 + 0x4c ]
}
4000a840: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a844: 81 e8 00 00 restore
<== NOT EXECUTED
{
4000a848: 10 bf ff e0 b 4000a7c8 <_Scheduler_EDF_Update_priority+0x8c>
4000a84c: 86 10 00 01 mov %g1, %g3
4000a850: 7f ff f9 b1 call 40008f14 <_Timecounter_Sbinuptime>
4000a854: f0 19 a0 28 ldd [ %g6 + 0x28 ], %i0
4000a858: d0 3f 20 28 std %o0, [ %i4 + 0x28 ]
*_result = *_end - *_start;
4000a85c: 9a a2 40 19 subcc %o1, %i1, %o5
4000a860: 98 62 00 18 subx %o0, %i0, %o4
*_time += *_add;
4000a864: f0 1f 60 98 ldd [ %i5 + 0x98 ], %i0
4000a868: 86 86 40 0d addcc %i1, %o5, %g3
4000a86c: 84 46 00 0c addx %i0, %o4, %g2
4000a870: c4 3f 60 98 std %g2, [ %i5 + 0x98 ]
_Thread_Heir = new_heir;
4000a874: f6 21 a0 24 st %i3, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
4000a878: e0 29 a0 1c stb %l0, [ %g6 + 0x1c ]
}
4000a87c: 81 c7 e0 08 ret
4000a880: 81 e8 00 00 restore
4000ab00 <_Scheduler_EDF_Yield>:
void _Scheduler_EDF_Yield(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
4000ab00: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_RBTree_Extract( &context->Ready, &node->Node );
4000ab04: f8 06 00 00 ld [ %i0 ], %i4
<== NOT EXECUTED
4000ab08: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000ab0c: ba 06 a0 38 add %i2, 0x38, %i5
<== NOT EXECUTED
4000ab10: 7f ff fc 5e call 40009c88 <_RBTree_Extract>
<== NOT EXECUTED
4000ab14: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
link = _RBTree_Root_reference( the_rbtree );
4000ab18: 84 10 00 1c mov %i4, %g2
while ( *link != NULL ) {
4000ab1c: c2 00 80 00 ld [ %g2 ], %g1
context = _Scheduler_EDF_Get_context( scheduler );
the_node = _Scheduler_EDF_Node_downcast( node );
_Scheduler_EDF_Extract( context, the_node );
_Scheduler_EDF_Enqueue( context, the_node, the_node->priority );
4000ab20: c8 06 a0 48 ld [ %i2 + 0x48 ], %g4
4000ab24: f6 06 a0 4c ld [ %i2 + 0x4c ], %i3
4000ab28: 80 a0 60 00 cmp %g1, 0
4000ab2c: 02 80 00 12 be 4000ab74 <_Scheduler_EDF_Yield+0x74>
<== NEVER TAKEN
4000ab30: 86 10 20 00 clr %g3
if ( ( *less )( key, parent ) ) {
4000ab34: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000ab38: 80 a0 80 04 cmp %g2, %g4
4000ab3c: 0a 80 00 09 bcs 4000ab60 <_Scheduler_EDF_Yield+0x60>
<== NEVER TAKEN
4000ab40: 84 00 60 04 add %g1, 4, %g2
4000ab44: 12 80 00 29 bne 4000abe8 <_Scheduler_EDF_Yield+0xe8>
<== NEVER TAKEN
4000ab48: 84 10 00 01 mov %g1, %g2
4000ab4c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4000ab50: 80 a0 80 1b cmp %g2, %i3
4000ab54: 1a 80 00 25 bcc 4000abe8 <_Scheduler_EDF_Yield+0xe8>
4000ab58: 84 10 00 01 mov %g1, %g2
return &RB_RIGHT( the_node, Node );
4000ab5c: 84 00 60 04 add %g1, 4, %g2
{
4000ab60: 86 10 00 01 mov %g1, %g3
while ( *link != NULL ) {
4000ab64: c2 00 80 00 ld [ %g2 ], %g1
4000ab68: 80 a0 60 00 cmp %g1, 0
4000ab6c: 32 bf ff f3 bne,a 4000ab38 <_Scheduler_EDF_Yield+0x38>
4000ab70: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
RB_SET( child, parent, Node );
4000ab74: c6 26 a0 40 st %g3, [ %i2 + 0x40 ]
4000ab78: b6 10 20 01 mov 1, %i3
4000ab7c: c0 26 a0 3c clr [ %i2 + 0x3c ]
_RBTree_Insert_color( the_rbtree, the_node );
4000ab80: 92 10 00 1d mov %i5, %o1
RB_SET( child, parent, Node );
4000ab84: c0 26 a0 38 clr [ %i2 + 0x38 ]
_RBTree_Insert_color( the_rbtree, the_node );
4000ab88: 90 10 00 1c mov %i4, %o0
RB_SET( child, parent, Node );
4000ab8c: f6 26 a0 44 st %i3, [ %i2 + 0x44 ]
_RBTree_Insert_color( the_rbtree, the_node );
4000ab90: 7f ff fd a0 call 4000a210 <_RBTree_Insert_color>
4000ab94: fa 20 80 00 st %i5, [ %g2 ]
first = _RBTree_Minimum( &context->Ready );
4000ab98: 40 00 11 51 call 4000f0dc <_RBTree_Minimum>
4000ab9c: d0 06 00 00 ld [ %i0 ], %o0
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
4000aba0: f4 02 3f c8 ld [ %o0 + -56 ], %i2
Thread_Control *heir = _Thread_Heir;
4000aba4: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4000aba8: 80 a6 80 1d cmp %i2, %i5
4000abac: 02 80 00 0d be 4000abe0 <_Scheduler_EDF_Yield+0xe0>
<== NEVER TAKEN
4000abb0: b8 10 00 06 mov %g6, %i4
4000abb4: 7f ff f8 d8 call 40008f14 <_Timecounter_Sbinuptime>
4000abb8: f0 19 a0 28 ldd [ %g6 + 0x28 ], %i0
4000abbc: d0 3f 20 28 std %o0, [ %i4 + 0x28 ]
*_result = *_end - *_start;
4000abc0: 9a a2 40 19 subcc %o1, %i1, %o5
4000abc4: 98 62 00 18 subx %o0, %i0, %o4
*_time += *_add;
4000abc8: f0 1f 60 98 ldd [ %i5 + 0x98 ], %i0
4000abcc: 86 86 40 0d addcc %i1, %o5, %g3
4000abd0: 84 46 00 0c addx %i0, %o4, %g2
4000abd4: c4 3f 60 98 std %g2, [ %i5 + 0x98 ]
_Thread_Heir = new_heir;
4000abd8: f4 21 a0 24 st %i2, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
4000abdc: f6 29 a0 1c stb %i3, [ %g6 + 0x1c ]
_Scheduler_EDF_Schedule_body( scheduler, the_thread, true );
}
4000abe0: 81 c7 e0 08 ret
4000abe4: 81 e8 00 00 restore
{
4000abe8: 10 bf ff df b 4000ab64 <_Scheduler_EDF_Yield+0x64>
4000abec: 86 10 00 01 mov %g1, %g3
4000aac8 <_Scheduler_Get_affinity>:
bool _Scheduler_Get_affinity(
Thread_Control *the_thread,
size_t cpusetsize,
cpu_set_t *cpuset
)
{
4000aac8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
const Processor_mask *src,
size_t dst_size,
cpu_set_t *dst
)
{
return _Processor_mask_Copy(
4000aacc: 96 10 20 04 mov 4, %o3
<== NOT EXECUTED
4000aad0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000aad4: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
4000aad8: 15 10 00 4a sethi %hi(0x40012800), %o2
<== NOT EXECUTED
4000aadc: 7f ff fd 8b call 4000a108 <_Processor_mask_Copy>
<== NOT EXECUTED
4000aae0: 94 12 a1 00 or %o2, 0x100, %o2 ! 40012900 <_Processor_mask_The_one_and_only>
<== NOT EXECUTED
#endif
status = _Processor_mask_To_cpu_set_t( affinity, cpusetsize, cpuset );
_Scheduler_Release_critical( scheduler, &lock_context );
return status == PROCESSOR_MASK_COPY_LOSSLESS;
}
4000aae4: 80 a0 00 08 cmp %g0, %o0
4000aae8: b0 60 3f ff subx %g0, -1, %i0
4000aaec: 81 c7 e0 08 ret
4000aaf0: 81 e8 00 00 restore
40009c0c <_Scheduler_Handler_initialization>:
#endif
#include <rtems/score/schedulerimpl.h>
void _Scheduler_Handler_initialization(void)
{
40009c0c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
scheduler = &_Scheduler_Table[ i ];
#if defined(RTEMS_SMP)
context = _Scheduler_Get_context( scheduler );
#endif
_ISR_lock_Initialize( &context->Lock, "Scheduler" );
( *scheduler->Operations.initialize )( scheduler );
40009c10: 11 10 00 63 sethi %hi(0x40018c00), %o0
<== NOT EXECUTED
40009c14: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 40018dc8 <_Scheduler_Table>
40009c18: c2 02 20 04 ld [ %o0 + 4 ], %g1
40009c1c: 9f c0 40 00 call %g1
40009c20: 01 00 00 00 nop
}
}
40009c24: 81 c7 e0 08 ret
40009c28: 81 e8 00 00 restore
40024d1c <_Scheduler_Set_affinity>:
bool _Scheduler_Set_affinity(
Thread_Control *the_thread,
size_t cpusetsize,
const cpu_set_t *cpuset
)
{
40024d1c: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
Processor_mask *dst,
size_t src_size,
const cpu_set_t *src
)
{
return _Processor_mask_Copy(
40024d20: 92 10 20 04 mov 4, %o1
<== NOT EXECUTED
40024d24: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
40024d28: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
40024d2c: 90 07 bf fc add %fp, -4, %o0
40024d30: 7f ff fb e2 call 40023cb8 <_Processor_mask_Copy>
40024d34: b0 10 20 00 clr %i0
Scheduler_Node *node;
ISR_lock_Context lock_context;
bool ok;
status = _Processor_mask_From_cpu_set_t( &affinity, cpusetsize, cpuset );
if ( !_Processor_mask_Is_at_most_partial_loss( status ) ) {
40024d38: 80 a2 20 01 cmp %o0, 1
40024d3c: 38 80 00 09 bgu,a 40024d60 <_Scheduler_Set_affinity+0x44> <== NEVER TAKEN
40024d40: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
BIT_AND2( CPU_MAXIMUM_PROCESSORS, a, b, c );
40024d44: 03 10 01 91 sethi %hi(0x40064400), %g1
40024d48: c4 00 63 00 ld [ %g1 + 0x300 ], %g2 ! 40064700 <_Processor_mask_The_one_and_only>
return BIT_SUBSET( CPU_MAXIMUM_PROCESSORS, big, small );
40024d4c: c2 07 bf fc ld [ %fp + -4 ], %g1
40024d50: 82 28 80 01 andn %g2, %g1, %g1
40024d54: 80 a0 00 01 cmp %g0, %g1
40024d58: b0 60 3f ff subx %g0, -1, %i0
);
#endif
_Scheduler_Release_critical( scheduler, &lock_context );
return ok;
}
40024d5c: b0 0e 20 01 and %i0, 1, %i0
40024d60: 81 c7 e0 08 ret
40024d64: 81 e8 00 00 restore
40009b3c <_Scheduler_default_Cancel_job>:
{
(void) scheduler;
(void) the_thread;
(void) priority_node;
(void) queue_context;
}
40009b3c: 81 c3 e0 08 retl
<== NOT EXECUTED
40009b40: 01 00 00 00 nop
40009b04 <_Scheduler_default_Map_priority>:
Priority_Control _Scheduler_default_Map_priority(
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
return SCHEDULER_PRIORITY_MAP( priority );
40009b04: 83 2a 60 01 sll %o1, 1, %g1
<== NOT EXECUTED
40009b08: 91 32 a0 1f srl %o2, 0x1f, %o0
<== NOT EXECUTED
}
40009b0c: 93 2a a0 01 sll %o2, 1, %o1
<== NOT EXECUTED
40009b10: 81 c3 e0 08 retl
40009b14: 90 12 00 01 or %o0, %g1, %o0
40009b2c <_Scheduler_default_Node_destroy>:
Scheduler_Node *node
)
{
(void) scheduler;
(void) node;
}
40009b2c: 81 c3 e0 08 retl
<== NOT EXECUTED
40009b30: 01 00 00 00 nop
4000a4f0 <_Scheduler_default_Node_initialize>:
const Scheduler_Control *scheduler,
Scheduler_Node *node,
Thread_Control *the_thread,
Priority_Control priority
)
{
4000a4f0: 84 10 00 0b mov %o3, %g2
<== NOT EXECUTED
4000a4f4: 86 10 00 0c mov %o4, %g3
<== NOT EXECUTED
Scheduler_Node *node,
Thread_Control *the_thread,
Priority_Control priority
)
{
node->owner = the_thread;
4000a4f8: d4 22 40 00 st %o2, [ %o1 ]
<== NOT EXECUTED
_Scheduler_Node_do_initialize( scheduler, node, the_thread, priority );
}
4000a4fc: 81 c3 e0 08 retl
<== NOT EXECUTED
4000a500: c4 3a 60 30 std %g2, [ %o1 + 0x30 ]
40009b34 <_Scheduler_default_Release_job>:
(void) scheduler;
(void) the_thread;
(void) priority_node;
(void) deadline;
(void) queue_context;
}
40009b34: 81 c3 e0 08 retl
<== NOT EXECUTED
40009b38: 01 00 00 00 nop
40009b44 <_Scheduler_default_Start_idle>:
void _Scheduler_default_Start_idle(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Per_CPU_Control *cpu
)
{
40009b44: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
const Scheduler_Control *scheduler;
ISR_lock_Context lock_context;
scheduler = _Thread_Scheduler_get_home( the_thread );
_Scheduler_Acquire_critical( scheduler, &lock_context );
( *scheduler->Operations.unblock )(
40009b48: 11 10 00 63 sethi %hi(0x40018c00), %o0
<== NOT EXECUTED
40009b4c: d4 06 60 38 ld [ %i1 + 0x38 ], %o2
40009b50: 90 12 21 c8 or %o0, 0x1c8, %o0
40009b54: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40009b58: 9f c0 40 00 call %g1
40009b5c: 92 10 00 19 mov %i1, %o1
(void) scheduler;
(void) cpu;
_Scheduler_Unblock( the_thread );
}
40009b60: 81 c7 e0 08 ret
40009b64: 81 e8 00 00 restore
40009b68 <_Scheduler_default_Tick>:
void _Scheduler_default_Tick(
const Scheduler_Control *scheduler,
Thread_Control *executing
)
{
40009b68: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
40009b6c: c2 0e 60 89 ldub [ %i1 + 0x89 ], %g1
<== NOT EXECUTED
40009b70: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40009b74: 02 80 00 24 be 40009c04 <_Scheduler_default_Tick+0x9c> <== ALWAYS TAKEN
40009b78: 01 00 00 00 nop
return;
if ( !_States_Is_ready( executing->current_state ) )
40009b7c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
40009b80: 80 a0 60 00 cmp %g1, 0
40009b84: 12 80 00 20 bne 40009c04 <_Scheduler_default_Tick+0x9c>
40009b88: 01 00 00 00 nop
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
40009b8c: c2 06 60 90 ld [ %i1 + 0x90 ], %g1
40009b90: 80 a0 60 01 cmp %g1, 1
40009b94: 0a 80 00 0e bcs 40009bcc <_Scheduler_default_Tick+0x64>
40009b98: 80 a0 60 02 cmp %g1, 2
40009b9c: 08 80 00 0e bleu 40009bd4 <_Scheduler_default_Tick+0x6c>
40009ba0: 80 a0 60 03 cmp %g1, 3
40009ba4: 12 80 00 18 bne 40009c04 <_Scheduler_default_Tick+0x9c> <== NEVER TAKEN
40009ba8: 01 00 00 00 nop
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
40009bac: c2 06 60 8c ld [ %i1 + 0x8c ], %g1
40009bb0: 82 00 7f ff add %g1, -1, %g1
40009bb4: 80 a0 60 00 cmp %g1, 0
40009bb8: 12 80 00 05 bne 40009bcc <_Scheduler_default_Tick+0x64>
40009bbc: c2 26 60 8c st %g1, [ %i1 + 0x8c ]
(*executing->budget_callout)( executing );
40009bc0: c2 06 60 94 ld [ %i1 + 0x94 ], %g1
40009bc4: 9f c0 40 00 call %g1
40009bc8: 90 10 00 19 mov %i1, %o0
break;
#endif
}
}
40009bcc: 81 c7 e0 08 ret
40009bd0: 81 e8 00 00 restore
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
40009bd4: c2 06 60 8c ld [ %i1 + 0x8c ], %g1
40009bd8: 82 00 7f ff add %g1, -1, %g1
40009bdc: 80 a0 60 00 cmp %g1, 0
40009be0: 14 bf ff fb bg 40009bcc <_Scheduler_default_Tick+0x64>
40009be4: c2 26 60 8c st %g1, [ %i1 + 0x8c ]
_Thread_Yield( executing );
40009be8: 40 00 07 fb call 4000bbd4 <_Thread_Yield>
40009bec: 90 10 00 19 mov %i1, %o0
rtems_configuration_get_ticks_per_timeslice();
40009bf0: 03 10 00 63 sethi %hi(0x40018c00), %g1
executing->cpu_time_budget =
40009bf4: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 40018d00 <Configuration+0x18>
40009bf8: c2 26 60 8c st %g1, [ %i1 + 0x8c ]
40009bfc: 81 c7 e0 08 ret
40009c00: 81 e8 00 00 restore
40009c04: 81 c7 e0 08 ret
40009c08: 81 e8 00 00 restore
40009b18 <_Scheduler_default_Unmap_priority>:
Priority_Control _Scheduler_default_Unmap_priority(
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
return SCHEDULER_PRIORITY_UNMAP( priority );
40009b18: 95 32 a0 01 srl %o2, 1, %o2
<== NOT EXECUTED
40009b1c: 83 2a 60 1f sll %o1, 0x1f, %g1
}
40009b20: 91 32 60 01 srl %o1, 1, %o0
40009b24: 81 c3 e0 08 retl
40009b28: 92 10 40 0a or %g1, %o2, %o1
40009c2c <_Scheduler_priority_Block>:
void _Scheduler_priority_Block(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40009c2c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Chain_Node *node,
Scheduler_priority_Ready_queue *ready_queue,
Priority_bit_map_Control *bit_map
)
{
Chain_Control *ready_chain = ready_queue->ready_chain;
40009c30: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
if ( _Chain_Has_only_one_node( ready_chain ) ) {
40009c34: c6 00 40 00 ld [ %g1 ], %g3
40009c38: c4 00 60 08 ld [ %g1 + 8 ], %g2
40009c3c: 80 a0 c0 02 cmp %g3, %g2
40009c40: 22 80 00 31 be,a 40009d04 <_Scheduler_priority_Block+0xd8>
40009c44: c6 06 a0 40 ld [ %i2 + 0x40 ], %g3
next = the_node->next;
40009c48: c4 06 40 00 ld [ %i1 ], %g2
previous = the_node->previous;
40009c4c: c2 06 60 04 ld [ %i1 + 4 ], %g1
next->previous = previous;
40009c50: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40009c54: c4 20 40 00 st %g2, [ %g1 ]
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
40009c58: b8 10 00 06 mov %g6, %i4
{
( *extract )( scheduler, the_thread, node );
/* TODO: flash critical section? */
if ( _Thread_Is_executing( the_thread ) || _Thread_Is_heir( the_thread ) ) {
40009c5c: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1
40009c60: 80 a6 40 01 cmp %i1, %g1
40009c64: 02 80 00 07 be 40009c80 <_Scheduler_priority_Block+0x54>
40009c68: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3
40009c6c: 80 a6 40 1b cmp %i1, %i3
40009c70: 22 80 00 05 be,a 40009c84 <_Scheduler_priority_Block+0x58> <== NEVER TAKEN
40009c74: f4 06 00 00 ld [ %i0 ], %i2
<== NOT EXECUTED
the_thread,
node,
_Scheduler_priority_Extract_body,
_Scheduler_priority_Schedule_body
);
}
40009c78: 81 c7 e0 08 ret
40009c7c: 81 e8 00 00 restore
40009c80: f4 06 00 00 ld [ %i0 ], %i2
unsigned int bit_number;
#if ( CPU_USE_GENERIC_BITFIELD_CODE == FALSE )
_CPU_Bitfield_Find_first_bit( value, bit_number );
#elif defined(__GNUC__)
bit_number = (unsigned int) __builtin_clz( value )
40009c84: 40 00 37 5c call 400179f4 <__clzsi2>
40009c88: d0 16 80 00 lduh [ %i2 ], %o0
40009c8c: ba 02 3f f0 add %o0, -16, %i5
{
unsigned int minor;
unsigned int major;
major = _Bitfield_Find_first_bit( bit_map->major_bit_map );
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
40009c90: 83 2f 60 01 sll %i5, 1, %g1
return (_Priority_Bits_index( major ) << 4) +
40009c94: bb 2f 60 04 sll %i5, 4, %i5
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
40009c98: 82 06 80 01 add %i2, %g1, %g1
bit_number = (unsigned int) __builtin_clz( value )
40009c9c: 40 00 37 56 call 400179f4 <__clzsi2>
40009ca0: d0 10 60 02 lduh [ %g1 + 2 ], %o0
Priority_bit_map_Control *bit_map,
Chain_Control *ready_queues
)
{
Priority_Control index = _Priority_bit_map_Get_highest( bit_map );
Chain_Node *first = _Chain_First( &ready_queues[ index ] );
40009ca4: 90 02 00 1d add %o0, %i5, %o0
40009ca8: 90 02 3f f0 add %o0, -16, %o0
return _Chain_Immutable_head( the_chain )->next;
40009cac: bb 2a 20 01 sll %o0, 1, %i5
40009cb0: 90 07 40 08 add %i5, %o0, %o0
40009cb4: 91 2a 20 02 sll %o0, 2, %o0
40009cb8: b4 06 80 08 add %i2, %o0, %i2
40009cbc: fa 06 a0 24 ld [ %i2 + 0x24 ], %i5
bool force_dispatch
)
{
Thread_Control *heir = _Thread_Heir;
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40009cc0: 80 a7 40 1b cmp %i5, %i3
40009cc4: 02 80 00 0e be 40009cfc <_Scheduler_priority_Block+0xd0>
40009cc8: 01 00 00 00 nop
*time = _Timecounter_Sbinuptime();
40009ccc: 7f ff fa f1 call 40008890 <_Timecounter_Sbinuptime>
40009cd0: e0 1f 20 28 ldd [ %i4 + 0x28 ], %l0
40009cd4: d0 3f 20 28 std %o0, [ %i4 + 0x28 ]
const Timestamp_Control *_start,
const Timestamp_Control *_end,
Timestamp_Control *_result
)
{
*_result = *_end - *_start;
40009cd8: b2 a2 40 11 subcc %o1, %l1, %i1
*_time += *_add;
40009cdc: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4
*_result = *_end - *_start;
40009ce0: b0 62 00 10 subx %o0, %l0, %i0
*_time += *_add;
40009ce4: 86 83 40 19 addcc %o5, %i1, %g3
40009ce8: 84 43 00 18 addx %o4, %i0, %g2
40009cec: c4 3e e0 98 std %g2, [ %i3 + 0x98 ]
heir->Scheduler.state = THREAD_SCHEDULER_BLOCKED;
new_heir->Scheduler.state = THREAD_SCHEDULER_SCHEDULED;
#endif
_Thread_Update_CPU_time_used( heir, _Thread_Get_CPU( heir ) );
_Thread_Heir = new_heir;
_Thread_Dispatch_necessary = true;
40009cf0: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
40009cf4: fa 21 a0 24 st %i5, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
40009cf8: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
40009cfc: 81 c7 e0 08 ret
40009d00: 81 e8 00 00 restore
*bit_map_info->minor &= bit_map_info->block_minor;
40009d04: c4 10 c0 00 lduh [ %g3 ], %g2
40009d08: f8 16 a0 4a lduh [ %i2 + 0x4a ], %i4
40009d0c: c8 06 00 00 ld [ %i0 ], %g4
return &the_chain->Tail.Node;
40009d10: ba 00 60 04 add %g1, 4, %i5
head->previous = NULL;
40009d14: c0 20 60 04 clr [ %g1 + 4 ]
40009d18: 84 08 80 1c and %g2, %i4, %g2
head->next = tail;
40009d1c: fa 20 40 00 st %i5, [ %g1 ]
if ( *bit_map_info->minor == 0 )
40009d20: 80 a0 a0 00 cmp %g2, 0
tail->previous = head;
40009d24: c2 20 60 08 st %g1, [ %g1 + 8 ]
40009d28: 12 bf ff cc bne 40009c58 <_Scheduler_priority_Block+0x2c>
40009d2c: c4 30 c0 00 sth %g2, [ %g3 ]
bit_map->major_bit_map &= bit_map_info->block_major;
40009d30: c2 11 00 00 lduh [ %g4 ], %g1
40009d34: c4 16 a0 48 lduh [ %i2 + 0x48 ], %g2
40009d38: 82 08 40 02 and %g1, %g2, %g1
40009d3c: 10 bf ff c7 b 40009c58 <_Scheduler_priority_Block+0x2c>
40009d40: c2 31 00 00 sth %g1, [ %g4 ]
40009f2c <_Scheduler_priority_Initialize>:
#endif
#include <rtems/score/schedulerpriorityimpl.h>
void _Scheduler_priority_Initialize( const Scheduler_Control *scheduler )
{
40009f2c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
40009f30: c2 06 00 00 ld [ %i0 ], %g1
<== NOT EXECUTED
memset( bit_map, 0, sizeof( *bit_map ) );
40009f34: 90 10 00 01 mov %g1, %o0
<== NOT EXECUTED
40009f38: 94 10 20 22 mov 0x22, %o2
40009f3c: 40 00 14 b1 call 4000f200 <memset>
40009f40: 92 10 20 00 clr %o1
40009f44: c4 06 20 44 ld [ %i0 + 0x44 ], %g2
Scheduler_priority_Context *context =
_Scheduler_priority_Get_context( scheduler );
_Priority_bit_map_Initialize( &context->Bit_map );
_Scheduler_priority_Ready_queue_initialize(
40009f48: 90 02 20 24 add %o0, 0x24, %o0
40009f4c: 83 28 a0 01 sll %g2, 1, %g1
40009f50: 82 00 40 02 add %g1, %g2, %g1
40009f54: 83 28 60 02 sll %g1, 2, %g1
40009f58: 82 02 00 01 add %o0, %g1, %g1
head->next = tail;
40009f5c: 84 02 20 04 add %o0, 4, %g2
head->previous = NULL;
40009f60: c0 22 20 04 clr [ %o0 + 4 ]
for ( index = 0 ; index <= (size_t) maximum_priority ; ++index ) {
40009f64: 80 a2 00 01 cmp %o0, %g1
head->next = tail;
40009f68: c4 22 00 00 st %g2, [ %o0 ]
tail->previous = head;
40009f6c: d0 22 20 08 st %o0, [ %o0 + 8 ]
40009f70: 12 bf ff fb bne 40009f5c <_Scheduler_priority_Initialize+0x30>
40009f74: 90 02 20 0c add %o0, 0xc, %o0
&context->Ready[ 0 ],
scheduler->maximum_priority
);
}
40009f78: 81 c7 e0 08 ret
40009f7c: 81 e8 00 00 restore
40009f80 <_Scheduler_priority_Node_initialize>:
const Scheduler_Control *scheduler,
Scheduler_Node *node,
Thread_Control *the_thread,
Priority_Control priority
)
{
40009f80: da 02 00 00 ld [ %o0 ], %o5
<== NOT EXECUTED
context = _Scheduler_priority_Get_context( scheduler );
the_node = _Scheduler_priority_Node_downcast( node );
_Scheduler_priority_Ready_queue_update(
&the_node->Ready_queue,
SCHEDULER_PRIORITY_UNMAP( priority ),
40009f84: 85 2a e0 1f sll %o3, 0x1f, %g2
_Scheduler_priority_Ready_queue_update(
40009f88: 90 03 60 24 add %o5, 0x24, %o0
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
40009f8c: 07 00 00 20 sethi %hi(0x8000), %g3
SCHEDULER_PRIORITY_UNMAP( priority ),
40009f90: 83 33 20 01 srl %o4, 1, %g1
Scheduler_Node *node,
Thread_Control *the_thread,
Priority_Control priority
)
{
node->owner = the_thread;
40009f94: d4 22 40 00 st %o2, [ %o1 ]
40009f98: 82 10 80 01 or %g2, %g1, %g1
return the_priority / 16;
40009f9c: 85 30 60 04 srl %g1, 4, %g2
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
40009fa0: 95 30 c0 02 srl %g3, %g2, %o2
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
40009fa4: 84 00 a0 01 inc %g2
40009fa8: 85 28 a0 01 sll %g2, 1, %g2
40009fac: 84 03 40 02 add %o5, %g2, %g2
return the_priority % 16;
40009fb0: 9a 08 60 0f and %g1, 0xf, %o5
ready_queue->ready_chain = &ready_queues[ new_priority ];
40009fb4: 89 28 60 01 sll %g1, 1, %g4
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
40009fb8: 87 30 c0 0d srl %g3, %o5, %g3
40009fbc: 88 01 00 01 add %g4, %g1, %g4
bit_map_info->block_minor = (Priority_bit_map_Word) ~mask;
40009fc0: 9a 38 00 03 xnor %g0, %g3, %o5
40009fc4: 89 29 20 02 sll %g4, 2, %g4
node->Priority.value = priority;
40009fc8: d6 22 60 30 st %o3, [ %o1 + 0x30 ]
40009fcc: 88 02 00 04 add %o0, %g4, %g4
40009fd0: d8 22 60 34 st %o4, [ %o1 + 0x34 ]
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
40009fd4: 90 38 00 0a xnor %g0, %o2, %o0
ready_queue->current_priority = new_priority;
40009fd8: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
ready_queue->ready_chain = &ready_queues[ new_priority ];
40009fdc: c8 22 60 3c st %g4, [ %o1 + 0x3c ]
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
40009fe0: c4 22 60 40 st %g2, [ %o1 + 0x40 ]
bit_map_info->ready_major = mask;
40009fe4: d4 32 60 44 sth %o2, [ %o1 + 0x44 ]
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
40009fe8: d0 32 60 48 sth %o0, [ %o1 + 0x48 ]
bit_map_info->ready_minor = mask;
40009fec: c6 32 60 46 sth %g3, [ %o1 + 0x46 ]
&context->Bit_map,
&context->Ready[ 0 ]
);
}
40009ff0: 81 c3 e0 08 retl
40009ff4: da 32 60 4a sth %o5, [ %o1 + 0x4a ]
40009ff8 <_Scheduler_priority_Schedule>:
void _Scheduler_priority_Schedule(
const Scheduler_Control *scheduler,
Thread_Control *the_thread
)
{
40009ff8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
40009ffc: f8 06 00 00 ld [ %i0 ], %i4
<== NOT EXECUTED
bit_number = (unsigned int) __builtin_clz( value )
4000a000: 40 00 36 7d call 400179f4 <__clzsi2>
<== NOT EXECUTED
4000a004: d0 17 00 00 lduh [ %i4 ], %o0
<== NOT EXECUTED
4000a008: ba 02 3f f0 add %o0, -16, %i5
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
4000a00c: 83 2f 60 01 sll %i5, 1, %g1
return (_Priority_Bits_index( major ) << 4) +
4000a010: bb 2f 60 04 sll %i5, 4, %i5
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
4000a014: 82 07 00 01 add %i4, %g1, %g1
bit_number = (unsigned int) __builtin_clz( value )
4000a018: 40 00 36 77 call 400179f4 <__clzsi2>
4000a01c: d0 10 60 02 lduh [ %g1 + 2 ], %o0
Chain_Node *first = _Chain_First( &ready_queues[ index ] );
4000a020: 90 02 00 1d add %o0, %i5, %o0
4000a024: 90 02 3f f0 add %o0, -16, %o0
return _Chain_Immutable_head( the_chain )->next;
4000a028: bb 2a 20 01 sll %o0, 1, %i5
Thread_Control *heir = _Thread_Heir;
4000a02c: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3
4000a030: 90 07 40 08 add %i5, %o0, %o0
4000a034: 91 2a 20 02 sll %o0, 2, %o0
4000a038: b8 07 00 08 add %i4, %o0, %i4
4000a03c: fa 07 20 24 ld [ %i4 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4000a040: 80 a7 40 1b cmp %i5, %i3
4000a044: 02 80 00 06 be 4000a05c <_Scheduler_priority_Schedule+0x64>
4000a048: b4 10 00 06 mov %g6, %i2
4000a04c: c2 0e e0 89 ldub [ %i3 + 0x89 ], %g1
4000a050: 80 a0 60 00 cmp %g1, 0
4000a054: 12 80 00 04 bne 4000a064 <_Scheduler_priority_Schedule+0x6c> <== ALWAYS TAKEN
4000a058: 01 00 00 00 nop
_Scheduler_priority_Schedule_body( scheduler, the_thread, false );
}
4000a05c: 81 c7 e0 08 ret
4000a060: 81 e8 00 00 restore
4000a064: 7f ff fa 0b call 40008890 <_Timecounter_Sbinuptime>
4000a068: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0
4000a06c: d0 3e a0 28 std %o0, [ %i2 + 0x28 ]
*_result = *_end - *_start;
4000a070: b2 a2 40 11 subcc %o1, %l1, %i1
*_time += *_add;
4000a074: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4
*_result = *_end - *_start;
4000a078: b0 62 00 10 subx %o0, %l0, %i0
*_time += *_add;
4000a07c: 86 83 40 19 addcc %o5, %i1, %g3
4000a080: 84 43 00 18 addx %o4, %i0, %g2
4000a084: c4 3e e0 98 std %g2, [ %i3 + 0x98 ]
_Thread_Dispatch_necessary = true;
4000a088: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
4000a08c: fa 21 a0 24 st %i5, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
4000a090: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
4000a094: 81 c7 e0 08 ret
4000a098: 81 e8 00 00 restore
4000a09c <_Scheduler_priority_Unblock>:
void _Scheduler_priority_Unblock (
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
4000a09c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
4000a0a0: f6 06 a0 34 ld [ %i2 + 0x34 ], %i3
<== NOT EXECUTED
context = _Scheduler_priority_Get_context( scheduler );
the_node = _Scheduler_priority_Node_downcast( node );
priority = (unsigned int ) _Scheduler_Node_get_priority( &the_node->Base );
unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority );
if ( unmapped_priority != the_node->Ready_queue.current_priority ) {
4000a0a4: c2 06 a0 38 ld [ %i2 + 0x38 ], %g1
<== NOT EXECUTED
unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority );
4000a0a8: 87 36 e0 01 srl %i3, 1, %g3
<== NOT EXECUTED
if ( unmapped_priority != the_node->Ready_queue.current_priority ) {
4000a0ac: 80 a0 40 03 cmp %g1, %g3
4000a0b0: 02 80 00 4a be 4000a1d8 <_Scheduler_priority_Unblock+0x13c> <== ALWAYS TAKEN
4000a0b4: fa 06 00 00 ld [ %i0 ], %i5
ready_queue->ready_chain = &ready_queues[ new_priority ];
4000a0b8: b9 28 e0 01 sll %g3, 1, %i4
4000a0bc: b8 07 00 03 add %i4, %g3, %i4
4000a0c0: b9 2f 20 02 sll %i4, 2, %i4
_Scheduler_priority_Ready_queue_update(
4000a0c4: 84 07 60 24 add %i5, 0x24, %g2
4000a0c8: 84 00 80 1c add %g2, %i4, %g2
return the_priority % 16;
4000a0cc: b8 08 e0 0f and %g3, 0xf, %i4
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
4000a0d0: 09 00 00 20 sethi %hi(0x8000), %g4
return the_priority / 16;
4000a0d4: 83 36 e0 05 srl %i3, 5, %g1
ready_queue->current_priority = new_priority;
4000a0d8: c6 26 a0 38 st %g3, [ %i2 + 0x38 ]
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
4000a0dc: b1 31 00 01 srl %g4, %g1, %i0
4000a0e0: 87 31 00 1c srl %g4, %i4, %g3
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
4000a0e4: 82 00 60 01 inc %g1
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
4000a0e8: 9e 38 00 18 xnor %g0, %i0, %o7
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
4000a0ec: 83 28 60 01 sll %g1, 1, %g1
bit_map_info->block_minor = (Priority_bit_map_Word) ~mask;
4000a0f0: b8 38 00 03 xnor %g0, %g3, %i4
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
4000a0f4: 82 07 40 01 add %i5, %g1, %g1
ready_queue->ready_chain = &ready_queues[ new_priority ];
4000a0f8: c4 26 a0 3c st %g2, [ %i2 + 0x3c ]
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
4000a0fc: 88 10 00 03 mov %g3, %g4
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
4000a100: c2 26 a0 40 st %g1, [ %i2 + 0x40 ]
bit_map_info->ready_major = mask;
4000a104: f0 36 a0 44 sth %i0, [ %i2 + 0x44 ]
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
4000a108: de 36 a0 48 sth %o7, [ %i2 + 0x48 ]
bit_map_info->ready_minor = mask;
4000a10c: c6 36 a0 46 sth %g3, [ %i2 + 0x46 ]
bit_map_info->block_minor = (Priority_bit_map_Word) ~mask;
4000a110: f8 36 a0 4a sth %i4, [ %i2 + 0x4a ]
return &the_chain->Tail.Node;
4000a114: b8 00 a0 04 add %g2, 4, %i4
old_last = tail->previous;
4000a118: c6 00 a0 08 ld [ %g2 + 8 ], %g3
the_node->next = tail;
4000a11c: f8 26 40 00 st %i4, [ %i1 ]
tail->previous = the_node;
4000a120: f2 20 a0 08 st %i1, [ %g2 + 8 ]
old_last->next = the_node;
4000a124: f2 20 c0 00 st %i1, [ %g3 ]
*bit_map_info->minor |= bit_map_info->ready_minor;
4000a128: c4 10 40 00 lduh [ %g1 ], %g2
the_node->previous = old_last;
4000a12c: c6 26 60 04 st %g3, [ %i1 + 4 ]
4000a130: 84 10 80 04 or %g2, %g4, %g2
4000a134: c4 30 40 00 sth %g2, [ %g1 ]
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
4000a138: f8 01 a0 24 ld [ %g6 + 0x24 ], %i4
bit_map->major_bit_map |= bit_map_info->ready_major;
4000a13c: c4 16 a0 44 lduh [ %i2 + 0x44 ], %g2
4000a140: c2 17 40 00 lduh [ %i5 ], %g1
4000a144: 82 10 40 02 or %g1, %g2, %g1
4000a148: c4 07 20 38 ld [ %i4 + 0x38 ], %g2
4000a14c: c2 37 40 00 sth %g1, [ %i5 ]
4000a150: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1
4000a154: 80 a0 60 00 cmp %g1, 0
4000a158: 18 80 00 09 bgu 4000a17c <_Scheduler_priority_Unblock+0xe0> <== NEVER TAKEN
4000a15c: b0 10 00 06 mov %g6, %i0
4000a160: 22 80 00 04 be,a 4000a170 <_Scheduler_priority_Unblock+0xd4> <== ALWAYS TAKEN
4000a164: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1
_Scheduler_Update_heir( the_thread, priority == PRIORITY_PSEUDO_ISR );
}
}
4000a168: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a16c: 81 e8 00 00 restore
<== NOT EXECUTED
if ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
4000a170: 80 a0 40 1b cmp %g1, %i3
4000a174: 08 80 00 17 bleu 4000a1d0 <_Scheduler_priority_Unblock+0x134>
4000a178: 01 00 00 00 nop
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4000a17c: 80 a7 00 19 cmp %i4, %i1
4000a180: 02 bf ff fa be 4000a168 <_Scheduler_priority_Unblock+0xcc> <== NEVER TAKEN
4000a184: 80 a6 e0 00 cmp %i3, 0
4000a188: 02 80 00 06 be 4000a1a0 <_Scheduler_priority_Unblock+0x104>
4000a18c: 01 00 00 00 nop
4000a190: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1
4000a194: 80 a0 60 00 cmp %g1, 0
4000a198: 02 80 00 0e be 4000a1d0 <_Scheduler_priority_Unblock+0x134>
4000a19c: 01 00 00 00 nop
4000a1a0: 7f ff f9 bc call 40008890 <_Timecounter_Sbinuptime>
4000a1a4: e0 1e 20 28 ldd [ %i0 + 0x28 ], %l0
4000a1a8: d0 3e 20 28 std %o0, [ %i0 + 0x28 ]
*_result = *_end - *_start;
4000a1ac: b6 a2 40 11 subcc %o1, %l1, %i3
*_time += *_add;
4000a1b0: d8 1f 20 98 ldd [ %i4 + 0x98 ], %o4
*_result = *_end - *_start;
4000a1b4: b4 62 00 10 subx %o0, %l0, %i2
*_time += *_add;
4000a1b8: 86 83 40 1b addcc %o5, %i3, %g3
4000a1bc: 84 43 00 1a addx %o4, %i2, %g2
4000a1c0: c4 3f 20 98 std %g2, [ %i4 + 0x98 ]
_Thread_Dispatch_necessary = true;
4000a1c4: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
4000a1c8: f2 21 a0 24 st %i1, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
4000a1cc: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
}
4000a1d0: 81 c7 e0 08 ret
4000a1d4: 81 e8 00 00 restore
4000a1d8: c4 06 a0 3c ld [ %i2 + 0x3c ], %g2
4000a1dc: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1
4000a1e0: 10 bf ff cd b 4000a114 <_Scheduler_priority_Unblock+0x78>
4000a1e4: c8 16 a0 46 lduh [ %i2 + 0x46 ], %g4
40009d44 <_Scheduler_priority_Update_priority>:
void _Scheduler_priority_Update_priority(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40009d44: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Scheduler_priority_Context *context;
Scheduler_priority_Node *the_node;
unsigned int new_priority;
unsigned int unmapped_priority;
if ( !_Thread_Is_ready( the_thread ) ) {
40009d48: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
<== NOT EXECUTED
40009d4c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40009d50: 12 80 00 5c bne 40009ec0 <_Scheduler_priority_Update_priority+0x17c>
<== NOT EXECUTED
40009d54: 01 00 00 00 nop
/* Nothing to do */
return;
}
the_node = _Scheduler_priority_Node_downcast( node );
new_priority = (unsigned int)
40009d58: f6 06 a0 34 ld [ %i2 + 0x34 ], %i3
_Scheduler_Node_get_priority( &the_node->Base );
unmapped_priority = SCHEDULER_PRIORITY_UNMAP( new_priority );
if ( unmapped_priority == the_node->Ready_queue.current_priority ) {
40009d5c: c2 06 a0 38 ld [ %i2 + 0x38 ], %g1
unmapped_priority = SCHEDULER_PRIORITY_UNMAP( new_priority );
40009d60: 87 36 e0 01 srl %i3, 1, %g3
if ( unmapped_priority == the_node->Ready_queue.current_priority ) {
40009d64: 80 a0 40 03 cmp %g1, %g3
40009d68: 02 80 00 56 be 40009ec0 <_Scheduler_priority_Update_priority+0x17c>
40009d6c: 01 00 00 00 nop
Chain_Control *ready_chain = ready_queue->ready_chain;
40009d70: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
if ( _Chain_Has_only_one_node( ready_chain ) ) {
40009d74: c8 00 40 00 ld [ %g1 ], %g4
40009d78: c4 00 60 08 ld [ %g1 + 8 ], %g2
40009d7c: 80 a1 00 02 cmp %g4, %g2
40009d80: 02 80 00 52 be 40009ec8 <_Scheduler_priority_Update_priority+0x184>
40009d84: fa 06 00 00 ld [ %i0 ], %i5
next = the_node->next;
40009d88: c4 06 40 00 ld [ %i1 ], %g2
previous = the_node->previous;
40009d8c: c2 06 60 04 ld [ %i1 + 4 ], %g1
next->previous = previous;
40009d90: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40009d94: c4 20 40 00 st %g2, [ %g1 ]
return the_priority / 16;
40009d98: 85 36 e0 05 srl %i3, 5, %g2
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
40009d9c: 03 00 00 20 sethi %hi(0x8000), %g1
Priority_bit_map_Control *bit_map,
Chain_Control *ready_queues
)
{
ready_queue->current_priority = new_priority;
ready_queue->ready_chain = &ready_queues[ new_priority ];
40009da0: 89 28 e0 01 sll %g3, 1, %g4
40009da4: 9f 30 40 02 srl %g1, %g2, %o7
40009da8: 88 01 00 03 add %g4, %g3, %g4
return the_priority % 16;
40009dac: 96 08 e0 0f and %g3, 0xf, %o3
&the_thread->Object.Node,
&the_node->Ready_queue,
&context->Bit_map
);
_Scheduler_priority_Ready_queue_update(
40009db0: 9a 07 60 24 add %i5, 0x24, %o5
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
40009db4: 83 30 40 0b srl %g1, %o3, %g1
Priority_bit_map_Word mask;
major = _Priority_Major( new_priority );
minor = _Priority_Minor( new_priority );
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
40009db8: b8 00 a0 01 add %g2, 1, %i4
40009dbc: 89 29 20 02 sll %g4, 2, %g4
40009dc0: b9 2f 20 01 sll %i4, 1, %i4
40009dc4: b0 03 40 04 add %o5, %g4, %i0
40009dc8: b8 07 40 1c add %i5, %i4, %i4
mask = _Priority_Mask( major );
bit_map_info->ready_major = mask;
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
40009dcc: 98 38 00 0f xnor %g0, %o7, %o4
ready_queue->current_priority = new_priority;
40009dd0: c6 26 a0 38 st %g3, [ %i2 + 0x38 ]
mask = _Priority_Mask( minor );
bit_map_info->ready_minor = mask;
bit_map_info->block_minor = (Priority_bit_map_Word) ~mask;
40009dd4: 86 38 00 01 xnor %g0, %g1, %g3
ready_queue->ready_chain = &ready_queues[ new_priority ];
40009dd8: f0 26 a0 3c st %i0, [ %i2 + 0x3c ]
unmapped_priority,
&context->Bit_map,
&context->Ready[ 0 ]
);
if ( SCHEDULER_PRIORITY_IS_APPEND( new_priority ) ) {
40009ddc: 80 8e e0 01 btst 1, %i3
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
40009de0: f8 26 a0 40 st %i4, [ %i2 + 0x40 ]
bit_map_info->ready_major = mask;
40009de4: de 36 a0 44 sth %o7, [ %i2 + 0x44 ]
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
40009de8: d8 36 a0 48 sth %o4, [ %i2 + 0x48 ]
bit_map_info->ready_minor = mask;
40009dec: c2 36 a0 46 sth %g1, [ %i2 + 0x46 ]
40009df0: 02 80 00 46 be 40009f08 <_Scheduler_priority_Update_priority+0x1c4>
40009df4: c6 36 a0 4a sth %g3, [ %i2 + 0x4a ]
old_last = tail->previous;
40009df8: c6 06 20 08 ld [ %i0 + 8 ], %g3
return &the_chain->Tail.Node;
40009dfc: 88 06 20 04 add %i0, 4, %g4
the_node->next = tail;
40009e00: c8 26 40 00 st %g4, [ %i1 ]
40009e04: 85 28 a0 01 sll %g2, 1, %g2
tail->previous = the_node;
40009e08: f2 26 20 08 st %i1, [ %i0 + 8 ]
40009e0c: 84 07 40 02 add %i5, %g2, %g2
old_last->next = the_node;
40009e10: f2 20 c0 00 st %i1, [ %g3 ]
*bit_map_info->minor |= bit_map_info->ready_minor;
40009e14: c8 10 a0 02 lduh [ %g2 + 2 ], %g4
the_node->previous = old_last;
40009e18: c6 26 60 04 st %g3, [ %i1 + 4 ]
40009e1c: 82 10 40 04 or %g1, %g4, %g1
40009e20: c2 30 a0 02 sth %g1, [ %g2 + 2 ]
bit_map->major_bit_map |= bit_map_info->ready_major;
40009e24: c4 16 a0 44 lduh [ %i2 + 0x44 ], %g2
40009e28: c2 17 40 00 lduh [ %i5 ], %g1
40009e2c: 82 10 40 02 or %g1, %g2, %g1
40009e30: c2 37 40 00 sth %g1, [ %i5 ]
bit_number = (unsigned int) __builtin_clz( value )
40009e34: 40 00 36 f0 call 400179f4 <__clzsi2>
40009e38: d0 17 40 00 lduh [ %i5 ], %o0
40009e3c: b8 02 3f f0 add %o0, -16, %i4
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
40009e40: 83 2f 20 01 sll %i4, 1, %g1
return (_Priority_Bits_index( major ) << 4) +
40009e44: b9 2f 20 04 sll %i4, 4, %i4
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
40009e48: 82 07 40 01 add %i5, %g1, %g1
bit_number = (unsigned int) __builtin_clz( value )
40009e4c: 40 00 36 ea call 400179f4 <__clzsi2>
40009e50: d0 10 60 02 lduh [ %g1 + 2 ], %o0
Chain_Node *first = _Chain_First( &ready_queues[ index ] );
40009e54: 90 02 00 1c add %o0, %i4, %o0
Thread_Control *heir = _Thread_Heir;
40009e58: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3
40009e5c: 90 02 3f f0 add %o0, -16, %o0
return _Chain_Immutable_head( the_chain )->next;
40009e60: b9 2a 20 01 sll %o0, 1, %i4
40009e64: 90 07 00 08 add %i4, %o0, %o0
40009e68: 91 2a 20 02 sll %o0, 2, %o0
40009e6c: ba 07 40 08 add %i5, %o0, %i5
40009e70: fa 07 60 24 ld [ %i5 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40009e74: 80 a7 40 1b cmp %i5, %i3
40009e78: 02 80 00 12 be 40009ec0 <_Scheduler_priority_Update_priority+0x17c>
40009e7c: b4 10 00 06 mov %g6, %i2
40009e80: c2 0e e0 89 ldub [ %i3 + 0x89 ], %g1
40009e84: 80 a0 60 00 cmp %g1, 0
40009e88: 02 80 00 0e be 40009ec0 <_Scheduler_priority_Update_priority+0x17c>
40009e8c: 01 00 00 00 nop
40009e90: 7f ff fa 80 call 40008890 <_Timecounter_Sbinuptime>
40009e94: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0
40009e98: d0 3e a0 28 std %o0, [ %i2 + 0x28 ]
*_result = *_end - *_start;
40009e9c: b2 a2 40 11 subcc %o1, %l1, %i1
*_time += *_add;
40009ea0: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4
*_result = *_end - *_start;
40009ea4: b0 62 00 10 subx %o0, %l0, %i0
*_time += *_add;
40009ea8: 86 83 40 19 addcc %o5, %i1, %g3
40009eac: 84 43 00 18 addx %o4, %i0, %g2
40009eb0: c4 3e e0 98 std %g2, [ %i3 + 0x98 ]
_Thread_Dispatch_necessary = true;
40009eb4: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
40009eb8: fa 21 a0 24 st %i5, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
40009ebc: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
&context->Bit_map
);
}
_Scheduler_priority_Schedule_body( scheduler, the_thread, false );
}
40009ec0: 81 c7 e0 08 ret
40009ec4: 81 e8 00 00 restore
*bit_map_info->minor &= bit_map_info->block_minor;
40009ec8: c8 06 a0 40 ld [ %i2 + 0x40 ], %g4
40009ecc: c4 11 00 00 lduh [ %g4 ], %g2
40009ed0: f0 16 a0 4a lduh [ %i2 + 0x4a ], %i0
return &the_chain->Tail.Node;
40009ed4: b8 00 60 04 add %g1, 4, %i4
head->previous = NULL;
40009ed8: c0 20 60 04 clr [ %g1 + 4 ]
40009edc: 84 08 80 18 and %g2, %i0, %g2
head->next = tail;
40009ee0: f8 20 40 00 st %i4, [ %g1 ]
if ( *bit_map_info->minor == 0 )
40009ee4: 80 a0 a0 00 cmp %g2, 0
tail->previous = head;
40009ee8: c2 20 60 08 st %g1, [ %g1 + 8 ]
40009eec: 12 bf ff ab bne 40009d98 <_Scheduler_priority_Update_priority+0x54>
40009ef0: c4 31 00 00 sth %g2, [ %g4 ]
bit_map->major_bit_map &= bit_map_info->block_major;
40009ef4: c2 17 40 00 lduh [ %i5 ], %g1
40009ef8: c4 16 a0 48 lduh [ %i2 + 0x48 ], %g2
40009efc: 82 08 40 02 and %g1, %g2, %g1
40009f00: 10 bf ff a6 b 40009d98 <_Scheduler_priority_Update_priority+0x54>
40009f04: c2 37 40 00 sth %g1, [ %i5 ]
the_node->previous = after_node;
40009f08: f0 26 60 04 st %i0, [ %i1 + 4 ]
40009f0c: 85 28 a0 01 sll %g2, 1, %g2
before_node = after_node->next;
40009f10: c6 03 40 04 ld [ %o5 + %g4 ], %g3
after_node->next = the_node;
40009f14: f2 23 40 04 st %i1, [ %o5 + %g4 ]
40009f18: 84 07 40 02 add %i5, %g2, %g2
the_node->next = before_node;
40009f1c: c6 26 40 00 st %g3, [ %i1 ]
*bit_map_info->minor |= bit_map_info->ready_minor;
40009f20: c8 10 a0 02 lduh [ %g2 + 2 ], %g4
before_node->previous = the_node;
40009f24: 10 bf ff be b 40009e1c <_Scheduler_priority_Update_priority+0xd8>
40009f28: f2 20 e0 04 st %i1, [ %g3 + 4 ]
4000a1e8 <_Scheduler_priority_Yield>:
void _Scheduler_priority_Yield(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
4000a1e8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Scheduler_priority_Node *the_node;
Chain_Control *ready_chain;
the_node = _Scheduler_priority_Node_downcast( node );
ready_chain = the_node->Ready_queue.ready_chain;
4000a1ec: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
<== NOT EXECUTED
if ( !_Chain_Has_only_one_node( ready_chain ) ) {
4000a1f0: c6 00 60 08 ld [ %g1 + 8 ], %g3
<== NOT EXECUTED
4000a1f4: c4 00 40 00 ld [ %g1 ], %g2
<== NOT EXECUTED
4000a1f8: 80 a0 c0 02 cmp %g3, %g2
<== NOT EXECUTED
4000a1fc: 02 80 00 0b be 4000a228 <_Scheduler_priority_Yield+0x40>
<== NOT EXECUTED
4000a200: 88 00 60 04 add %g1, 4, %g4
previous = the_node->previous;
4000a204: c4 06 60 04 ld [ %i1 + 4 ], %g2
next = the_node->next;
4000a208: c6 06 40 00 ld [ %i1 ], %g3
next->previous = previous;
4000a20c: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
4000a210: c6 20 80 00 st %g3, [ %g2 ]
old_last = tail->previous;
4000a214: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
4000a218: c8 26 40 00 st %g4, [ %i1 ]
tail->previous = the_node;
4000a21c: f2 20 60 08 st %i1, [ %g1 + 8 ]
old_last->next = the_node;
4000a220: f2 20 80 00 st %i1, [ %g2 ]
the_node->previous = old_last;
4000a224: c4 26 60 04 st %g2, [ %i1 + 4 ]
4000a228: f8 06 00 00 ld [ %i0 ], %i4
bit_number = (unsigned int) __builtin_clz( value )
4000a22c: 40 00 35 f2 call 400179f4 <__clzsi2>
4000a230: d0 17 00 00 lduh [ %i4 ], %o0
4000a234: ba 02 3f f0 add %o0, -16, %i5
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
4000a238: 83 2f 60 01 sll %i5, 1, %g1
return (_Priority_Bits_index( major ) << 4) +
4000a23c: bb 2f 60 04 sll %i5, 4, %i5
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
4000a240: 82 07 00 01 add %i4, %g1, %g1
bit_number = (unsigned int) __builtin_clz( value )
4000a244: 40 00 35 ec call 400179f4 <__clzsi2>
4000a248: d0 10 60 02 lduh [ %g1 + 2 ], %o0
Chain_Node *first = _Chain_First( &ready_queues[ index ] );
4000a24c: 90 02 00 1d add %o0, %i5, %o0
4000a250: 90 02 3f f0 add %o0, -16, %o0
return _Chain_Immutable_head( the_chain )->next;
4000a254: bb 2a 20 01 sll %o0, 1, %i5
Thread_Control *heir = _Thread_Heir;
4000a258: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3
4000a25c: 90 07 40 08 add %i5, %o0, %o0
4000a260: 91 2a 20 02 sll %o0, 2, %o0
4000a264: b8 07 00 08 add %i4, %o0, %i4
4000a268: fa 07 20 24 ld [ %i4 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4000a26c: 80 a7 40 1b cmp %i5, %i3
4000a270: 02 80 00 0e be 4000a2a8 <_Scheduler_priority_Yield+0xc0>
4000a274: b4 10 00 06 mov %g6, %i2
4000a278: 7f ff f9 86 call 40008890 <_Timecounter_Sbinuptime>
4000a27c: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0
4000a280: d0 3e a0 28 std %o0, [ %i2 + 0x28 ]
*_result = *_end - *_start;
4000a284: b2 a2 40 11 subcc %o1, %l1, %i1
*_time += *_add;
4000a288: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4
*_result = *_end - *_start;
4000a28c: b0 62 00 10 subx %o0, %l0, %i0
*_time += *_add;
4000a290: 86 83 40 19 addcc %o5, %i1, %g3
4000a294: 84 43 00 18 addx %o4, %i0, %g2
4000a298: c4 3e e0 98 std %g2, [ %i3 + 0x98 ]
_Thread_Dispatch_necessary = true;
4000a29c: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
4000a2a0: fa 21 a0 24 st %i5, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
4000a2a4: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
_Chain_Extract_unprotected( &the_thread->Object.Node );
_Chain_Append_unprotected( ready_chain, &the_thread->Object.Node );
}
_Scheduler_priority_Schedule_body( scheduler, the_thread, true );
}
4000a2a8: 81 c7 e0 08 ret
4000a2ac: 81 e8 00 00 restore
4000a5fc <_Scheduler_simple_Block>:
void _Scheduler_simple_Block(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
4000a5fc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
previous = the_node->previous;
4000a600: c2 06 60 04 ld [ %i1 + 4 ], %g1
<== NOT EXECUTED
next = the_node->next;
4000a604: c4 06 40 00 ld [ %i1 ], %g2
<== NOT EXECUTED
next->previous = previous;
4000a608: c2 20 a0 04 st %g1, [ %g2 + 4 ]
<== NOT EXECUTED
return ( the_thread == _Thread_Executing );
4000a60c: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
previous->next = next;
4000a610: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
{
( *extract )( scheduler, the_thread, node );
/* TODO: flash critical section? */
if ( _Thread_Is_executing( the_thread ) || _Thread_Is_heir( the_thread ) ) {
4000a614: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1
<== NOT EXECUTED
4000a618: 80 a6 40 01 cmp %i1, %g1
<== NOT EXECUTED
4000a61c: 02 80 00 07 be 4000a638 <_Scheduler_simple_Block+0x3c>
<== NOT EXECUTED
4000a620: f8 01 a0 24 ld [ %g6 + 0x24 ], %i4
4000a624: 80 a6 40 1c cmp %i1, %i4
4000a628: 22 80 00 05 be,a 4000a63c <_Scheduler_simple_Block+0x40> <== NEVER TAKEN
4000a62c: c2 06 00 00 ld [ %i0 ], %g1
<== NOT EXECUTED
the_thread,
node,
_Scheduler_simple_Extract,
_Scheduler_simple_Schedule_body
);
}
4000a630: 81 c7 e0 08 ret
4000a634: 81 e8 00 00 restore
return _Chain_Immutable_head( the_chain )->next;
4000a638: c2 06 00 00 ld [ %i0 ], %g1
4000a63c: f6 00 40 00 ld [ %g1 ], %i3
bool force_dispatch
)
{
Thread_Control *heir = _Thread_Heir;
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4000a640: 80 a6 c0 1c cmp %i3, %i4
4000a644: 02 80 00 0e be 4000a67c <_Scheduler_simple_Block+0x80> <== NEVER TAKEN
4000a648: 01 00 00 00 nop
*time = _Timecounter_Sbinuptime();
4000a64c: 7f ff fa 6a call 40008ff4 <_Timecounter_Sbinuptime>
4000a650: e0 1f 60 28 ldd [ %i5 + 0x28 ], %l0
4000a654: d0 3f 60 28 std %o0, [ %i5 + 0x28 ]
const Timestamp_Control *_start,
const Timestamp_Control *_end,
Timestamp_Control *_result
)
{
*_result = *_end - *_start;
4000a658: b2 a2 40 11 subcc %o1, %l1, %i1
*_time += *_add;
4000a65c: d8 1f 20 98 ldd [ %i4 + 0x98 ], %o4
*_result = *_end - *_start;
4000a660: b0 62 00 10 subx %o0, %l0, %i0
*_time += *_add;
4000a664: 86 83 40 19 addcc %o5, %i1, %g3
4000a668: 84 43 00 18 addx %o4, %i0, %g2
4000a66c: c4 3f 20 98 std %g2, [ %i4 + 0x98 ]
heir->Scheduler.state = THREAD_SCHEDULER_BLOCKED;
new_heir->Scheduler.state = THREAD_SCHEDULER_SCHEDULED;
#endif
_Thread_Update_CPU_time_used( heir, _Thread_Get_CPU( heir ) );
_Thread_Heir = new_heir;
_Thread_Dispatch_necessary = true;
4000a670: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
4000a674: f6 21 a0 24 st %i3, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
4000a678: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
4000a67c: 81 c7 e0 08 ret
4000a680: 81 e8 00 00 restore
4000a794 <_Scheduler_simple_Initialize>:
#include <rtems/score/schedulersimpleimpl.h>
#include <rtems/score/chainimpl.h>
void _Scheduler_simple_Initialize( const Scheduler_Control *scheduler )
{
4000a794: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
return &the_chain->Tail.Node;
4000a798: 84 00 60 04 add %g1, 4, %g2
<== NOT EXECUTED
head->previous = NULL;
4000a79c: c0 20 60 04 clr [ %g1 + 4 ]
<== NOT EXECUTED
head->next = tail;
4000a7a0: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
Scheduler_simple_Context *context =
_Scheduler_simple_Get_context( scheduler );
_Chain_Initialize_empty( &context->Ready );
}
4000a7a4: 81 c3 e0 08 retl
<== NOT EXECUTED
4000a7a8: c2 20 60 08 st %g1, [ %g1 + 8 ]
4000a7ac <_Scheduler_simple_Schedule>:
void _Scheduler_simple_Schedule(
const Scheduler_Control *scheduler,
Thread_Control *the_thread
)
{
4000a7ac: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000a7b0: c2 06 00 00 ld [ %i0 ], %g1
<== NOT EXECUTED
4000a7b4: f6 00 40 00 ld [ %g1 ], %i3
<== NOT EXECUTED
Thread_Control *heir = _Thread_Heir;
4000a7b8: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
<== NOT EXECUTED
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4000a7bc: 80 a6 c0 1d cmp %i3, %i5
<== NOT EXECUTED
4000a7c0: 02 80 00 06 be 4000a7d8 <_Scheduler_simple_Schedule+0x2c>
<== NOT EXECUTED
4000a7c4: b8 10 00 06 mov %g6, %i4
<== NOT EXECUTED
4000a7c8: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1
<== NOT EXECUTED
4000a7cc: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000a7d0: 12 80 00 04 bne 4000a7e0 <_Scheduler_simple_Schedule+0x34>
<== NOT EXECUTED
4000a7d4: 01 00 00 00 nop
<== NOT EXECUTED
_Scheduler_simple_Schedule_body( scheduler, the_thread, false );
}
4000a7d8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a7dc: 81 e8 00 00 restore
<== NOT EXECUTED
4000a7e0: 7f ff fa 05 call 40008ff4 <_Timecounter_Sbinuptime>
<== NOT EXECUTED
4000a7e4: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0
<== NOT EXECUTED
4000a7e8: d0 3f 20 28 std %o0, [ %i4 + 0x28 ]
<== NOT EXECUTED
*_result = *_end - *_start;
4000a7ec: b2 a2 40 11 subcc %o1, %l1, %i1
<== NOT EXECUTED
*_time += *_add;
4000a7f0: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4
<== NOT EXECUTED
*_result = *_end - *_start;
4000a7f4: b0 62 00 10 subx %o0, %l0, %i0
<== NOT EXECUTED
*_time += *_add;
4000a7f8: 86 83 40 19 addcc %o5, %i1, %g3
<== NOT EXECUTED
4000a7fc: 84 43 00 18 addx %o4, %i0, %g2
<== NOT EXECUTED
4000a800: c4 3f 60 98 std %g2, [ %i5 + 0x98 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
4000a804: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
_Thread_Heir = new_heir;
4000a808: f6 21 a0 24 st %i3, [ %g6 + 0x24 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
4000a80c: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
<== NOT EXECUTED
4000a810: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a814: 81 e8 00 00 restore
<== NOT EXECUTED
4000a818 <_Scheduler_simple_Unblock>:
void _Scheduler_simple_Unblock(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
4000a818: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
4000a81c: c6 06 00 00 ld [ %i0 ], %g3
<== NOT EXECUTED
4000a820: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
<== NOT EXECUTED
4000a824: f8 00 60 1c ld [ %g1 + 0x1c ], %i4
<== NOT EXECUTED
4000a828: c2 00 c0 00 ld [ %g3 ], %g1
<== NOT EXECUTED
return &the_chain->Tail.Node;
4000a82c: 86 00 e0 04 add %g3, 4, %g3
<== NOT EXECUTED
while ( next != tail && !( *order )( left, next ) ) {
4000a830: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
4000a834: 02 80 00 18 be 4000a894 <_Scheduler_simple_Unblock+0x7c>
<== NOT EXECUTED
4000a838: b6 17 20 01 or %i4, 1, %i3
4000a83c: c4 00 60 38 ld [ %g1 + 0x38 ], %g2
4000a840: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
4000a844: 80 a1 20 00 cmp %g4, 0
4000a848: 12 80 00 12 bne 4000a890 <_Scheduler_simple_Unblock+0x78> <== NEVER TAKEN
4000a84c: ba 10 20 00 clr %i5
4000a850: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
4000a854: 80 a0 80 1b cmp %g2, %i3
4000a858: 3a 80 00 0f bcc,a 4000a894 <_Scheduler_simple_Unblock+0x7c>
4000a85c: 86 10 00 01 mov %g1, %g3
4000a860: c2 00 40 00 ld [ %g1 ], %g1
4000a864: 80 a0 c0 01 cmp %g3, %g1
4000a868: 22 80 00 0c be,a 4000a898 <_Scheduler_simple_Unblock+0x80>
4000a86c: c2 00 e0 04 ld [ %g3 + 4 ], %g1
4000a870: c4 00 60 38 ld [ %g1 + 0x38 ], %g2
4000a874: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
4000a878: 80 a7 40 04 cmp %i5, %g4
4000a87c: 12 80 00 05 bne 4000a890 <_Scheduler_simple_Unblock+0x78> <== NEVER TAKEN
4000a880: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
4000a884: 80 a6 c0 02 cmp %i3, %g2
4000a888: 38 bf ff f7 bgu,a 4000a864 <_Scheduler_simple_Unblock+0x4c>
4000a88c: c2 00 40 00 ld [ %g1 ], %g1
4000a890: 86 10 00 01 mov %g1, %g3
4000a894: c2 00 e0 04 ld [ %g3 + 4 ], %g1
the_node->previous = after_node;
4000a898: c2 26 60 04 st %g1, [ %i1 + 4 ]
before_node = after_node->next;
4000a89c: c4 00 40 00 ld [ %g1 ], %g2
after_node->next = the_node;
4000a8a0: f2 20 40 00 st %i1, [ %g1 ]
the_node->next = before_node;
4000a8a4: c4 26 40 00 st %g2, [ %i1 ]
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
4000a8a8: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
4000a8ac: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
before_node->previous = the_node;
4000a8b0: f2 20 a0 04 st %i1, [ %g2 + 4 ]
4000a8b4: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4000a8b8: 80 a0 a0 00 cmp %g2, 0
4000a8bc: 18 80 00 09 bgu 4000a8e0 <_Scheduler_simple_Unblock+0xc8> <== NEVER TAKEN
4000a8c0: b6 10 00 06 mov %g6, %i3
4000a8c4: 22 80 00 04 be,a 4000a8d4 <_Scheduler_simple_Unblock+0xbc> <== ALWAYS TAKEN
4000a8c8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
_Scheduler_Update_heir(
the_thread,
priority == PRIORITY_PSEUDO_ISR
);
}
}
4000a8cc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a8d0: 81 e8 00 00 restore
<== NOT EXECUTED
if ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
4000a8d4: 80 a0 40 1c cmp %g1, %i4
4000a8d8: 08 80 00 17 bleu 4000a934 <_Scheduler_simple_Unblock+0x11c>
4000a8dc: 01 00 00 00 nop
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4000a8e0: 80 a7 40 19 cmp %i5, %i1
4000a8e4: 02 bf ff fa be 4000a8cc <_Scheduler_simple_Unblock+0xb4> <== NEVER TAKEN
4000a8e8: 80 a7 20 00 cmp %i4, 0
4000a8ec: 02 80 00 06 be 4000a904 <_Scheduler_simple_Unblock+0xec>
4000a8f0: 01 00 00 00 nop
4000a8f4: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1
4000a8f8: 80 a0 60 00 cmp %g1, 0
4000a8fc: 02 80 00 0e be 4000a934 <_Scheduler_simple_Unblock+0x11c>
4000a900: 01 00 00 00 nop
4000a904: 7f ff f9 bc call 40008ff4 <_Timecounter_Sbinuptime>
4000a908: e0 1e e0 28 ldd [ %i3 + 0x28 ], %l0
4000a90c: d0 3e e0 28 std %o0, [ %i3 + 0x28 ]
*_result = *_end - *_start;
4000a910: b6 a2 40 11 subcc %o1, %l1, %i3
*_time += *_add;
4000a914: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4
*_result = *_end - *_start;
4000a918: b4 62 00 10 subx %o0, %l0, %i2
*_time += *_add;
4000a91c: 86 83 40 1b addcc %o5, %i3, %g3
4000a920: 84 43 00 1a addx %o4, %i2, %g2
4000a924: c4 3f 60 98 std %g2, [ %i5 + 0x98 ]
_Thread_Dispatch_necessary = true;
4000a928: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
4000a92c: f2 21 a0 24 st %i1, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
4000a930: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
}
4000a934: 81 c7 e0 08 ret
4000a938: 81 e8 00 00 restore
4000a684 <_Scheduler_simple_Update_priority>:
void _Scheduler_simple_Update_priority(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
4000a684: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Scheduler_simple_Context *context;
unsigned int new_priority;
if ( !_Thread_Is_ready( the_thread ) ) {
4000a688: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
<== NOT EXECUTED
4000a68c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000a690: 22 80 00 04 be,a 4000a6a0 <_Scheduler_simple_Update_priority+0x1c>
<== NOT EXECUTED
4000a694: c2 06 60 04 ld [ %i1 + 4 ], %g1
new_priority = (unsigned int ) _Scheduler_Node_get_priority( node );
_Scheduler_simple_Extract( scheduler, the_thread, node );
_Scheduler_simple_Insert( &context->Ready, the_thread, new_priority );
_Scheduler_simple_Schedule_body( scheduler, the_thread, false );
}
4000a698: 81 c7 e0 08 ret
4000a69c: 81 e8 00 00 restore
next = the_node->next;
4000a6a0: c4 06 40 00 ld [ %i1 ], %g2
4000a6a4: f8 06 00 00 ld [ %i0 ], %i4
4000a6a8: f6 06 a0 34 ld [ %i2 + 0x34 ], %i3
next->previous = previous;
4000a6ac: c2 20 a0 04 st %g1, [ %g2 + 4 ]
return &the_chain->Tail.Node;
4000a6b0: 88 07 20 04 add %i4, 4, %g4
previous->next = next;
4000a6b4: c4 20 40 00 st %g2, [ %g1 ]
return _Chain_Immutable_head( the_chain )->next;
4000a6b8: c2 07 00 00 ld [ %i4 ], %g1
)
{
const Chain_Node *tail = _Chain_Immutable_tail( the_chain );
Chain_Node *next = _Chain_First( the_chain );
while ( next != tail && !( *order )( left, next ) ) {
4000a6bc: 80 a1 00 01 cmp %g4, %g1
4000a6c0: 22 80 00 19 be,a 4000a724 <_Scheduler_simple_Update_priority+0xa0> <== NEVER TAKEN
4000a6c4: c2 01 20 04 ld [ %g4 + 4 ], %g1
<== NOT EXECUTED
4000a6c8: c4 00 60 38 ld [ %g1 + 0x38 ], %g2
4000a6cc: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
4000a6d0: 80 a0 e0 00 cmp %g3, 0
4000a6d4: 12 80 00 12 bne 4000a71c <_Scheduler_simple_Update_priority+0x98> <== NEVER TAKEN
4000a6d8: ba 10 20 00 clr %i5
4000a6dc: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
4000a6e0: 80 a0 80 1b cmp %g2, %i3
4000a6e4: 3a 80 00 0f bcc,a 4000a720 <_Scheduler_simple_Update_priority+0x9c>
4000a6e8: 88 10 00 01 mov %g1, %g4
4000a6ec: c2 00 40 00 ld [ %g1 ], %g1
4000a6f0: 80 a1 00 01 cmp %g4, %g1
4000a6f4: 22 80 00 0c be,a 4000a724 <_Scheduler_simple_Update_priority+0xa0>
4000a6f8: c2 01 20 04 ld [ %g4 + 4 ], %g1
4000a6fc: c4 00 60 38 ld [ %g1 + 0x38 ], %g2
4000a700: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
4000a704: 80 a7 40 03 cmp %i5, %g3
4000a708: 12 80 00 05 bne 4000a71c <_Scheduler_simple_Update_priority+0x98> <== NEVER TAKEN
4000a70c: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
4000a710: 80 a6 c0 02 cmp %i3, %g2
4000a714: 38 bf ff f7 bgu,a 4000a6f0 <_Scheduler_simple_Update_priority+0x6c>
4000a718: c2 00 40 00 ld [ %g1 ], %g1
4000a71c: 88 10 00 01 mov %g1, %g4
4000a720: c2 01 20 04 ld [ %g4 + 4 ], %g1
the_node->previous = after_node;
4000a724: c2 26 60 04 st %g1, [ %i1 + 4 ]
before_node = after_node->next;
4000a728: c4 00 40 00 ld [ %g1 ], %g2
after_node->next = the_node;
4000a72c: f2 20 40 00 st %i1, [ %g1 ]
the_node->next = before_node;
4000a730: c4 26 40 00 st %g2, [ %i1 ]
before_node->previous = the_node;
4000a734: f2 20 a0 04 st %i1, [ %g2 + 4 ]
return _Chain_Immutable_head( the_chain )->next;
4000a738: f8 07 00 00 ld [ %i4 ], %i4
Thread_Control *heir = _Thread_Heir;
4000a73c: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4000a740: 80 a7 00 1d cmp %i4, %i5
4000a744: 02 bf ff d5 be 4000a698 <_Scheduler_simple_Update_priority+0x14>
4000a748: b6 10 00 06 mov %g6, %i3
4000a74c: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1
4000a750: 80 a0 60 00 cmp %g1, 0
4000a754: 02 80 00 0e be 4000a78c <_Scheduler_simple_Update_priority+0x108> <== ALWAYS TAKEN
4000a758: 01 00 00 00 nop
4000a75c: 7f ff fa 26 call 40008ff4 <_Timecounter_Sbinuptime>
<== NOT EXECUTED
4000a760: f0 19 a0 28 ldd [ %g6 + 0x28 ], %i0
<== NOT EXECUTED
4000a764: d0 3e e0 28 std %o0, [ %i3 + 0x28 ]
<== NOT EXECUTED
*_result = *_end - *_start;
4000a768: b6 a2 40 19 subcc %o1, %i1, %i3
<== NOT EXECUTED
4000a76c: b4 62 00 18 subx %o0, %i0, %i2
<== NOT EXECUTED
*_time += *_add;
4000a770: f0 1f 60 98 ldd [ %i5 + 0x98 ], %i0
<== NOT EXECUTED
4000a774: 86 86 40 1b addcc %i1, %i3, %g3
<== NOT EXECUTED
4000a778: 84 46 00 1a addx %i0, %i2, %g2
<== NOT EXECUTED
4000a77c: c4 3f 60 98 std %g2, [ %i5 + 0x98 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
4000a780: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
_Thread_Heir = new_heir;
4000a784: f8 21 a0 24 st %i4, [ %g6 + 0x24 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
4000a788: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
<== NOT EXECUTED
4000a78c: 81 c7 e0 08 ret
4000a790: 81 e8 00 00 restore
4000a93c <_Scheduler_simple_Yield>:
void _Scheduler_simple_Yield(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
4000a93c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
next = the_node->next;
4000a940: c4 06 40 00 ld [ %i1 ], %g2
<== NOT EXECUTED
previous = the_node->previous;
4000a944: c2 06 60 04 ld [ %i1 + 4 ], %g1
<== NOT EXECUTED
4000a948: f8 06 00 00 ld [ %i0 ], %i4
<== NOT EXECUTED
next->previous = previous;
4000a94c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
<== NOT EXECUTED
return &the_chain->Tail.Node;
4000a950: 88 07 20 04 add %i4, 4, %g4
<== NOT EXECUTED
previous->next = next;
4000a954: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
context = _Scheduler_simple_Get_context( scheduler );
(void) node;
_Chain_Extract_unprotected( &the_thread->Object.Node );
insert_priority = (unsigned int) _Thread_Get_priority( the_thread );
4000a958: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
<== NOT EXECUTED
4000a95c: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000a960: c2 07 00 00 ld [ %i4 ], %g1
<== NOT EXECUTED
while ( next != tail && !( *order )( left, next ) ) {
4000a964: 80 a1 00 01 cmp %g4, %g1
<== NOT EXECUTED
4000a968: 02 80 00 18 be 4000a9c8 <_Scheduler_simple_Yield+0x8c>
<== NOT EXECUTED
4000a96c: b6 10 a0 01 or %g2, 1, %i3
4000a970: c4 00 60 38 ld [ %g1 + 0x38 ], %g2
4000a974: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
4000a978: 80 a0 e0 00 cmp %g3, 0
4000a97c: 12 80 00 12 bne 4000a9c4 <_Scheduler_simple_Yield+0x88> <== NEVER TAKEN
4000a980: ba 10 20 00 clr %i5
4000a984: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
4000a988: 80 a0 80 1b cmp %g2, %i3
4000a98c: 3a 80 00 0f bcc,a 4000a9c8 <_Scheduler_simple_Yield+0x8c>
4000a990: 88 10 00 01 mov %g1, %g4
4000a994: c2 00 40 00 ld [ %g1 ], %g1
4000a998: 80 a1 00 01 cmp %g4, %g1
4000a99c: 22 80 00 0c be,a 4000a9cc <_Scheduler_simple_Yield+0x90> <== NEVER TAKEN
4000a9a0: c2 01 20 04 ld [ %g4 + 4 ], %g1
<== NOT EXECUTED
4000a9a4: c4 00 60 38 ld [ %g1 + 0x38 ], %g2
4000a9a8: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
4000a9ac: 80 a7 40 03 cmp %i5, %g3
4000a9b0: 12 80 00 05 bne 4000a9c4 <_Scheduler_simple_Yield+0x88> <== NEVER TAKEN
4000a9b4: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
4000a9b8: 80 a6 c0 02 cmp %i3, %g2
4000a9bc: 38 bf ff f7 bgu,a 4000a998 <_Scheduler_simple_Yield+0x5c>
4000a9c0: c2 00 40 00 ld [ %g1 ], %g1
4000a9c4: 88 10 00 01 mov %g1, %g4
4000a9c8: c2 01 20 04 ld [ %g4 + 4 ], %g1
the_node->previous = after_node;
4000a9cc: c2 26 60 04 st %g1, [ %i1 + 4 ]
before_node = after_node->next;
4000a9d0: c4 00 40 00 ld [ %g1 ], %g2
after_node->next = the_node;
4000a9d4: f2 20 40 00 st %i1, [ %g1 ]
the_node->next = before_node;
4000a9d8: c4 26 40 00 st %g2, [ %i1 ]
before_node->previous = the_node;
4000a9dc: f2 20 a0 04 st %i1, [ %g2 + 4 ]
return _Chain_Immutable_head( the_chain )->next;
4000a9e0: f8 07 00 00 ld [ %i4 ], %i4
Thread_Control *heir = _Thread_Heir;
4000a9e4: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4000a9e8: 80 a7 00 1d cmp %i4, %i5
4000a9ec: 02 80 00 06 be 4000aa04 <_Scheduler_simple_Yield+0xc8>
4000a9f0: b6 10 00 06 mov %g6, %i3
4000a9f4: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1
4000a9f8: 80 a0 60 00 cmp %g1, 0
4000a9fc: 12 80 00 04 bne 4000aa0c <_Scheduler_simple_Yield+0xd0> <== NEVER TAKEN
4000aa00: 01 00 00 00 nop
insert_priority = SCHEDULER_PRIORITY_APPEND( insert_priority );
_Scheduler_simple_Insert( &context->Ready, the_thread, insert_priority );
_Scheduler_simple_Schedule_body( scheduler, the_thread, false );
}
4000aa04: 81 c7 e0 08 ret
4000aa08: 81 e8 00 00 restore
4000aa0c: 7f ff f9 7a call 40008ff4 <_Timecounter_Sbinuptime>
<== NOT EXECUTED
4000aa10: f0 19 a0 28 ldd [ %g6 + 0x28 ], %i0
<== NOT EXECUTED
4000aa14: d0 3e e0 28 std %o0, [ %i3 + 0x28 ]
<== NOT EXECUTED
*_result = *_end - *_start;
4000aa18: b6 a2 40 19 subcc %o1, %i1, %i3
<== NOT EXECUTED
4000aa1c: b4 62 00 18 subx %o0, %i0, %i2
<== NOT EXECUTED
*_time += *_add;
4000aa20: f0 1f 60 98 ldd [ %i5 + 0x98 ], %i0
<== NOT EXECUTED
4000aa24: 86 86 40 1b addcc %i1, %i3, %g3
<== NOT EXECUTED
4000aa28: 84 46 00 1a addx %i0, %i2, %g2
<== NOT EXECUTED
4000aa2c: c4 3f 60 98 std %g2, [ %i5 + 0x98 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
4000aa30: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
_Thread_Heir = new_heir;
4000aa34: f8 21 a0 24 st %i4, [ %g6 + 0x24 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
4000aa38: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
<== NOT EXECUTED
4000aa3c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000aa40: 81 e8 00 00 restore
<== NOT EXECUTED
4001da94 <_Semaphore_Post>:
_Sem_Queue_release( sem, level, &queue_context );
return eno;
}
void _Semaphore_Post( struct _Semaphore_Control *_sem )
{
4001da94: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001da98: 91 d0 20 09 ta 9
<== NOT EXECUTED
sem = _Sem_Get( _sem );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
_Sem_Queue_acquire_critical( sem, &queue_context );
heads = sem->Queue.Queue.heads;
4001da9c: d0 06 20 08 ld [ %i0 + 8 ], %o0
if ( __predict_true( heads == NULL ) ) {
4001daa0: 80 a2 20 00 cmp %o0, 0
4001daa4: 32 80 00 09 bne,a 4001dac8 <_Semaphore_Post+0x34>
4001daa8: c2 27 bf dc st %g1, [ %fp + -36 ]
++sem->count;
4001daac: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
4001dab0: 84 00 a0 01 inc %g2
<== NOT EXECUTED
4001dab4: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001dab8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001dabc: 01 00 00 00 nop
4001dac0: 81 c7 e0 08 ret
4001dac4: 81 e8 00 00 restore
const Thread_queue_Operations *operations;
Thread_Control *first;
_Thread_queue_Context_set_ISR_level( &queue_context, level );
operations = SEMAPHORE_TQ_OPERATIONS;
first = ( *operations->first )( heads );
4001dac8: 3b 10 01 5c sethi %hi(0x40057000), %i5
4001dacc: ba 17 60 2c or %i5, 0x2c, %i5 ! 4005702c <_Thread_queue_Operations_priority>
4001dad0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4001dad4: 9f c0 40 00 call %g1
4001dad8: 01 00 00 00 nop
_Thread_queue_Extract_critical(
4001dadc: 96 07 bf dc add %fp, -36, %o3
4001dae0: 94 10 00 08 mov %o0, %o2
4001dae4: 92 10 00 1d mov %i5, %o1
4001dae8: 40 00 03 a5 call 4001e97c <_Thread_queue_Extract_critical>
4001daec: 90 06 20 08 add %i0, 8, %o0
operations,
first,
&queue_context
);
}
}
4001daf0: 81 c7 e0 08 ret
4001daf4: 81 e8 00 00 restore
40012ed8 <_Semaphore_Post_binary>:
);
}
}
void _Semaphore_Post_binary( struct _Semaphore_Control *_sem )
{
40012ed8: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40012edc: 91 d0 20 09 ta 9
<== NOT EXECUTED
sem = _Sem_Get( _sem );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
_Sem_Queue_acquire_critical( sem, &queue_context );
heads = sem->Queue.Queue.heads;
40012ee0: d0 06 20 08 ld [ %i0 + 8 ], %o0
if ( __predict_true( heads == NULL ) ) {
40012ee4: 80 a2 20 00 cmp %o0, 0
40012ee8: 12 80 00 07 bne 40012f04 <_Semaphore_Post_binary+0x2c>
40012eec: 84 10 20 01 mov 1, %g2
sem->count = 1;
40012ef0: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40012ef4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40012ef8: 01 00 00 00 nop
40012efc: 81 c7 e0 08 ret
40012f00: 81 e8 00 00 restore
40012f04: c2 27 bf dc st %g1, [ %fp + -36 ]
const Thread_queue_Operations *operations;
Thread_Control *first;
_Thread_queue_Context_set_ISR_level( &queue_context, level );
operations = SEMAPHORE_TQ_OPERATIONS;
first = ( *operations->first )( heads );
40012f08: 3b 10 00 4e sethi %hi(0x40013800), %i5
40012f0c: ba 17 62 04 or %i5, 0x204, %i5 ! 40013a04 <_Thread_queue_Operations_priority>
40012f10: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40012f14: 9f c0 40 00 call %g1
40012f18: 01 00 00 00 nop
_Thread_queue_Extract_critical(
40012f1c: 96 07 bf dc add %fp, -36, %o3
40012f20: 94 10 00 08 mov %o0, %o2
40012f24: 92 10 00 1d mov %i5, %o1
40012f28: 7f ff db bb call 40009e14 <_Thread_queue_Extract_critical>
40012f2c: 90 06 20 08 add %i0, 8, %o0
operations,
first,
&queue_context
);
}
}
40012f30: 81 c7 e0 08 ret
40012f34: 81 e8 00 00 restore
40012e94 <_Semaphore_Try_wait>:
int _Semaphore_Try_wait( struct _Semaphore_Control *_sem )
{
40012e94: 86 10 00 08 mov %o0, %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40012e98: 91 d0 20 09 ta 9
<== NOT EXECUTED
sem = _Sem_Get( _sem );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
_Sem_Queue_acquire_critical( sem, &queue_context );
count = sem->count;
40012e9c: c4 02 20 14 ld [ %o0 + 0x14 ], %g2
if ( __predict_true( count > 0 ) ) {
40012ea0: 80 a0 a0 00 cmp %g2, 0
40012ea4: 02 80 00 08 be 40012ec4 <_Semaphore_Try_wait+0x30>
40012ea8: 84 00 bf ff add %g2, -1, %g2
sem->count = count - 1;
eno = 0;
40012eac: 90 10 20 00 clr %o0
<== NOT EXECUTED
sem->count = count - 1;
40012eb0: c4 20 e0 14 st %g2, [ %g3 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40012eb4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40012eb8: 01 00 00 00 nop
eno = EAGAIN;
}
_Sem_Queue_release( sem, level, &queue_context );
return eno;
}
40012ebc: 81 c3 e0 08 retl
40012ec0: 01 00 00 00 nop
eno = EAGAIN;
40012ec4: 90 10 20 0b mov 0xb, %o0 ! b <_TLS_Alignment+0xa>
<== NOT EXECUTED
40012ec8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40012ecc: 01 00 00 00 nop
}
40012ed0: 81 c3 e0 08 retl
40012ed4: 01 00 00 00 nop
40012db4 <_Semaphore_Wait>:
sizeof( Sem_Control ) == sizeof( struct _Semaphore_Control ),
SEMAPHORE_CONTROL_SIZE
);
void _Semaphore_Wait( struct _Semaphore_Control *_sem )
{
40012db4: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40012db8: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
40012dbc: 86 10 00 01 mov %g1, %g3
sem = _Sem_Get( _sem );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
executing = _Sem_Queue_acquire_critical( sem, &queue_context );
count = sem->count;
40012dc0: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
if ( __predict_true( count > 0 ) ) {
40012dc4: 80 a0 a0 00 cmp %g2, 0
40012dc8: 02 80 00 07 be 40012de4 <_Semaphore_Wait+0x30>
40012dcc: 84 00 bf ff add %g2, -1, %g2
sem->count = count - 1;
40012dd0: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40012dd4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40012dd8: 01 00 00 00 nop
40012ddc: 81 c7 e0 08 ret
40012de0: 81 e8 00 00 restore
queue_context->thread_state = thread_state;
40012de4: 82 10 20 02 mov 2, %g1
Thread_queue_Context *queue_context
)
{
Thread_Control *executing;
executing = _Thread_Executing;
40012de8: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
40012dec: c2 27 bf e0 st %g1, [ %fp + -32 ]
queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;
40012df0: 03 10 00 27 sethi %hi(0x40009c00), %g1
40012df4: 82 10 60 24 or %g1, 0x24, %g1 ! 40009c24 <_Thread_queue_Enqueue_do_nothing_extra>
&queue_context,
STATES_WAITING_FOR_SEMAPHORE
);
_Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context );
_Thread_queue_Context_set_ISR_level( &queue_context, level );
_Thread_queue_Enqueue(
40012df8: 96 07 bf dc add %fp, -36, %o3
40012dfc: c2 27 bf e4 st %g1, [ %fp + -28 ]
40012e00: 13 10 00 4e sethi %hi(0x40013800), %o1
40012e04: c6 27 bf dc st %g3, [ %fp + -36 ]
40012e08: 92 12 62 04 or %o1, 0x204, %o1
40012e0c: 7f ff db 8c call 40009c3c <_Thread_queue_Enqueue>
40012e10: 90 06 20 08 add %i0, 8, %o0
SEMAPHORE_TQ_OPERATIONS,
executing,
&queue_context
);
}
}
40012e14: 81 c7 e0 08 ret
40012e18: 81 e8 00 00 restore
40012e1c <_Semaphore_Wait_timed_ticks>:
int _Semaphore_Wait_timed_ticks( struct _Semaphore_Control *_sem, uint32_t ticks )
{
40012e1c: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40012e20: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
40012e24: 86 10 00 01 mov %g1, %g3
sem = _Sem_Get( _sem );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
executing = _Sem_Queue_acquire_critical( sem, &queue_context );
count = sem->count;
40012e28: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
if ( __predict_true( count > 0 ) ) {
40012e2c: 80 a0 a0 00 cmp %g2, 0
40012e30: 02 80 00 07 be 40012e4c <_Semaphore_Wait_timed_ticks+0x30>
40012e34: 84 00 bf ff add %g2, -1, %g2
sem->count = count - 1;
40012e38: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40012e3c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40012e40: 01 00 00 00 nop
_Sem_Queue_release( sem, level, &queue_context );
return 0;
40012e44: 81 c7 e0 08 ret
40012e48: 91 e8 20 00 restore %g0, 0, %o0
queue_context->thread_state = thread_state;
40012e4c: 82 10 20 02 mov 2, %g1
40012e50: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
40012e54: c2 27 bf e0 st %g1, [ %fp + -32 ]
queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks;
40012e58: 03 10 00 2a sethi %hi(0x4000a800), %g1
40012e5c: 82 10 60 74 or %g1, 0x74, %g1 ! 4000a874 <_Thread_queue_Add_timeout_ticks>
&queue_context,
STATES_WAITING_FOR_SEMAPHORE
);
_Thread_queue_Context_set_enqueue_timeout_ticks( &queue_context, ticks );
_Thread_queue_Context_set_ISR_level( &queue_context, level );
_Thread_queue_Enqueue(
40012e60: 90 06 20 08 add %i0, 8, %o0
queue_context->Timeout.ticks = ticks;
40012e64: f2 27 bf e8 st %i1, [ %fp + -24 ]
40012e68: 96 07 bf dc add %fp, -36, %o3
40012e6c: c6 27 bf dc st %g3, [ %fp + -36 ]
40012e70: 94 10 00 1d mov %i5, %o2
queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks;
40012e74: c2 27 bf e4 st %g1, [ %fp + -28 ]
40012e78: 13 10 00 4e sethi %hi(0x40013800), %o1
40012e7c: 7f ff db 70 call 40009c3c <_Thread_queue_Enqueue>
40012e80: 92 12 62 04 or %o1, 0x204, %o1 ! 40013a04 <_Thread_queue_Operations_priority>
&sem->Queue.Queue,
SEMAPHORE_TQ_OPERATIONS,
executing,
&queue_context
);
return STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) );
40012e84: f0 07 60 4c ld [ %i5 + 0x4c ], %i0
40012e88: b1 3e 20 08 sra %i0, 8, %i0
}
}
40012e8c: 81 c7 e0 08 ret
40012e90: 81 e8 00 00 restore
40006a7c <_TOD_Adjust>:
#include <rtems/score/todimpl.h>
void _TOD_Adjust(
const struct timespec *delta
)
{
40006a7c: 9d e3 bf 88 save %sp, -120, %sp
<== NOT EXECUTED
* enhancement would be to adjust the time in smaller increments
* at each clock tick. Until then, there is no outstanding
* adjustment.
*/
_TOD_Lock();
40006a80: 40 00 00 10 call 40006ac0 <_TOD_Lock>
<== NOT EXECUTED
40006a84: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006a88: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Timecounter_Acquire( lock_context );
40006a8c: c2 27 bf ec st %g1, [ %fp + -20 ]
_Timecounter_Nanotime( tod );
40006a90: 40 00 06 b0 call 40008550 <_Timecounter_Nanotime>
40006a94: 90 07 bf f0 add %fp, -16, %o0
_TOD_Acquire( &lock_context );
_TOD_Get( &tod );
_Timespec_Add_to( &tod, delta );
40006a98: 92 10 00 18 mov %i0, %o1
40006a9c: 40 00 14 16 call 4000baf4 <_Timespec_Add_to>
40006aa0: 90 07 bf f0 add %fp, -16, %o0
_TOD_Set( &tod, &lock_context );
40006aa4: 92 07 bf ec add %fp, -20, %o1
40006aa8: 40 00 00 10 call 40006ae8 <_TOD_Set>
40006aac: 90 07 bf f0 add %fp, -16, %o0
_TOD_Unlock();
40006ab0: 40 00 00 09 call 40006ad4 <_TOD_Unlock>
40006ab4: 01 00 00 00 nop
}
40006ab8: 81 c7 e0 08 ret
40006abc: 81 e8 00 00 restore
4000816c <_TOD_Lock>:
static API_Mutex_Control _TOD_Mutex = API_MUTEX_INITIALIZER( "_TOD" );
void _TOD_Lock( void )
{
_API_Mutex_Lock( &_TOD_Mutex );
4000816c: 11 10 00 4f sethi %hi(0x40013c00), %o0
<== NOT EXECUTED
40008170: 90 12 23 04 or %o0, 0x304, %o0 ! 40013f04 <_TOD_Mutex>
<== NOT EXECUTED
40008174: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40008178: 7f ff ff d1 call 400080bc <_API_Mutex_Lock>
<== NOT EXECUTED
4000817c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40008194 <_TOD_Set>:
void _TOD_Set(
const struct timespec *tod,
ISR_lock_Context *lock_context
)
{
40008194: 9d e3 bf 88 save %sp, -120, %sp
<== NOT EXECUTED
_bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL;
40008198: c4 06 20 08 ld [ %i0 + 8 ], %g2
<== NOT EXECUTED
4000819c: 89 28 a0 02 sll %g2, 2, %g4
<== NOT EXECUTED
_bt->sec = _ts->tv_sec;
400081a0: f8 1e 00 00 ldd [ %i0 ], %i4
_bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL;
400081a4: 83 38 a0 1f sra %g2, 0x1f, %g1
400081a8: 07 12 e0 be sethi %hi(0x4b82f800), %g3
400081ac: 86 10 e2 09 or %g3, 0x209, %g3 ! 4b82fa09 <RAM_END+0xb42fa09>
400081b0: 82 58 40 03 smul %g1, %g3, %g1
400081b4: 86 50 80 03 umul %g2, %g3, %g3
400081b8: 85 40 00 00 rd %y, %g2
400081bc: 82 00 40 04 add %g1, %g4, %g1
400081c0: 84 00 40 02 add %g1, %g2, %g2
_bt->sec = _ts->tv_sec;
400081c4: f8 3f bf f0 std %i4, [ %fp + -16 ]
uint32_t cpu_index;
_Assert( _TOD_Is_owner() );
timespec2bintime( tod, &tod_as_bintime );
_Timecounter_Set_clock( &tod_as_bintime, lock_context );
400081c8: 92 10 00 19 mov %i1, %o1
_bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL;
400081cc: c4 3f bf f8 std %g2, [ %fp + -8 ]
400081d0: 40 00 06 cc call 40009d00 <_Timecounter_Set_clock>
400081d4: 90 07 bf f0 add %fp, -16, %o0
_Assert( _Watchdog_Is_valid_timespec( ts ) );
_Assert( ts->tv_sec >= 0 );
_Assert( !_Watchdog_Is_far_future_timespec( ts ) );
ticks = (uint64_t) ts->tv_sec;
400081d8: c6 06 00 00 ld [ %i0 ], %g3
<== NOT EXECUTED
400081dc: c4 06 20 04 ld [ %i0 + 4 ], %g2
<== NOT EXECUTED
ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS;
ticks |= (uint32_t) ts->tv_nsec;
400081e0: d6 06 20 08 ld [ %i0 + 8 ], %o3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400081e4: 91 d0 20 09 ta 9
<== NOT EXECUTED
Watchdog_Control *first;
cpu = _Per_CPU_Get_by_index( cpu_index );
header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_REALTIME ];
_ISR_lock_ISR_disable_and_acquire( &cpu->Watchdog.Lock, &lock_context );
400081e8: c2 27 bf ec st %g1, [ %fp + -20 ]
400081ec: 11 10 00 57 sethi %hi(0x40015c00), %o0
400081f0: 90 12 22 80 or %o0, 0x280, %o0 ! 40015e80 <_Per_CPU_Information>
400081f4: d2 02 20 44 ld [ %o0 + 0x44 ], %o1
first = _Watchdog_Header_first( header );
if ( first != NULL ) {
400081f8: 80 a2 60 00 cmp %o1, 0
400081fc: 02 80 00 09 be 40008220 <_TOD_Set+0x8c>
40008200: 95 30 a0 02 srl %g2, 2, %o2
ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS;
40008204: 87 28 e0 1e sll %g3, 0x1e, %g3
40008208: 85 28 a0 1e sll %g2, 0x1e, %g2
_Watchdog_Tickle(
4000820c: 98 07 bf ec add %fp, -20, %o4
40008210: 94 12 80 03 or %o2, %g3, %o2
40008214: 96 12 c0 02 or %o3, %g2, %o3
40008218: 40 00 15 9a call 4000d880 <_Watchdog_Do_tickle>
4000821c: 90 02 20 40 add %o0, 0x40, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008220: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008224: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008228: 01 00 00 00 nop
}
_ISR_lock_Release_and_ISR_enable( &cpu->Watchdog.Lock, &lock_context );
}
_TOD.is_set = true;
4000822c: 03 10 00 56 sethi %hi(0x40015800), %g1
40008230: 84 10 20 01 mov 1, %g2
40008234: c4 28 62 55 stb %g2, [ %g1 + 0x255 ]
}
40008238: 81 c7 e0 08 ret
4000823c: 81 e8 00 00 restore
40008180 <_TOD_Unlock>:
}
void _TOD_Unlock( void )
{
_API_Mutex_Unlock( &_TOD_Mutex );
40008180: 11 10 00 4f sethi %hi(0x40013c00), %o0
<== NOT EXECUTED
40008184: 90 12 23 04 or %o0, 0x304, %o0 ! 40013f04 <_TOD_Mutex>
<== NOT EXECUTED
40008188: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000818c: 7f ff ff d8 call 400080ec <_API_Mutex_Unlock>
<== NOT EXECUTED
40008190: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40007858 <_Terminate>:
void _Terminate(
Internal_errors_Source the_source,
Internal_errors_t the_error
)
{
40007858: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, error };
_User_extensions_Iterate(
4000785c: 94 10 20 00 clr %o2
40007860: 90 07 bf f8 add %fp, -8, %o0
User_extensions_Fatal_context ctx = { source, error };
40007864: f0 27 bf f8 st %i0, [ %fp + -8 ]
_User_extensions_Iterate(
40007868: 13 10 00 2f sethi %hi(0x4000bc00), %o1
User_extensions_Fatal_context ctx = { source, error };
4000786c: f2 27 bf fc st %i1, [ %fp + -4 ]
_User_extensions_Iterate(
40007870: 40 00 11 58 call 4000bdd0 <_User_extensions_Iterate>
40007874: 92 12 61 80 or %o1, 0x180, %o1
_User_extensions_Fatal( the_source, the_error );
_Internal_errors_What_happened.the_source = the_source;
40007878: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000787c: 84 10 61 30 or %g1, 0x130, %g2 ! 4001f530 <_Internal_errors_What_happened>
40007880: f0 20 61 30 st %i0, [ %g1 + 0x130 ]
40007884: 03 10 00 7d sethi %hi(0x4001f400), %g1
_Internal_errors_What_happened.the_error = the_error;
40007888: f2 20 a0 04 st %i1, [ %g2 + 4 ]
4000788c: 84 10 20 03 mov 3, %g2
_System_state_Set( SYSTEM_STATE_TERMINATED );
_SMP_Request_shutdown();
_CPU_Fatal_halt( the_source, the_error );
40007890: 92 10 00 19 mov %i1, %o1
40007894: 90 10 00 18 mov %i0, %o0
40007898: 40 00 42 96 call 400182f0 <_CPU_Fatal_halt>
4000789c: c4 20 61 38 st %g2, [ %g1 + 0x138 ]
400078a0: 01 00 00 00 nop
<== NOT EXECUTED
4000e984 <_Thread_Cancel>:
void _Thread_Cancel(
Thread_Control *the_thread,
Thread_Control *executing,
void *exit_value
)
{
4000e984: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e988: 91 d0 20 09 ta 9
<== NOT EXECUTED
previous = the_thread->Life.state;
4000e98c: c4 06 21 70 ld [ %i0 + 0x170 ], %g2
state |= set;
4000e990: 86 10 a0 04 or %g2, 4, %g3
the_thread->Life.exit_value = exit_value;
4000e994: f4 26 21 78 st %i2, [ %i0 + 0x178 ]
if (
4000e998: 80 88 a0 09 btst 9, %g2
4000e99c: 02 80 00 36 be 4000ea74 <_Thread_Cancel+0xf0>
4000e9a0: c6 26 21 70 st %g3, [ %i0 + 0x170 ]
disable_level = cpu_self->thread_dispatch_disable_level;
4000e9a4: c4 01 a0 18 ld [ %g6 + 0x18 ], %g2
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000e9a8: 84 00 a0 01 inc %g2
4000e9ac: c4 21 a0 18 st %g2, [ %g6 + 0x18 ]
);
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
priority = _Thread_Get_priority( executing );
if ( _States_Is_dormant( the_thread->current_state ) ) {
4000e9b0: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
4000e9b4: 80 a0 a0 00 cmp %g2, 0
4000e9b8: 06 80 00 1d bl 4000ea2c <_Thread_Cancel+0xa8>
<== NEVER TAKEN
4000e9bc: ba 10 00 06 mov %g6, %i5
pending_requests = the_thread->Life.pending_life_change_requests;
4000e9c0: c4 06 21 74 ld [ %i0 + 0x174 ], %g2
4000e9c4: c6 06 60 38 ld [ %i1 + 0x38 ], %g3
4000e9c8: f4 18 e0 18 ldd [ %g3 + 0x18 ], %i2
the_thread->Life.pending_life_change_requests = pending_requests + 1;
4000e9cc: 86 00 a0 01 add %g2, 1, %g3
if ( pending_requests == 0 ) {
4000e9d0: 80 a0 a0 00 cmp %g2, 0
4000e9d4: 02 80 00 44 be 4000eae4 <_Thread_Cancel+0x160>
<== ALWAYS TAKEN
4000e9d8: c6 26 21 74 st %g3, [ %i0 + 0x174 ]
4000e9dc: c2 27 bf fc st %g1, [ %fp + -4 ]
_Thread_State_release( the_thread, &lock_context );
_Thread_Finalize_life_change( the_thread, priority );
} else {
_Thread_Add_life_change_request( the_thread );
_Thread_Clear_state_locked( the_thread, STATES_SUSPENDED );
4000e9e0: 13 00 00 20 sethi %hi(0x8000), %o1
4000e9e4: 40 00 18 20 call 40014a64 <_Thread_Clear_state_locked>
4000e9e8: 90 10 00 18 mov %i0, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e9ec: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e9f0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e9f4: 01 00 00 00 nop
_Thread_State_release( the_thread, &lock_context );
_Thread_Raise_real_priority( the_thread, priority );
4000e9f8: 92 10 00 1a mov %i2, %o1
4000e9fc: 94 10 00 1b mov %i3, %o2
4000ea00: 7f ff fe da call 4000e568 <_Thread_Raise_real_priority>
4000ea04: 90 10 00 18 mov %i0, %o0
_Thread_Remove_life_change_request( the_thread );
4000ea08: 7f ff fe c3 call 4000e514 <_Thread_Remove_life_change_request>
4000ea0c: 90 10 00 18 mov %i0, %o0
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000ea10: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
if ( disable_level == 1 ) {
4000ea14: 80 a0 60 01 cmp %g1, 1
4000ea18: 02 80 00 0d be 4000ea4c <_Thread_Cancel+0xc8>
<== NEVER TAKEN
4000ea1c: 82 00 7f ff add %g1, -1, %g1
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000ea20: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
}
_Thread_Dispatch_enable( cpu_self );
}
4000ea24: 81 c7 e0 08 ret
4000ea28: 81 e8 00 00 restore
4000ea2c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ea30: 01 00 00 00 nop
_Thread_Make_zombie( the_thread );
4000ea34: 7f ff ff 09 call 4000e658 <_Thread_Make_zombie>
4000ea38: 90 10 00 18 mov %i0, %o0
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000ea3c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
if ( disable_level == 1 ) {
4000ea40: 80 a0 60 01 cmp %g1, 1
4000ea44: 12 bf ff f7 bne 4000ea20 <_Thread_Cancel+0x9c>
<== ALWAYS TAKEN
4000ea48: 82 00 7f ff add %g1, -1, %g1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000ea4c: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000ea50: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
<== NOT EXECUTED
4000ea54: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000ea58: 12 80 00 2f bne 4000eb14 <_Thread_Cancel+0x190>
<== NOT EXECUTED
4000ea5c: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4000ea60: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ea64: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ea68: 01 00 00 00 nop
<== NOT EXECUTED
4000ea6c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ea70: 81 e8 00 00 restore
<== NOT EXECUTED
4000ea74: c2 27 bf fc st %g1, [ %fp + -4 ]
4000ea78: 7f ff fe e0 call 4000e5f8 <_Thread_Change_life_locked.part.37>
4000ea7c: 90 10 00 18 mov %i0, %o0
disable_level = cpu_self->thread_dispatch_disable_level;
4000ea80: c4 01 a0 18 ld [ %g6 + 0x18 ], %g2
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000ea84: 84 00 a0 01 inc %g2
4000ea88: c4 21 a0 18 st %g2, [ %g6 + 0x18 ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000ea8c: ba 10 00 06 mov %g6, %i5
4000ea90: c6 06 60 38 ld [ %i1 + 0x38 ], %g3
if ( _States_Is_dormant( the_thread->current_state ) ) {
4000ea94: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
4000ea98: f4 18 e0 18 ldd [ %g3 + 0x18 ], %i2
4000ea9c: 80 a0 a0 00 cmp %g2, 0
4000eaa0: 06 bf ff e3 bl 4000ea2c <_Thread_Cancel+0xa8>
4000eaa4: c2 07 bf fc ld [ %fp + -4 ], %g1
pending_requests = the_thread->Life.pending_life_change_requests;
4000eaa8: c4 06 21 74 ld [ %i0 + 0x174 ], %g2
the_thread->Life.pending_life_change_requests = pending_requests + 1;
4000eaac: 86 00 a0 01 add %g2, 1, %g3
if ( pending_requests == 0 ) {
4000eab0: 80 a0 a0 00 cmp %g2, 0
4000eab4: 02 80 00 12 be 4000eafc <_Thread_Cancel+0x178>
<== ALWAYS TAKEN
4000eab8: c6 26 21 74 st %g3, [ %i0 + 0x174 ]
4000eabc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000eac0: 01 00 00 00 nop
_Thread_queue_Extract_with_proxy( the_thread );
4000eac4: 40 00 18 5d call 40014c38 <_Thread_queue_Extract_with_proxy>
4000eac8: 90 10 00 18 mov %i0, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000eacc: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000ead0: c2 27 bf fc st %g1, [ %fp + -4 ]
4000ead4: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
4000ead8: 40 00 02 40 call 4000f3d8 <_Watchdog_Remove>
4000eadc: 92 06 20 68 add %i0, 0x68, %o1
4000eae0: 30 bf ff c3 b,a 4000e9ec <_Thread_Cancel+0x68>
4000eae4: c2 27 bf fc st %g1, [ %fp + -4 ]
_Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING );
4000eae8: 13 00 00 80 sethi %hi(0x20000), %o1
4000eaec: 40 00 00 65 call 4000ec80 <_Thread_Set_state_locked>
4000eaf0: 90 10 00 18 mov %i0, %o0
4000eaf4: 10 bf ff ba b 4000e9dc <_Thread_Cancel+0x58>
4000eaf8: c2 07 bf fc ld [ %fp + -4 ], %g1
4000eafc: c2 27 bf fc st %g1, [ %fp + -4 ]
4000eb00: 13 00 00 80 sethi %hi(0x20000), %o1
4000eb04: 40 00 00 5f call 4000ec80 <_Thread_Set_state_locked>
4000eb08: 90 10 00 18 mov %i0, %o0
4000eb0c: 10 bf ff ec b 4000eabc <_Thread_Cancel+0x138>
4000eb10: c2 07 bf fc ld [ %fp + -4 ], %g1
_Thread_Do_dispatch( cpu_self, level );
4000eb14: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
4000eb18: 40 00 17 f5 call 40014aec <_Thread_Do_dispatch>
<== NOT EXECUTED
4000eb1c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000eb20: 10 bf ff d1 b 4000ea64 <_Thread_Cancel+0xe0>
<== NOT EXECUTED
4000eb24: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
4000b91c <_Thread_Change_life>:
Thread_Life_state _Thread_Change_life(
Thread_Life_state clear,
Thread_Life_state set,
Thread_Life_state ignore
)
{
4000b91c: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b920: 91 d0 20 09 ta 9
<== NOT EXECUTED
executing = _Thread_Executing;
4000b924: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
previous = the_thread->Life.state;
4000b928: fa 02 21 70 ld [ %o0 + 0x170 ], %i5
state &= ~clear;
4000b92c: 84 2f 40 18 andn %i5, %i0, %g2
state |= set;
4000b930: b2 16 40 02 or %i1, %g2, %i1
the_thread->Life.state = state;
4000b934: f2 22 21 70 st %i1, [ %o0 + 0x170 ]
state &= ~ignore;
4000b938: b2 2e 40 1a andn %i1, %i2, %i1
if (
4000b93c: 80 8e 60 09 btst 9, %i1
4000b940: 12 80 00 07 bne 4000b95c <_Thread_Change_life+0x40>
4000b944: 80 8e 60 06 btst 6, %i1
&& _Thread_Is_life_changing( state )
4000b948: 02 80 00 05 be 4000b95c <_Thread_Change_life+0x40>
4000b94c: 01 00 00 00 nop
4000b950: 7f ff ff 10 call 4000b590 <_Thread_Change_life_locked.part.37>
4000b954: c2 27 bf fc st %g1, [ %fp + -4 ]
4000b958: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000b95c: c4 01 a0 18 ld [ %g6 + 0x18 ], %g2
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000b960: 84 00 a0 01 inc %g2
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000b964: 90 10 00 06 mov %g6, %o0
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000b968: c4 21 a0 18 st %g2, [ %g6 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b96c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b970: 01 00 00 00 nop
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000b974: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
if ( disable_level == 1 ) {
4000b978: 80 a0 60 01 cmp %g1, 1
4000b97c: 02 80 00 06 be 4000b994 <_Thread_Change_life+0x78>
4000b980: 82 00 7f ff add %g1, -1, %g1
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
_Thread_State_release( executing, &lock_context );
_Thread_Dispatch_enable( cpu_self );
return previous;
}
4000b984: b0 10 00 1d mov %i5, %i0
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000b988: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
4000b98c: 81 c7 e0 08 ret
4000b990: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b994: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000b998: c4 09 a0 1c ldub [ %g6 + 0x1c ], %g2
4000b99c: 80 a0 a0 00 cmp %g2, 0
4000b9a0: 12 80 00 07 bne 4000b9bc <_Thread_Change_life+0xa0>
4000b9a4: 92 10 00 01 mov %g1, %o1
cpu_self->thread_dispatch_disable_level = 0;
4000b9a8: c0 21 a0 18 clr [ %g6 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b9ac: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b9b0: 01 00 00 00 nop
4000b9b4: 81 c7 e0 08 ret
4000b9b8: 91 e8 00 1d restore %g0, %i5, %o0
_Thread_Do_dispatch( cpu_self, level );
4000b9bc: 40 00 0b 06 call 4000e5d4 <_Thread_Do_dispatch>
4000b9c0: c2 27 bf fc st %g1, [ %fp + -4 ]
4000b9c4: 10 bf ff fa b 4000b9ac <_Thread_Change_life+0x90>
<== NOT EXECUTED
4000b9c8: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
4000e57c <_Thread_Clear_state>:
States_Control _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
4000e57c: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e580: 91 d0 20 09 ta 9
<== NOT EXECUTED
previous_state = the_thread->current_state;
4000e584: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
if ( ( previous_state & state ) != 0 ) {
4000e588: 80 8e 40 1d btst %i1, %i5
4000e58c: 02 80 00 06 be 4000e5a4 <_Thread_Clear_state+0x28>
4000e590: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
4000e594: b2 2f 40 19 andn %i5, %i1, %i1
if ( _States_Is_ready( next_state ) ) {
4000e598: 80 a6 60 00 cmp %i1, 0
4000e59c: 02 80 00 06 be 4000e5b4 <_Thread_Clear_state+0x38>
4000e5a0: f2 26 20 1c st %i1, [ %i0 + 0x1c ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e5a4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e5a8: 01 00 00 00 nop
_Thread_State_acquire( the_thread, &lock_context );
previous_state = _Thread_Clear_state_locked( the_thread, state );
_Thread_State_release( the_thread, &lock_context );
return previous_state;
}
4000e5ac: 81 c7 e0 08 ret
4000e5b0: 91 e8 00 1d restore %g0, %i5, %o0
4000e5b4: c2 27 bf fc st %g1, [ %fp + -4 ]
4000e5b8: 7f ff ff dc call 4000e528 <_Thread_Clear_state_locked.part.10>
4000e5bc: 90 10 00 18 mov %i0, %o0
4000e5c0: c2 07 bf fc ld [ %fp + -4 ], %g1
4000e5c4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e5c8: 01 00 00 00 nop
4000e5cc: 81 c7 e0 08 ret
4000e5d0: 91 e8 00 1d restore %g0, %i5, %o0
4000e54c <_Thread_Clear_state_locked>:
{
4000e54c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
previous_state = the_thread->current_state;
4000e550: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
<== NOT EXECUTED
if ( ( previous_state & state ) != 0 ) {
4000e554: 80 8f 40 19 btst %i5, %i1
<== NOT EXECUTED
4000e558: 02 80 00 07 be 4000e574 <_Thread_Clear_state_locked+0x28>
<== NOT EXECUTED
4000e55c: b2 2f 40 19 andn %i5, %i1, %i1
<== NOT EXECUTED
if ( _States_Is_ready( next_state ) ) {
4000e560: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000e564: 12 80 00 04 bne 4000e574 <_Thread_Clear_state_locked+0x28>
<== NOT EXECUTED
4000e568: f2 26 20 1c st %i1, [ %i0 + 0x1c ]
<== NOT EXECUTED
4000e56c: 7f ff ff ef call 4000e528 <_Thread_Clear_state_locked.part.10>
<== NOT EXECUTED
4000e570: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
4000e574: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e578: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
4000eb3c <_Thread_Close>:
Thread_Control *the_thread,
Thread_Control *executing,
Thread_Close_context *context
)
{
context->cancel = the_thread;
4000eb3c: d0 22 a0 24 st %o0, [ %o2 + 0x24 ]
queue_context->enqueue_callout = enqueue_callout;
4000eb40: 03 10 00 3a sethi %hi(0x4000e800), %g1
4000eb44: 82 10 63 28 or %g1, 0x328, %g1 ! 4000eb28 <_Thread_Close_enqueue_callout>
4000eb48: c2 22 a0 08 st %g1, [ %o2 + 8 ]
{
4000eb4c: 96 10 00 0a mov %o2, %o3
executing->Wait.return_argument = NULL;
4000eb50: c0 22 60 40 clr [ %o1 + 0x40 ]
queue_context->thread_state = thread_state;
4000eb54: 03 00 00 10 sethi %hi(0x4000), %g1
4000eb58: c2 22 e0 04 st %g1, [ %o3 + 4 ]
{
4000eb5c: 94 10 00 09 mov %o1, %o2
_Thread_queue_Enqueue(
4000eb60: 90 02 20 10 add %o0, 0x10, %o0
4000eb64: 13 10 00 8d sethi %hi(0x40023400), %o1
4000eb68: 92 12 61 a4 or %o1, 0x1a4, %o1 ! 400235a4 <_Thread_queue_Operations_priority>
4000eb6c: 82 13 c0 00 mov %o7, %g1
4000eb70: 7f ff fb 30 call 4000d830 <_Thread_queue_Enqueue>
4000eb74: 9e 10 40 00 mov %g1, %o7
4000ee70 <_Thread_Continue>:
#include <rtems/score/threadimpl.h>
#include <rtems/score/status.h>
void _Thread_Continue( Thread_Control *the_thread, Status_Control status )
{
4000ee70: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
queue_context->Priority.update_count = 0;
4000ee74: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000ee78: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
4000ee7c: c2 27 bf dc st %g1, [ %fp + -36 ]
4000ee80: fa 06 20 50 ld [ %i0 + 0x50 ], %i5
_Thread_queue_Context_clear_priority_updates( &queue_context );
_Thread_Wait_acquire( the_thread, &queue_context );
wait_flags = _Thread_Wait_flags_get( the_thread );
if ( ( wait_flags & THREAD_WAIT_STATE_READY_AGAIN ) == 0 ) {
4000ee84: 80 8f 60 04 btst 4, %i5
4000ee88: 12 80 00 20 bne 4000ef08 <_Thread_Continue+0x98>
4000ee8c: 92 10 00 18 mov %i0, %o1
( *the_thread->Wait.operations->extract )(
4000ee90: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
4000ee94: c2 00 60 08 ld [ %g1 + 8 ], %g1
4000ee98: d0 06 20 54 ld [ %i0 + 0x54 ], %o0
4000ee9c: 9f c0 40 00 call %g1
4000eea0: 94 07 bf dc add %fp, -36, %o2
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4000eea4: 03 10 00 8d sethi %hi(0x40023400), %g1
4000eea8: 82 10 61 cc or %g1, 0x1cc, %g1 ! 400235cc <_Thread_queue_Operations_default>
4000eeac: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
_Thread_Wait_cancel( the_thread, &queue_context );
the_thread->Wait.return_code = status;
wait_class = wait_flags & THREAD_WAIT_CLASS_MASK;
4000eeb0: 03 00 00 3f sethi %hi(0xfc00), %g1
4000eeb4: 82 10 63 00 or %g1, 0x300, %g1 ! ff00 <_Configuration_Interrupt_stack_size+0xef00>
if ( success ) {
4000eeb8: c4 06 20 50 ld [ %i0 + 0x50 ], %g2
4000eebc: ba 0f 40 01 and %i5, %g1, %i5
the_thread->Wait.queue = NULL;
4000eec0: c0 26 20 54 clr [ %i0 + 0x54 ]
ready_again = wait_class | THREAD_WAIT_STATE_READY_AGAIN;
success = _Thread_Wait_flags_try_change_release(
4000eec4: 82 17 60 01 or %i5, 1, %g1
the_thread->Wait.return_code = status;
4000eec8: f4 26 20 4c st %i2, [ %i0 + 0x4c ]
ready_again = wait_class | THREAD_WAIT_STATE_READY_AGAIN;
4000eecc: ba 17 60 04 or %i5, 4, %i5
if ( success ) {
4000eed0: 80 a0 40 02 cmp %g1, %g2
4000eed4: 02 80 00 0d be 4000ef08 <_Thread_Continue+0x98>
4000eed8: fa 26 20 50 st %i5, [ %i0 + 0x50 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000eedc: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000eee0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000eee4: 01 00 00 00 nop
} else {
unblock = false;
}
_Thread_Wait_release( the_thread, &queue_context );
_Thread_Priority_update( &queue_context );
4000eee8: 40 00 16 be call 400149e0 <_Thread_Priority_update>
4000eeec: 90 07 bf dc add %fp, -36, %o0
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4000eef0: 90 10 00 18 mov %i0, %o0
4000eef4: 13 0c 00 57 sethi %hi(0x30015c00), %o1
4000eef8: 40 00 16 e7 call 40014a94 <_Thread_Clear_state>
4000eefc: 92 12 63 ff or %o1, 0x3ff, %o1 ! 30015fff <RAM_SIZE+0x2fc15fff>
if ( !_Objects_Is_local_id( the_thread->Object.id ) ) {
_Thread_MP_Free_proxy( the_thread );
}
#endif
}
}
4000ef00: 81 c7 e0 08 ret
4000ef04: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000ef08: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ef0c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ef10: 01 00 00 00 nop
_Thread_Priority_update( &queue_context );
4000ef14: 40 00 16 b3 call 400149e0 <_Thread_Priority_update>
4000ef18: 90 07 bf dc add %fp, -36, %o0
}
4000ef1c: 81 c7 e0 08 ret
4000ef20: 81 e8 00 00 restore
4000a2b0 <_Thread_Create_idle>:
_Scheduler_Start_idle( scheduler, idle, cpu );
_User_extensions_Thread_start( idle );
}
void _Thread_Create_idle( void )
{
4000a2b0: 9d e3 bf 70 save %sp, -144, %sp
<== NOT EXECUTED
4000a2b4: 03 10 00 7d sethi %hi(0x4001f400), %g1
<== NOT EXECUTED
4000a2b8: 84 10 20 01 mov 1, %g2
return maximum_internal_threads;
}
RTEMS_INLINE_ROUTINE Thread_Control *_Thread_Internal_allocate( void )
{
return (Thread_Control *)
4000a2bc: 31 10 00 7e sethi %hi(0x4001f800), %i0
4000a2c0: c4 20 61 38 st %g2, [ %g1 + 0x138 ]
4000a2c4: 7f ff fa ac call 40008d74 <_Objects_Allocate_unprotected>
4000a2c8: 90 16 21 94 or %i0, 0x194, %o0
_Stack_Ensure_minimum( rtems_configuration_get_idle_task_stack_size() ),
4000a2cc: 37 10 00 63 sethi %hi(0x40018c00), %i3
4000a2d0: 03 10 00 6c sethi %hi(0x4001b000), %g1
4000a2d4: b6 16 e0 e8 or %i3, 0xe8, %i3
4000a2d8: c2 00 63 40 ld [ %g1 + 0x340 ], %g1
4000a2dc: f4 06 e0 20 ld [ %i3 + 0x20 ], %i2
4000a2e0: 80 a6 80 01 cmp %i2, %g1
4000a2e4: 1a 80 00 03 bcc 4000a2f0 <_Thread_Create_idle+0x40>
<== ALWAYS TAKEN
4000a2e8: b8 10 00 08 mov %o0, %i4
4000a2ec: b4 10 00 01 mov %g1, %i2
<== NOT EXECUTED
_Thread_Initialize(
4000a2f0: 3b 10 00 63 sethi %hi(0x40018c00), %i5
4000a2f4: ba 17 61 c8 or %i5, 0x1c8, %i5 ! 40018dc8 <_Scheduler_Table>
return ( *scheduler->Operations.map_priority )( scheduler, priority );
4000a2f8: d4 07 60 44 ld [ %i5 + 0x44 ], %o2
4000a2fc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000a300: d2 07 60 40 ld [ %i5 + 0x40 ], %o1
4000a304: 9f c0 40 00 call %g1
4000a308: 90 10 00 1d mov %i5, %o0
4000a30c: d0 3f bf f0 std %o0, [ %fp + -16 ]
4000a310: 82 07 bf fc add %fp, -4, %g1
4000a314: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
4000a318: b2 10 20 01 mov 1, %i1
4000a31c: c2 07 bf f0 ld [ %fp + -16 ], %g1
4000a320: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000a324: 98 10 00 1a mov %i2, %o4
4000a328: c2 07 bf f4 ld [ %fp + -12 ], %g1
4000a32c: f2 23 a0 64 st %i1, [ %sp + 0x64 ]
4000a330: 9a 10 20 00 clr %o5
4000a334: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
4000a338: 03 12 51 13 sethi %hi(0x49444c00), %g1
4000a33c: c0 23 a0 70 clr [ %sp + 0x70 ]
4000a340: 82 10 60 45 or %g1, 0x45, %g1
4000a344: c0 23 a0 6c clr [ %sp + 0x6c ]
4000a348: 96 10 20 00 clr %o3
4000a34c: c0 23 a0 68 clr [ %sp + 0x68 ]
4000a350: 94 10 00 1d mov %i5, %o2
4000a354: 92 10 00 1c mov %i4, %o1
4000a358: 90 16 21 94 or %i0, 0x194, %o0
4000a35c: 40 00 00 62 call 4000a4e4 <_Thread_Initialize>
4000a360: c2 27 bf fc st %g1, [ %fp + -4 ]
idle->Start.Entry.Kinds.Idle.entry = rtems_configuration_get_idle_task();
4000a364: c4 06 e0 1c ld [ %i3 + 0x1c ], %g2
cpu->executing = idle;
4000a368: 37 10 00 7e sethi %hi(0x4001f800), %i3
4000a36c: b6 16 e1 40 or %i3, 0x140, %i3 ! 4001f940 <_Per_CPU_Information>
4000a370: f8 26 e0 20 st %i4, [ %i3 + 0x20 ]
idle->Start.Entry.adaptor = _Thread_Entry_adaptor_idle;
4000a374: 03 10 00 28 sethi %hi(0x4000a000), %g1
cpu->heir =
4000a378: f8 26 e0 24 st %i4, [ %i3 + 0x24 ]
idle->Start.Entry.adaptor = _Thread_Entry_adaptor_idle;
4000a37c: 82 10 63 c0 or %g1, 0x3c0, %g1
idle->is_idle = true;
4000a380: f2 2f 20 88 stb %i1, [ %i4 + 0x88 ]
_Thread_Load_environment( idle );
4000a384: 90 10 00 1c mov %i4, %o0
idle->Start.Entry.adaptor = _Thread_Entry_adaptor_idle;
4000a388: c2 27 20 a0 st %g1, [ %i4 + 0xa0 ]
_User_extensions_Iterate(
4000a38c: 33 10 00 2f sethi %hi(0x4000bc00), %i1
idle->Start.Entry.Kinds.Idle.entry = rtems_configuration_get_idle_task();
4000a390: c4 27 20 a4 st %g2, [ %i4 + 0xa4 ]
_Thread_Load_environment( idle );
4000a394: 40 00 01 14 call 4000a7e4 <_Thread_Load_environment>
4000a398: b4 10 20 00 clr %i2
idle->current_state = STATES_READY;
4000a39c: c0 27 20 1c clr [ %i4 + 0x1c ]
( *scheduler->Operations.start_idle )( scheduler, the_thread, cpu );
4000a3a0: 94 10 00 1b mov %i3, %o2
4000a3a4: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
4000a3a8: 92 10 00 1c mov %i4, %o1
4000a3ac: 90 10 00 1d mov %i5, %o0
4000a3b0: 9f c0 40 00 call %g1
4000a3b4: b0 10 00 1c mov %i4, %i0
4000a3b8: 40 00 06 86 call 4000bdd0 <_User_extensions_Iterate>
4000a3bc: 93 ee 60 f0 restore %i1, 0xf0, %o1
4000b344 <_Thread_Dispatch>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b344: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000b348: 92 10 00 01 mov %g1, %o1
_ISR_Local_disable( level );
cpu_self = _Per_CPU_Get();
if ( cpu_self->dispatch_necessary ) {
4000b34c: c4 09 a0 1c ldub [ %g6 + 0x1c ], %g2
4000b350: 80 a0 a0 00 cmp %g2, 0
4000b354: 12 80 00 06 bne 4000b36c <_Thread_Dispatch+0x28>
<== NEVER TAKEN
4000b358: 90 10 00 06 mov %g6, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b35c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b360: 01 00 00 00 nop
cpu_self->thread_dispatch_disable_level = 1;
_Thread_Do_dispatch( cpu_self, level );
} else {
_ISR_Local_enable( level );
}
}
4000b364: 81 c3 e0 08 retl
4000b368: 01 00 00 00 nop
cpu_self->thread_dispatch_disable_level = 1;
4000b36c: 82 10 20 01 mov 1, %g1 ! 1 <_TLS_Alignment>
<== NOT EXECUTED
4000b370: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
4000b374: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000b378: 7f ff ff ab call 4000b224 <_Thread_Do_dispatch>
<== NOT EXECUTED
4000b37c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000e6f4 <_Thread_Dispatch_direct>:
_ISR_Local_enable( level );
}
}
void _Thread_Dispatch_direct( Per_CPU_Control *cpu_self )
{
4000e6f4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
ISR_Level level;
if ( cpu_self->thread_dispatch_disable_level != 1 ) {
4000e6f8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
4000e6fc: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000e700: 12 80 00 05 bne 4000e714 <_Thread_Dispatch_direct+0x20>
<== NOT EXECUTED
4000e704: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e708: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_DISABLE_LEVEL );
}
_ISR_Local_disable( level );
_Thread_Do_dispatch( cpu_self, level );
4000e70c: 7f ff ff b2 call 4000e5d4 <_Thread_Do_dispatch>
4000e710: 93 e8 00 01 restore %g0, %g1, %o1
_Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_DISABLE_LEVEL );
4000e714: 7f ff e4 64 call 400078a4 <_Internal_error>
4000e718: 90 10 20 1e mov 0x1e, %o0
4000e71c: 01 00 00 00 nop
<== NOT EXECUTED
4000e5d4 <_Thread_Do_dispatch>:
_Thread_State_release( executing, &lock_context );
}
void _Thread_Do_dispatch( Per_CPU_Control *cpu_self, ISR_Level level )
{
4000e5d4: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
) {
_Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT );
}
#endif
executing = cpu_self->executing;
4000e5d8: f6 06 20 20 ld [ %i0 + 0x20 ], %i3
{
4000e5dc: 82 10 00 19 mov %i1, %g1
/*
* Since heir and executing are not the same, we need to do a real
* context switch.
*/
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
heir->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice();
4000e5e0: 23 10 00 63 sethi %hi(0x40018c00), %l1
return _Chain_Immutable_head( the_chain )->next;
4000e5e4: 33 10 00 6d sethi %hi(0x4001b400), %i1
4000e5e8: a2 14 60 e8 or %l1, 0xe8, %l1
4000e5ec: b2 16 62 3c or %i1, 0x23c, %i1
_ISR_Local_enable( level );
_User_extensions_Thread_switch( executing, heir );
_Thread_Save_fp( executing );
_Context_Switch( &executing->Registers, &heir->Registers );
4000e5f0: a0 06 e0 f0 add %i3, 0xf0, %l0
if ( node != tail ) {
4000e5f4: b4 06 60 04 add %i1, 4, %i2
heir = cpu_self->heir;
4000e5f8: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
cpu_self->dispatch_necessary = false;
4000e5fc: c0 2e 20 1c clrb [ %i0 + 0x1c ]
if ( heir == executing )
4000e600: 80 a6 c0 1c cmp %i3, %i4
4000e604: 02 80 00 1f be 4000e680 <_Thread_Do_dispatch+0xac>
4000e608: f8 26 20 20 st %i4, [ %i0 + 0x20 ]
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
4000e60c: c4 07 20 90 ld [ %i4 + 0x90 ], %g2
4000e610: 80 a0 a0 01 cmp %g2, 1
4000e614: 12 80 00 04 bne 4000e624 <_Thread_Do_dispatch+0x50>
4000e618: 01 00 00 00 nop
heir->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice();
4000e61c: c4 04 60 18 ld [ %l1 + 0x18 ], %g2
<== NOT EXECUTED
4000e620: c4 27 20 8c st %g2, [ %i4 + 0x8c ]
<== NOT EXECUTED
4000e624: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e628: 01 00 00 00 nop
4000e62c: fa 06 40 00 ld [ %i1 ], %i5
4000e630: 80 a7 40 1a cmp %i5, %i2
4000e634: 02 80 00 0b be 4000e660 <_Thread_Do_dispatch+0x8c>
4000e638: 92 07 20 f0 add %i4, 0xf0, %o1
(*extension->thread_switch)( executing, heir );
4000e63c: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000e640: 92 10 00 1c mov %i4, %o1
4000e644: 9f c0 40 00 call %g1
4000e648: 90 10 00 1b mov %i3, %o0
4000e64c: fa 07 40 00 ld [ %i5 ], %i5
while ( node != tail ) {
4000e650: 80 a7 40 1a cmp %i5, %i2
4000e654: 32 bf ff fb bne,a 4000e640 <_Thread_Do_dispatch+0x6c>
4000e658: c2 07 60 08 ld [ %i5 + 8 ], %g1
_Context_Switch( &executing->Registers, &heir->Registers );
4000e65c: 92 07 20 f0 add %i4, 0xf0, %o1
4000e660: 7f ff f8 6e call 4000c818 <_CPU_Context_switch>
4000e664: 90 10 00 10 mov %l0, %o0
/*
* We have to obtain this value again after the context switch since the
* heir thread may have migrated from another processor. Values from the
* stack or non-volatile registers reflect the old execution environment.
*/
cpu_self = _Per_CPU_Get();
4000e668: b0 10 00 06 mov %g6, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e66c: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_Local_disable( level );
} while ( cpu_self->dispatch_necessary );
4000e670: c4 09 a0 1c ldub [ %g6 + 0x1c ], %g2
4000e674: 80 a0 a0 00 cmp %g2, 0
4000e678: 32 bf ff e1 bne,a 4000e5fc <_Thread_Do_dispatch+0x28>
4000e67c: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
post_switch:
_Assert( cpu_self->thread_dispatch_disable_level == 1 );
cpu_self->thread_dispatch_disable_level = 0;
4000e680: c0 26 20 18 clr [ %i0 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e684: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e688: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e68c: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( lock_context );
4000e690: c2 27 bf fc st %g1, [ %fp + -4 ]
4000e694: d2 06 e0 e0 ld [ %i3 + 0xe0 ], %o1
return &the_chain->Tail.Node;
4000e698: ba 06 e0 e4 add %i3, 0xe4, %i5
if ( !_Chain_Is_empty(the_chain))
4000e69c: 80 a2 40 1d cmp %o1, %i5
4000e6a0: 02 80 00 10 be 4000e6e0 <_Thread_Do_dispatch+0x10c>
4000e6a4: b8 06 e0 e0 add %i3, 0xe0, %i4
new_first = old_first->next;
4000e6a8: c2 02 40 00 ld [ %o1 ], %g1
head->next = new_first;
4000e6ac: c2 26 e0 e0 st %g1, [ %i3 + 0xe0 ]
( *action->handler )( executing, action, &lock_context );
4000e6b0: 94 07 bf fc add %fp, -4, %o2
new_first->previous = head;
4000e6b4: f8 20 60 04 st %i4, [ %g1 + 4 ]
node->next = NULL;
4000e6b8: c0 22 40 00 clr [ %o1 ]
4000e6bc: c2 02 60 08 ld [ %o1 + 8 ], %g1
4000e6c0: 9f c0 40 00 call %g1
4000e6c4: 90 10 00 1b mov %i3, %o0
4000e6c8: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000e6cc: c2 27 bf fc st %g1, [ %fp + -4 ]
return _Chain_Immutable_head( the_chain )->next;
4000e6d0: d2 06 e0 e0 ld [ %i3 + 0xe0 ], %o1
if ( !_Chain_Is_empty(the_chain))
4000e6d4: 80 a7 40 09 cmp %i5, %o1
4000e6d8: 32 bf ff f5 bne,a 4000e6ac <_Thread_Do_dispatch+0xd8> <== NEVER TAKEN
4000e6dc: c2 02 40 00 ld [ %o1 ], %g1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e6e0: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e6e4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e6e8: 01 00 00 00 nop
_Profiling_Thread_dispatch_enable( cpu_self, 0 );
_ISR_Local_enable( level );
_Thread_Run_post_switch_actions( executing );
}
4000e6ec: 81 c7 e0 08 ret
4000e6f0: 81 e8 00 00 restore
4000a3c0 <_Thread_Entry_adaptor_idle>:
#endif
#include <rtems/score/threadimpl.h>
void _Thread_Entry_adaptor_idle( Thread_Control *executing )
{
4000a3c0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
const Thread_Entry_idle *idle = &executing->Start.Entry.Kinds.Idle;
( *idle->entry )( 0 );
4000a3c4: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1
4000a3c8: 9f c0 40 00 call %g1
4000a3cc: 90 10 20 00 clr %o0
}
4000a3d0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a3d4: 81 e8 00 00 restore
<== NOT EXECUTED
4000a3d8 <_Thread_Entry_adaptor_numeric>:
#endif
#include <rtems/score/threadimpl.h>
void _Thread_Entry_adaptor_numeric( Thread_Control *executing )
{
4000a3d8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
const Thread_Entry_numeric *numeric = &executing->Start.Entry.Kinds.Numeric;
( *numeric->entry )( numeric->argument );
4000a3dc: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1
<== NOT EXECUTED
4000a3e0: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000a3e4: d0 06 20 a8 ld [ %i0 + 0xa8 ], %o0
}
4000a3e8: 81 c7 e0 08 ret
4000a3ec: 81 e8 00 00 restore
400253b0 <_Thread_Entry_adaptor_pointer>:
#endif
#include <rtems/score/threadimpl.h>
void _Thread_Entry_adaptor_pointer( Thread_Control *executing )
{
400253b0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
const Thread_Entry_pointer *pointer = &executing->Start.Entry.Kinds.Pointer;
executing->Wait.return_argument = ( *pointer->entry )( pointer->argument );
400253b4: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1
<== NOT EXECUTED
400253b8: 9f c0 40 00 call %g1
<== NOT EXECUTED
400253bc: d0 06 20 a8 ld [ %i0 + 0xa8 ], %o0
400253c0: d0 26 20 40 st %o0, [ %i0 + 0x40 ]
}
400253c4: 81 c7 e0 08 ret
400253c8: 81 e8 00 00 restore
4000eb78 <_Thread_Exit>:
void _Thread_Exit(
Thread_Control *executing,
Thread_Life_state set,
void *exit_value
)
{
4000eb78: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000eb7c: 91 d0 20 09 ta 9
<== NOT EXECUTED
state |= set;
4000eb80: c4 06 21 70 ld [ %i0 + 0x170 ], %g2
4000eb84: b2 16 40 02 or %i1, %g2, %i1
the_thread->Life.exit_value = exit_value;
4000eb88: f4 26 21 78 st %i2, [ %i0 + 0x178 ]
&& _Thread_Is_life_changing( state )
4000eb8c: 80 8e 60 06 btst 6, %i1
4000eb90: 02 80 00 06 be 4000eba8 <_Thread_Exit+0x30>
<== NEVER TAKEN
4000eb94: f2 26 21 70 st %i1, [ %i0 + 0x170 ]
4000eb98: c2 27 bf fc st %g1, [ %fp + -4 ]
4000eb9c: 7f ff fe 97 call 4000e5f8 <_Thread_Change_life_locked.part.37>
4000eba0: 90 10 00 18 mov %i0, %o0
4000eba4: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000eba8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ebac: 01 00 00 00 nop
0,
set,
THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED
);
_Thread_State_release( executing, &lock_context );
}
4000ebb0: 81 c7 e0 08 ret
4000ebb4: 81 e8 00 00 restore
4000a3f0 <_Thread_Get>:
ISR_lock_Context *lock_context
)
{
Objects_Information *information;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
4000a3f0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000a3f4: 02 80 00 11 be 4000a438 <_Thread_Get+0x48>
<== NEVER TAKEN
4000a3f8: 83 32 20 18 srl %o0, 0x18, %g1
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
4000a3fc: 82 08 60 07 and %g1, 7, %g1
if ( !the_api || the_api > OBJECTS_APIS_LAST )
4000a400: 84 00 7f ff add %g1, -1, %g2
4000a404: 80 a0 a0 02 cmp %g2, 2
4000a408: 18 80 00 10 bgu 4000a448 <_Thread_Get+0x58>
4000a40c: 83 28 60 02 sll %g1, 2, %g1
return _Objects_Information_table[ the_api ][ 1 ];
4000a410: 05 10 00 66 sethi %hi(0x40019800), %g2
4000a414: 84 10 a0 c0 or %g2, 0xc0, %g2 ! 400198c0 <_Objects_Information_table>
4000a418: c2 00 80 01 ld [ %g2 + %g1 ], %g1
4000a41c: d4 00 60 04 ld [ %g1 + 4 ], %o2
_ISR_lock_ISR_disable( lock_context );
return _Thread_Executing;
}
information = _Thread_Get_objects_information( id );
if ( information == NULL ) {
4000a420: 80 a2 a0 00 cmp %o2, 0
4000a424: 02 80 00 09 be 4000a448 <_Thread_Get+0x58>
4000a428: 01 00 00 00 nop
return NULL;
}
return (Thread_Control *)
4000a42c: 82 13 c0 00 mov %o7, %g1
4000a430: 40 00 0e ff call 4000e02c <_Objects_Get>
4000a434: 9e 10 40 00 mov %g1, %o7
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000a438: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( lock_context );
4000a43c: c2 22 40 00 st %g1, [ %o1 ]
return _Thread_Executing;
4000a440: 81 c3 e0 08 retl
4000a444: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
_Objects_Get( id, lock_context, information );
}
4000a448: 81 c3 e0 08 retl
4000a44c: 90 10 20 00 clr %o0
4000ba04 <_Thread_Get_CPU_time_used>:
void _Thread_Get_CPU_time_used(
Thread_Control *the_thread,
Timestamp_Control *cpu_time_used
)
{
4000ba04: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
4000ba08: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Thread_State_acquire( the_thread, &state_lock_context );
scheduler = _Thread_Scheduler_get_home( the_thread );
_Scheduler_Acquire_critical( scheduler, &scheduler_lock_context );
if ( _Thread_Is_scheduled( the_thread ) ) {
4000ba0c: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2
4000ba10: 80 a6 00 02 cmp %i0, %g2
4000ba14: 02 80 00 08 be 4000ba34 <_Thread_Get_CPU_time_used+0x30>
4000ba18: ba 10 00 06 mov %g6, %i5
4000ba1c: c4 1e 20 98 ldd [ %i0 + 0x98 ], %g2
<== NOT EXECUTED
_Thread_Update_CPU_time_used( the_thread, _Thread_Get_CPU( the_thread ) );
}
*cpu_time_used = the_thread->cpu_time_used;
4000ba20: c4 3e 40 00 std %g2, [ %i1 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ba24: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ba28: 01 00 00 00 nop
_Scheduler_Release_critical( scheduler, &scheduler_lock_context );
_Thread_State_release( the_thread, &state_lock_context );
}
4000ba2c: 81 c7 e0 08 ret
4000ba30: 81 e8 00 00 restore
last = cpu->cpu_usage_timestamp;
4000ba34: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0
4000ba38: 7f ff f8 07 call 40009a54 <_Timecounter_Sbinuptime>
4000ba3c: c2 27 bf fc st %g1, [ %fp + -4 ]
4000ba40: d0 3f 60 28 std %o0, [ %i5 + 0x28 ]
<== NOT EXECUTED
*_result = *_end - *_start;
4000ba44: b6 a2 40 11 subcc %o1, %l1, %i3
<== NOT EXECUTED
*_time += *_add;
4000ba48: f8 1e 20 98 ldd [ %i0 + 0x98 ], %i4
<== NOT EXECUTED
*_result = *_end - *_start;
4000ba4c: b4 62 00 10 subx %o0, %l0, %i2
<== NOT EXECUTED
*_time += *_add;
4000ba50: 86 86 c0 1d addcc %i3, %i5, %g3
<== NOT EXECUTED
4000ba54: 84 46 80 1c addx %i2, %i4, %g2
<== NOT EXECUTED
4000ba58: c4 3e 20 98 std %g2, [ %i0 + 0x98 ]
<== NOT EXECUTED
4000ba5c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
*cpu_time_used = the_thread->cpu_time_used;
4000ba60: c4 3e 40 00 std %g2, [ %i1 ]
<== NOT EXECUTED
4000ba64: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ba68: 01 00 00 00 nop
}
4000ba6c: 81 c7 e0 08 ret
4000ba70: 81 e8 00 00 restore
4000bf68 <_Thread_Get_name>:
size_t _Thread_Get_name(
const Thread_Control *the_thread,
char *buffer,
size_t buffer_size
)
{
4000bf68: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
const char *name;
name = the_thread->Join_queue.Queue.name;
4000bf6c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
{
4000bf70: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
if ( name != NULL && name[ 0 ] != '\0' ) {
4000bf74: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000bf78: 02 80 00 06 be 4000bf90 <_Thread_Get_name+0x28>
<== NOT EXECUTED
4000bf7c: 96 10 00 1a mov %i2, %o3
4000bf80: c4 48 40 00 ldsb [ %g1 ], %g2
4000bf84: 80 a0 a0 00 cmp %g2, 0
4000bf88: 12 80 00 09 bne 4000bfac <_Thread_Get_name+0x44>
4000bf8c: b2 10 00 01 mov %g1, %i1
return strlcpy( buffer, name, buffer_size );
} else {
return _Objects_Name_to_string(
4000bf90: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000bf94: c2 27 bf fc st %g1, [ %fp + -4 ]
4000bf98: 92 10 20 00 clr %o1
4000bf9c: 40 00 0d 91 call 4000f5e0 <_Objects_Name_to_string>
4000bfa0: 90 07 bf fc add %fp, -4, %o0
false,
buffer,
buffer_size
);
}
}
4000bfa4: 81 c7 e0 08 ret
4000bfa8: 91 e8 00 08 restore %g0, %o0, %o0
return strlcpy( buffer, name, buffer_size );
4000bfac: 40 00 11 40 call 400104ac <strlcpy>
4000bfb0: 91 e8 00 0a restore %g0, %o2, %o0
4000a450 <_Thread_Handler>:
}
#endif
}
void _Thread_Handler( void )
{
4000a450: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
/*
* Some CPUs need to tinker with the call frame or registers when the
* thread actually begins to execute for the first time. This is a
* hook point where the port gets a shot at doing whatever it requires.
*/
_Context_Initialization_at_thread_begin();
4000a454: 3f 10 00 29 sethi %hi(0x4000a400), %i7
<== NOT EXECUTED
4000a458: be 17 e0 50 or %i7, 0x50, %i7 ! 4000a450 <_Thread_Handler>
<== NOT EXECUTED
executing = _Thread_Executing;
4000a45c: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
<== NOT EXECUTED
4000a460: 90 10 00 06 mov %g6, %o0
<== NOT EXECUTED
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
4000a464: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
<== NOT EXECUTED
_ISR_Set_level( level );
4000a468: 83 28 60 08 sll %g1, 8, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a46c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000a470: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000a474: 91 d0 20 09 ta 9
<== NOT EXECUTED
* Make sure we lose no thread dispatch necessary update and execute the
* post-switch actions. As a side-effect change the thread dispatch level
* from one to zero. Do not use _Thread_Enable_dispatch() since there is no
* valid thread dispatch necessary indicator in this context.
*/
_Thread_Do_dispatch( cpu_self, level );
4000a478: 40 00 10 57 call 4000e5d4 <_Thread_Do_dispatch>
4000a47c: 92 10 00 01 mov %g1, %o1
_User_extensions_Iterate(
4000a480: 94 10 20 00 clr %o2
4000a484: 90 10 00 1d mov %i5, %o0
4000a488: 13 10 00 2f sethi %hi(0x4000bc00), %o1
4000a48c: 40 00 06 51 call 4000bdd0 <_User_extensions_Iterate>
4000a490: 92 12 61 38 or %o1, 0x138, %o1 ! 4000bd38 <_User_extensions_Thread_begin_visitor>
if ( executing->Object.id == _Thread_Global_constructor ) {
4000a494: 03 10 00 7e sethi %hi(0x4001f800), %g1
4000a498: c6 07 60 08 ld [ %i5 + 8 ], %g3
4000a49c: c4 00 61 90 ld [ %g1 + 0x190 ], %g2
4000a4a0: 80 a0 c0 02 cmp %g3, %g2
4000a4a4: 02 80 00 0c be 4000a4d4 <_Thread_Handler+0x84>
4000a4a8: 01 00 00 00 nop
/*
* RTEMS supports multiple APIs and each API can define a different
* thread/task prototype. The following code supports invoking the
* user thread entry point using the prototype expected.
*/
( *executing->Start.Entry.adaptor )( executing );
4000a4ac: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
4000a4b0: 9f c0 40 00 call %g1
4000a4b4: 90 10 00 1d mov %i5, %o0
_User_extensions_Iterate(
4000a4b8: 90 10 00 1d mov %i5, %o0
4000a4bc: 94 10 20 00 clr %o2
4000a4c0: 13 10 00 2f sethi %hi(0x4000bc00), %o1
4000a4c4: 40 00 06 43 call 4000bdd0 <_User_extensions_Iterate>
4000a4c8: 92 12 61 5c or %o1, 0x15c, %o1 ! 4000bd5c <_User_extensions_Thread_exitted_visitor>
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
_Internal_error( INTERNAL_ERROR_THREAD_EXITTED );
4000a4cc: 7f ff f4 f6 call 400078a4 <_Internal_error>
4000a4d0: 90 10 20 05 mov 5, %o0
INIT_NAME();
4000a4d4: 40 00 3f 71 call 4001a298 <_init>
4000a4d8: c0 20 61 90 clr [ %g1 + 0x190 ]
( *executing->Start.Entry.adaptor )( executing );
4000a4dc: 10 bf ff f5 b 4000a4b0 <_Thread_Handler+0x60>
4000a4e0: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
4000a88c <_Thread_Handler_initialization>:
THREAD_QUEUE_HEADS_SIZE( _Scheduler_Count )
);
}
void _Thread_Handler_initialization(void)
{
4000a88c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_stack_allocate_init_hook stack_allocate_init_hook =
4000a890: 03 10 00 63 sethi %hi(0x40018c00), %g1
4000a894: 82 10 60 e8 or %g1, 0xe8, %g1 ! 40018ce8 <Configuration>
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
4000a898: c6 00 60 28 ld [ %g1 + 0x28 ], %g3
4000a89c: 80 a0 e0 00 cmp %g3, 0
4000a8a0: 02 80 00 12 be 4000a8e8 <_Thread_Handler_initialization+0x5c> <== NEVER TAKEN
4000a8a4: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
4000a8a8: c6 00 60 2c ld [ %g1 + 0x2c ], %g3
4000a8ac: 80 a0 e0 00 cmp %g3, 0
4000a8b0: 02 80 00 0e be 4000a8e8 <_Thread_Handler_initialization+0x5c>
4000a8b4: 80 a0 a0 00 cmp %g2, 0
rtems_configuration_get_stack_free_hook() == NULL)
_Internal_error( INTERNAL_ERROR_BAD_STACK_HOOK );
if ( stack_allocate_init_hook != NULL )
4000a8b8: 22 80 00 05 be,a 4000a8cc <_Thread_Handler_initialization+0x40>
4000a8bc: 31 10 00 7e sethi %hi(0x4001f800), %i0
(*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
4000a8c0: 9f c0 80 00 call %g2
4000a8c4: d0 00 60 04 ld [ %g1 + 4 ], %o0
/*
* Initialize the internal class of threads. We need an IDLE thread
* per CPU in an SMP system. In addition, if this is a loosely
* coupled multiprocessing system, account for the MPCI Server Thread.
*/
_Thread_Initialize_information(
4000a8c8: 31 10 00 7e sethi %hi(0x4001f800), %i0
4000a8cc: ba 10 20 08 mov 8, %i5
4000a8d0: b8 10 20 00 clr %i4
4000a8d4: b6 10 20 01 mov 1, %i3
4000a8d8: b4 10 20 01 mov 1, %i2
4000a8dc: b2 10 20 01 mov 1, %i1
4000a8e0: 7f ff ff d8 call 4000a840 <_Thread_Initialize_information>
4000a8e4: 91 ee 21 94 restore %i0, 0x194, %o0
_Internal_error( INTERNAL_ERROR_BAD_STACK_HOOK );
4000a8e8: 7f ff f3 ef call 400078a4 <_Internal_error>
4000a8ec: 90 10 20 0e mov 0xe, %o0
4000a8f0: 01 00 00 00 nop
<== NOT EXECUTED
4000a4e4 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
4000a4e4: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
4000a4e8: c2 07 a0 74 ld [ %fp + 0x74 ], %g1
<== NOT EXECUTED
return false;
}
}
#endif
memset(
4000a4ec: d4 06 20 18 ld [ %i0 + 0x18 ], %o2
<== NOT EXECUTED
{
4000a4f0: e8 00 40 00 ld [ %g1 ], %l4
return (uintptr_t) _TLS_BSS_end - (uintptr_t) _TLS_Data_begin;
4000a4f4: 03 10 00 68 sethi %hi(0x4001a000), %g1
4000a4f8: 82 10 62 d0 or %g1, 0x2d0, %g1 ! 4001a2d0 <_Linker_set__Sysinit_bsp_work_area_initialize>
4000a4fc: e4 07 a0 5c ld [ %fp + 0x5c ], %l2
4000a500: e6 07 a0 60 ld [ %fp + 0x60 ], %l3
4000a504: e2 07 a0 68 ld [ %fp + 0x68 ], %l1
4000a508: ea 0f a0 67 ldub [ %fp + 0x67 ], %l5
memset(
4000a50c: 94 02 bf f0 add %o2, -16, %o2
4000a510: 21 10 00 68 sethi %hi(0x4001a000), %l0
4000a514: 92 10 20 00 clr %o1
4000a518: a0 14 22 d0 or %l0, 0x2d0, %l0
4000a51c: 90 06 60 10 add %i1, 0x10, %o0
4000a520: 40 00 13 38 call 4000f200 <memset>
4000a524: a0 24 00 01 sub %l0, %g1, %l0
&the_thread->Join_queue,
0,
information->Objects.size - offsetof( Thread_Control, Join_queue )
);
for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) {
4000a528: 03 10 00 63 sethi %hi(0x40018c00), %g1
4000a52c: de 00 61 24 ld [ %g1 + 0x124 ], %o7 ! 40018d24 <_Thread_Control_add_on_count>
4000a530: 80 a3 e0 00 cmp %o7, 0
4000a534: 02 80 00 0e be 4000a56c <_Thread_Initialize+0x88>
<== NEVER TAKEN
4000a538: 80 a6 e0 00 cmp %i3, 0
4000a53c: 03 10 00 63 sethi %hi(0x40018c00), %g1
4000a540: 86 10 20 00 clr %g3
4000a544: 82 10 61 28 or %g1, 0x128, %g1
const Thread_Control_add_on *add_on = &_Thread_Control_add_ons[ i ];
*(void **) ( (char *) the_thread + add_on->destination_offset ) =
(char *) the_thread + add_on->source_offset;
4000a548: c4 00 60 04 ld [ %g1 + 4 ], %g2
*(void **) ( (char *) the_thread + add_on->destination_offset ) =
4000a54c: c8 00 40 00 ld [ %g1 ], %g4
(char *) the_thread + add_on->source_offset;
4000a550: 84 06 40 02 add %i1, %g2, %g2
*(void **) ( (char *) the_thread + add_on->destination_offset ) =
4000a554: c4 26 40 04 st %g2, [ %i1 + %g4 ]
for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) {
4000a558: 86 00 e0 01 inc %g3
4000a55c: 80 a0 c0 0f cmp %g3, %o7
4000a560: 12 bf ff fa bne 4000a548 <_Thread_Initialize+0x64>
4000a564: 82 00 60 08 add %g1, 8, %g1
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
4000a568: 80 a6 e0 00 cmp %i3, 0
4000a56c: 02 80 00 93 be 4000a7b8 <_Thread_Initialize+0x2d4>
4000a570: 92 10 00 1c mov %i4, %o1
stack = the_thread->Start.stack;
the_thread->Start.core_allocated_stack = true;
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
4000a574: c0 2e 60 c8 clrb [ %i1 + 0xc8 ]
4000a578: ac 06 20 3c add %i0, 0x3c, %l6
the_stack->area = starting_address;
4000a57c: f6 26 60 d0 st %i3, [ %i1 + 0xd0 ]
);
scheduler_index = 0;
/* Thread-local storage (TLS) area allocation */
if ( tls_size > 0 ) {
4000a580: 80 a4 20 00 cmp %l0, 0
4000a584: 12 80 00 6a bne 4000a72c <_Thread_Initialize+0x248>
4000a588: f8 26 60 cc st %i4, [ %i1 + 0xcc ]
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
4000a58c: 80 a7 60 00 cmp %i5, 0
4000a590: 12 80 00 79 bne 4000a774 <_Thread_Initialize+0x290>
4000a594: b8 10 20 00 clr %i4
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
if ( !fp_area )
goto failed;
}
the_thread->fp_context = fp_area;
4000a598: f8 26 61 50 st %i4, [ %i1 + 0x150 ]
the_thread->Start.fp_context = fp_area;
4000a59c: f8 26 60 d4 st %i4, [ %i1 + 0xd4 ]
return information->auto_extend ? information->allocation_size : 0;
4000a5a0: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
4000a5a4: 80 a0 60 00 cmp %g1, 0
4000a5a8: 12 80 00 5f bne 4000a724 <_Thread_Initialize+0x240>
4000a5ac: 94 10 20 00 clr %o2
#endif
/*
* Get thread queue heads
*/
the_thread->Wait.spare_heads = _Freechain_Get(
4000a5b0: 96 10 20 48 mov 0x48, %o3
4000a5b4: 90 10 00 16 mov %l6, %o0
4000a5b8: 13 10 00 30 sethi %hi(0x4000c000), %o1
4000a5bc: 7f ff f2 eb call 40007168 <_Freechain_Get>
4000a5c0: 92 12 63 b8 or %o1, 0x3b8, %o1 ! 4000c3b8 <_Workspace_Allocate>
&information->Free_thread_queue_heads,
_Workspace_Allocate,
_Objects_Extend_size( &information->Objects ),
THREAD_QUEUE_HEADS_SIZE( _Scheduler_Count )
);
if ( the_thread->Wait.spare_heads == NULL ) {
4000a5c4: 80 a2 20 00 cmp %o0, 0
4000a5c8: 02 80 00 48 be 4000a6e8 <_Thread_Initialize+0x204>
<== NEVER TAKEN
4000a5cc: d0 26 60 5c st %o0, [ %i1 + 0x5c ]
return &the_chain->Tail.Node;
4000a5d0: 82 02 20 34 add %o0, 0x34, %g1
head->previous = NULL;
4000a5d4: c0 22 20 34 clr [ %o0 + 0x34 ]
return &the_chain->Tail.Node;
4000a5d8: 84 02 20 30 add %o0, 0x30, %g2
head->next = tail;
4000a5dc: c2 22 20 30 st %g1, [ %o0 + 0x30 ]
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
_Thread_Timer_initialize( &the_thread->Timer, cpu );
switch ( budget_algorithm ) {
4000a5e0: 80 a4 60 02 cmp %l1, 2
tail->previous = head;
4000a5e4: c4 22 20 38 st %g2, [ %o0 + 0x38 ]
the_thread->Start.isr_level = isr_level;
4000a5e8: c2 07 a0 70 ld [ %fp + 0x70 ], %g1
4000a5ec: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ]
the_thread->Start.budget_callout = budget_callout;
4000a5f0: c2 07 a0 6c ld [ %fp + 0x6c ], %g1
4000a5f4: c2 26 60 b4 st %g1, [ %i1 + 0xb4 ]
Thread_Timer_information *timer,
Per_CPU_Control *cpu
)
{
_ISR_lock_Initialize( &timer->Lock, "Thread Timer" );
timer->header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ];
4000a5f8: 03 10 00 7e sethi %hi(0x4001f800), %g1
4000a5fc: 82 10 61 78 or %g1, 0x178, %g1 ! 4001f978 <_Per_CPU_Information+0x38>
the_thread->is_fp = is_fp;
4000a600: fa 2e 60 8a stb %i5, [ %i1 + 0x8a ]
4000a604: c2 26 60 60 st %g1, [ %i1 + 0x60 ]
RTEMS_INLINE_ROUTINE void _Watchdog_Set_state(
Watchdog_Control *the_watchdog,
Watchdog_State state
)
{
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
4000a608: 82 10 20 02 mov 2, %g1
the_thread->Start.is_preemptible = is_preemptible;
4000a60c: ea 2e 60 ac stb %l5, [ %i1 + 0xac ]
the_thread->Start.budget_algorithm = budget_algorithm;
4000a610: e2 26 60 b0 st %l1, [ %i1 + 0xb0 ]
switch ( budget_algorithm ) {
4000a614: 12 80 00 05 bne 4000a628 <_Thread_Initialize+0x144>
4000a618: c2 26 60 74 st %g1, [ %i1 + 0x74 ]
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
the_thread->cpu_time_budget =
rtems_configuration_get_ticks_per_timeslice();
4000a61c: 03 10 00 63 sethi %hi(0x40018c00), %g1
the_thread->cpu_time_budget =
4000a620: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 40018d00 <Configuration+0x18>
4000a624: c2 26 60 8c st %g1, [ %i1 + 0x8c ]
( *scheduler->Operations.node_initialize )(
4000a628: 96 10 00 12 mov %l2, %o3
4000a62c: fa 06 60 38 ld [ %i1 + 0x38 ], %i5
4000a630: c2 06 a0 24 ld [ %i2 + 0x24 ], %g1
4000a634: 98 10 00 13 mov %l3, %o4
4000a638: 94 10 00 19 mov %i1, %o2
4000a63c: 92 10 00 1d mov %i5, %o1
4000a640: 9f c0 40 00 call %g1
4000a644: 90 10 00 1a mov %i2, %o0
RTEMS_INLINE_ROUTINE void _Priority_Node_initialize(
Priority_Node *node,
Priority_Control priority
)
{
node->priority = priority;
4000a648: e4 3e 60 30 std %l2, [ %i1 + 0x30 ]
#endif
aggregation->Action.node = NULL;
aggregation->Action.type = PRIORITY_ACTION_INVALID;
#endif
_Priority_Node_initialize( &aggregation->Node, node->priority );
_RBTree_Initialize_one( &aggregation->Contributors, &node->Node.RBTree );
4000a64c: 82 06 60 20 add %i1, 0x20, %g1
node->priority = priority;
4000a650: e4 3f 60 18 std %l2, [ %i5 + 0x18 ]
#endif
/* Initialize the CPU for the non-SMP schedulers */
_Thread_Set_CPU( the_thread, cpu );
the_thread->current_state = STATES_DORMANT;
4000a654: 05 20 00 00 sethi %hi(0x80000000), %g2
RB_ROOT( the_rbtree ) = the_node;
4000a658: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
return &the_chain->Tail.Node;
4000a65c: 86 06 60 e0 add %i1, 0xe0, %g3
4000a660: c4 26 60 1c st %g2, [ %i1 + 0x1c ]
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4000a664: 05 10 00 66 sethi %hi(0x40019800), %g2
4000a668: 84 10 a1 50 or %g2, 0x150, %g2 ! 40019950 <_Thread_queue_Operations_default>
information->local_table[ index ] = the_object;
4000a66c: c2 16 60 0a lduh [ %i1 + 0xa ], %g1
4000a670: c4 26 60 58 st %g2, [ %i1 + 0x58 ]
4000a674: 88 06 60 e4 add %i1, 0xe4, %g4
4000a678: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
RB_PARENT( the_node, Node ) = NULL;
4000a67c: c0 26 60 28 clr [ %i1 + 0x28 ]
4000a680: 83 28 60 02 sll %g1, 2, %g1
RB_LEFT( the_node, Node ) = NULL;
4000a684: c0 26 60 20 clr [ %i1 + 0x20 ]
_User_extensions_Iterate(
4000a688: 94 10 20 00 clr %o2
RB_RIGHT( the_node, Node ) = NULL;
4000a68c: c0 26 60 24 clr [ %i1 + 0x24 ]
4000a690: 13 10 00 2f sethi %hi(0x4000bc00), %o1
RB_COLOR( the_node, Node ) = RB_BLACK;
4000a694: c0 26 60 2c clr [ %i1 + 0x2c ]
4000a698: 92 12 60 90 or %o1, 0x90, %o1
the_thread->Start.initial_priority = priority;
4000a69c: e4 3e 60 c0 std %l2, [ %i1 + 0xc0 ]
4000a6a0: 90 07 bf f8 add %fp, -8, %o0
RB_INIT( the_rbtree );
4000a6a4: c0 26 61 60 clr [ %i1 + 0x160 ]
head->next = tail;
4000a6a8: c8 26 60 e0 st %g4, [ %i1 + 0xe0 ]
head->previous = NULL;
4000a6ac: c0 26 60 e4 clr [ %i1 + 0xe4 ]
tail->previous = head;
4000a6b0: c6 26 60 e8 st %g3, [ %i1 + 0xe8 ]
the_object->name = name;
4000a6b4: e8 26 60 0c st %l4, [ %i1 + 0xc ]
information->local_table[ index ] = the_object;
4000a6b8: f2 20 80 01 st %i1, [ %g2 + %g1 ]
User_extensions_Thread_create_context ctx = { created, true };
4000a6bc: 82 10 20 01 mov 1, %g1
4000a6c0: f2 27 bf f8 st %i1, [ %fp + -8 ]
_User_extensions_Iterate(
4000a6c4: 40 00 05 c3 call 4000bdd0 <_User_extensions_Iterate>
4000a6c8: c2 2f bf fc stb %g1, [ %fp + -4 ]
* user extensions with dispatching enabled. The Allocator
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
4000a6cc: f0 0f bf fc ldub [ %fp + -4 ], %i0
4000a6d0: 80 a6 20 00 cmp %i0, 0
4000a6d4: 12 80 00 0f bne 4000a710 <_Thread_Initialize+0x22c>
4000a6d8: 92 10 00 1d mov %i5, %o1
( *scheduler->Operations.node_destroy )( scheduler, node );
4000a6dc: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
4000a6e0: 9f c0 40 00 call %g1
4000a6e4: 90 10 00 1a mov %i2, %o0
4000a6e8: d0 06 60 dc ld [ %i1 + 0xdc ], %o0
if ( scheduler_index > 0 ) {
_Scheduler_Node_destroy( scheduler, scheduler_node );
}
#endif
_Workspace_Free( the_thread->Start.tls_area );
4000a6ec: 40 00 07 43 call 4000c3f8 <_Workspace_Free>
4000a6f0: b0 10 20 00 clr %i0
_Freechain_Put(
4000a6f4: d2 06 60 5c ld [ %i1 + 0x5c ], %o1
4000a6f8: 7f ff f2 ba call 400071e0 <_Freechain_Put>
4000a6fc: 90 10 00 16 mov %l6, %o0
&information->Free_thread_queue_heads,
the_thread->Wait.spare_heads
);
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
4000a700: 40 00 07 3e call 4000c3f8 <_Workspace_Free>
4000a704: 90 10 00 1c mov %i4, %o0
#endif
_Thread_Stack_Free( the_thread );
4000a708: 40 00 04 e8 call 4000baa8 <_Thread_Stack_Free>
4000a70c: 90 10 00 19 mov %i1, %o0
return false;
4000a710: 81 c7 e0 08 ret
4000a714: 81 e8 00 00 restore
4000a718: b0 10 20 00 clr %i0
}
4000a71c: 81 c7 e0 08 ret
4000a720: 81 e8 00 00 restore
4000a724: 10 bf ff a3 b 4000a5b0 <_Thread_Initialize+0xcc>
4000a728: d4 16 20 14 lduh [ %i0 + 0x14 ], %o2
return (val + msk) & ~msk;
4000a72c: 90 04 20 07 add %l0, 7, %o0
4000a730: 13 00 00 00 sethi %hi(0), %o1
4000a734: 90 0a 3f f8 and %o0, -8, %o0
4000a738: 92 12 60 01 or %o1, 1, %o1
4000a73c: 92 02 60 07 add %o1, 7, %o1
4000a740: 92 0a 7f f8 and %o1, -8, %o1
sizeof(TLS_Thread_control_block) : alignment;
4000a744: 80 a2 60 08 cmp %o1, 8
4000a748: 0a 80 00 12 bcs 4000a790 <_Thread_Initialize+0x2ac>
<== NEVER TAKEN
4000a74c: 82 10 00 09 mov %o1, %g1
allocation_size += _TLS_Get_thread_control_block_area_size( alignment );
4000a750: 90 02 00 01 add %o0, %g1, %o0
_Workspace_Allocate_aligned( tls_alloc, tls_align );
4000a754: 40 00 07 21 call 4000c3d8 <_Workspace_Allocate_aligned>
4000a758: 90 02 20 08 add %o0, 8, %o0
the_thread->Start.tls_area =
4000a75c: d0 26 60 dc st %o0, [ %i1 + 0xdc ]
if ( the_thread->Start.tls_area == NULL ) {
4000a760: 80 a2 20 00 cmp %o0, 0
4000a764: 12 bf ff 8a bne 4000a58c <_Thread_Initialize+0xa8>
<== ALWAYS TAKEN
4000a768: b8 10 00 08 mov %o0, %i4
failed:
4000a76c: 10 bf ff e0 b 4000a6ec <_Thread_Initialize+0x208>
<== NOT EXECUTED
4000a770: 90 10 20 00 clr %o0
<== NOT EXECUTED
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
4000a774: 40 00 07 11 call 4000c3b8 <_Workspace_Allocate>
4000a778: 90 10 20 88 mov 0x88, %o0
if ( !fp_area )
4000a77c: b8 92 20 00 orcc %o0, 0, %i4
4000a780: 32 bf ff 87 bne,a 4000a59c <_Thread_Initialize+0xb8>
4000a784: f8 26 61 50 st %i4, [ %i1 + 0x150 ]
failed:
4000a788: 10 bf ff d9 b 4000a6ec <_Thread_Initialize+0x208>
4000a78c: d0 06 60 dc ld [ %i1 + 0xdc ], %o0
sizeof(TLS_Thread_control_block) : alignment;
4000a790: 82 10 20 08 mov 8, %g1
<== NOT EXECUTED
allocation_size += _TLS_Get_thread_control_block_area_size( alignment );
4000a794: 90 02 00 01 add %o0, %g1, %o0
<== NOT EXECUTED
_Workspace_Allocate_aligned( tls_alloc, tls_align );
4000a798: 40 00 07 10 call 4000c3d8 <_Workspace_Allocate_aligned>
<== NOT EXECUTED
4000a79c: 90 02 20 08 add %o0, 8, %o0
<== NOT EXECUTED
the_thread->Start.tls_area =
4000a7a0: d0 26 60 dc st %o0, [ %i1 + 0xdc ]
<== NOT EXECUTED
if ( the_thread->Start.tls_area == NULL ) {
4000a7a4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000a7a8: 12 bf ff 79 bne 4000a58c <_Thread_Initialize+0xa8>
<== NOT EXECUTED
4000a7ac: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
4000a7b0: 10 bf ff cf b 4000a6ec <_Thread_Initialize+0x208>
<== NOT EXECUTED
4000a7b4: 90 10 20 00 clr %o0
<== NOT EXECUTED
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
4000a7b8: 40 00 04 ac call 4000ba68 <_Thread_Stack_Allocate>
4000a7bc: 90 10 00 19 mov %i1, %o0
if ( !actual_stack_size || actual_stack_size < stack_size )
4000a7c0: 80 a2 20 00 cmp %o0, 0
4000a7c4: 02 bf ff d5 be 4000a718 <_Thread_Initialize+0x234>
4000a7c8: 80 a2 00 1c cmp %o0, %i4
4000a7cc: 0a bf ff d3 bcs 4000a718 <_Thread_Initialize+0x234>
<== NEVER TAKEN
4000a7d0: 82 10 20 01 mov 1, %g1
stack = the_thread->Start.stack;
4000a7d4: f6 06 60 d8 ld [ %i1 + 0xd8 ], %i3
the_thread->Start.core_allocated_stack = true;
4000a7d8: c2 2e 60 c8 stb %g1, [ %i1 + 0xc8 ]
4000a7dc: 10 bf ff 67 b 4000a578 <_Thread_Initialize+0x94>
4000a7e0: b8 10 00 08 mov %o0, %i4
4000a840 <_Thread_Initialize_information>:
uint16_t the_class,
uint32_t maximum,
bool is_string,
uint32_t maximum_name_length
)
{
4000a840: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
_Objects_Initialize_information(
4000a844: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
<== NOT EXECUTED
4000a848: 03 10 00 63 sethi %hi(0x40018c00), %g1
4000a84c: d8 10 61 52 lduh [ %g1 + 0x152 ], %o4 ! 40018d52 <_Thread_Control_size+0x2>
{
4000a850: ba 10 00 1b mov %i3, %i5
_Objects_Initialize_information(
4000a854: 94 10 00 1a mov %i2, %o2
4000a858: 92 10 00 19 mov %i1, %o1
4000a85c: 96 10 00 1b mov %i3, %o3
4000a860: 90 10 00 18 mov %i0, %o0
4000a864: 9a 10 00 1c mov %i4, %o5
is_string,
maximum_name_length,
NULL
);
_Freechain_Initialize(
4000a868: 33 10 00 31 sethi %hi(0x4000c400), %i1
4000a86c: 35 00 00 3f sethi %hi(0xfc00), %i2
4000a870: b6 10 20 48 mov 0x48, %i3
_Objects_Initialize_information(
4000a874: 7f ff fa 4d call 400091a8 <_Objects_Do_initialize_information>
4000a878: b4 16 a3 ff or %i2, 0x3ff, %i2
_Freechain_Initialize(
4000a87c: b0 06 20 3c add %i0, 0x3c, %i0
4000a880: b4 0f 40 1a and %i5, %i2, %i2
4000a884: 7f ff f2 2c call 40007134 <_Freechain_Initialize>
4000a888: 93 ee 60 10 restore %i1, 0x10, %o1
4000e830 <_Thread_Iterate>:
void _Thread_Iterate(
Thread_Visitor visitor,
void *arg
)
{
4000e830: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
4000e834: 37 10 00 77 sethi %hi(0x4001dc00), %i3
<== NOT EXECUTED
4000e838: b6 16 e3 1c or %i3, 0x31c, %i3 ! 4001df1c <_Objects_Information_table>
<== NOT EXECUTED
4000e83c: b4 06 e0 0c add %i3, 0xc, %i2
<== NOT EXECUTED
if ( _Objects_Information_table[ api_index ] == NULL ) {
continue;
}
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
4000e840: c2 06 e0 04 ld [ %i3 + 4 ], %g1
<== NOT EXECUTED
4000e844: f8 00 60 04 ld [ %g1 + 4 ], %i4
if ( information == NULL ) {
4000e848: 80 a7 20 00 cmp %i4, 0
4000e84c: 22 80 00 1d be,a 4000e8c0 <_Thread_Iterate+0x90>
4000e850: b6 06 e0 04 add %i3, 4, %i3
continue;
}
for ( i = 1 ; i <= information->maximum ; ++i ) {
4000e854: c4 17 20 10 lduh [ %i4 + 0x10 ], %g2
4000e858: 82 90 a0 00 orcc %g2, 0, %g1
4000e85c: 02 80 00 18 be 4000e8bc <_Thread_Iterate+0x8c>
<== NEVER TAKEN
4000e860: ba 10 20 01 mov 1, %i5
Thread_Control *the_thread;
the_thread = (Thread_Control *) information->local_table[ i ];
4000e864: 10 80 00 09 b 4000e888 <_Thread_Iterate+0x58>
4000e868: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
for ( i = 1 ; i <= information->maximum ; ++i ) {
4000e86c: ba 07 60 01 inc %i5
4000e870: 83 28 a0 10 sll %g2, 0x10, %g1
4000e874: 87 2f 60 10 sll %i5, 0x10, %g3
4000e878: 80 a0 c0 01 cmp %g3, %g1
4000e87c: 38 80 00 11 bgu,a 4000e8c0 <_Thread_Iterate+0x90>
4000e880: b6 06 e0 04 add %i3, 4, %i3
the_thread = (Thread_Control *) information->local_table[ i ];
4000e884: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
4000e888: 83 2f 60 10 sll %i5, 0x10, %g1
4000e88c: 83 30 60 0e srl %g1, 0xe, %g1
4000e890: d0 00 c0 01 ld [ %g3 + %g1 ], %o0
if ( the_thread != NULL ) {
4000e894: 80 a2 20 00 cmp %o0, 0
4000e898: 22 bf ff f6 be,a 4000e870 <_Thread_Iterate+0x40>
4000e89c: ba 07 60 01 inc %i5
bool done;
done = (* visitor )( the_thread, arg );
4000e8a0: 9f c6 00 00 call %i0
4000e8a4: 92 10 00 19 mov %i1, %o1
if ( done ) {
4000e8a8: 80 a2 20 00 cmp %o0, 0
4000e8ac: 22 bf ff f0 be,a 4000e86c <_Thread_Iterate+0x3c>
<== ALWAYS TAKEN
4000e8b0: c4 17 20 10 lduh [ %i4 + 0x10 ], %g2
return;
}
}
}
}
}
4000e8b4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e8b8: 81 e8 00 00 restore
<== NOT EXECUTED
4000e8bc: b6 06 e0 04 add %i3, 4, %i3
<== NOT EXECUTED
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; ++api_index ) {
4000e8c0: 80 a6 80 1b cmp %i2, %i3
4000e8c4: 32 bf ff e0 bne,a 4000e844 <_Thread_Iterate+0x14>
4000e8c8: c2 06 e0 04 ld [ %i3 + 4 ], %g1
}
4000e8cc: 81 c7 e0 08 ret
4000e8d0: 81 e8 00 00 restore
400105a0 <_Thread_Join>:
{
_Assert( the_thread != executing );
_Assert( _Thread_State_is_owner( the_thread ) );
#if defined(RTEMS_POSIX_API)
executing->Wait.return_argument = NULL;
400105a0: c0 22 a0 40 clr [ %o2 + 0x40 ]
<== NOT EXECUTED
#endif
_Thread_queue_Context_set_thread_state( queue_context, waiting_for_join );
_Thread_queue_Enqueue(
400105a4: 90 02 20 10 add %o0, 0x10, %o0
<== NOT EXECUTED
queue_context->thread_state = thread_state;
400105a8: d2 22 e0 04 st %o1, [ %o3 + 4 ]
<== NOT EXECUTED
400105ac: 13 10 00 6f sethi %hi(0x4001bc00), %o1
<== NOT EXECUTED
400105b0: 92 12 61 68 or %o1, 0x168, %o1 ! 4001bd68 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
400105b4: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400105b8: 7f ff fb 73 call 4000f384 <_Thread_queue_Enqueue>
<== NOT EXECUTED
400105bc: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000b7fc <_Thread_Kill_zombies>:
{
4000b7fc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b800: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000b804: 05 10 00 6d sethi %hi(0x4001b400), %g2
4000b808: fa 00 a1 cc ld [ %g2 + 0x1cc ], %i5 ! 4001b5cc <_Thread_Zombies>
4000b80c: b8 10 a1 cc or %g2, 0x1cc, %i4
if ( !_Chain_Is_empty(the_chain))
4000b810: b0 07 20 04 add %i4, 4, %i0
4000b814: 80 a7 40 18 cmp %i5, %i0
4000b818: 02 80 00 3d be 4000b90c <_Thread_Kill_zombies+0x110>
4000b81c: 33 10 00 2f sethi %hi(0x4000bc00), %i1
new_first = old_first->next;
4000b820: c6 07 40 00 ld [ %i5 ], %g3
<== NOT EXECUTED
head->next = new_first;
4000b824: c6 20 a1 cc st %g3, [ %g2 + 0x1cc ]
<== NOT EXECUTED
new_first->previous = head;
4000b828: f8 20 e0 04 st %i4, [ %g3 + 4 ]
<== NOT EXECUTED
4000b82c: 35 10 00 63 sethi %hi(0x40018c00), %i2
<== NOT EXECUTED
_User_extensions_Iterate(
4000b830: b2 16 60 cc or %i1, 0xcc, %i1
<== NOT EXECUTED
4000b834: b4 16 a1 c8 or %i2, 0x1c8, %i2
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b838: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b83c: 01 00 00 00 nop
Thread_Information *information = (Thread_Information *)
4000b840: 40 00 09 d8 call 4000dfa0 <_Objects_Get_information_id>
4000b844: d0 07 60 08 ld [ %i5 + 8 ], %o0
4000b848: 94 10 20 01 mov 1, %o2
4000b84c: b6 10 00 08 mov %o0, %i3
4000b850: 92 10 00 19 mov %i1, %o1
4000b854: 40 00 01 5f call 4000bdd0 <_User_extensions_Iterate>
4000b858: 90 10 00 1d mov %i5, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b85c: 91 d0 20 09 ta 9
<== NOT EXECUTED
iter = the_thread->last_user_extensions_iterator;
4000b860: c4 07 61 88 ld [ %i5 + 0x188 ], %g2
while ( iter != NULL ) {
4000b864: 80 a0 a0 00 cmp %g2, 0
4000b868: 02 80 00 0a be 4000b890 <_Thread_Kill_zombies+0x94>
4000b86c: 01 00 00 00 nop
next = the_node->next;
4000b870: c8 00 80 00 ld [ %g2 ], %g4
previous = the_node->previous;
4000b874: c6 00 a0 04 ld [ %g2 + 4 ], %g3
next->previous = previous;
4000b878: c6 21 20 04 st %g3, [ %g4 + 4 ]
previous->next = next;
4000b87c: c8 20 c0 00 st %g4, [ %g3 ]
iter = iter->previous;
4000b880: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
while ( iter != NULL ) {
4000b884: 80 a0 a0 00 cmp %g2, 0
4000b888: 32 bf ff fb bne,a 4000b874 <_Thread_Kill_zombies+0x78> <== NEVER TAKEN
4000b88c: c8 00 80 00 ld [ %g2 ], %g4
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b890: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b894: 01 00 00 00 nop
4000b898: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
4000b89c: d2 07 60 38 ld [ %i5 + 0x38 ], %o1
4000b8a0: 9f c0 40 00 call %g1
4000b8a4: 90 10 00 1a mov %i2, %o0
_Workspace_Free( the_thread->Start.fp_context );
4000b8a8: 40 00 02 d4 call 4000c3f8 <_Workspace_Free>
4000b8ac: d0 07 60 d4 ld [ %i5 + 0xd4 ], %o0
_Freechain_Put(
4000b8b0: d2 07 60 5c ld [ %i5 + 0x5c ], %o1
4000b8b4: 7f ff ee 4b call 400071e0 <_Freechain_Put>
4000b8b8: 90 06 e0 3c add %i3, 0x3c, %o0
_Thread_Stack_Free( the_thread );
4000b8bc: 40 00 00 7b call 4000baa8 <_Thread_Stack_Free>
4000b8c0: 90 10 00 1d mov %i5, %o0
_Workspace_Free( the_thread->Start.tls_area );
4000b8c4: 40 00 02 cd call 4000c3f8 <_Workspace_Free>
4000b8c8: d0 07 60 dc ld [ %i5 + 0xdc ], %o0
_Context_Destroy( the_thread, &the_thread->Registers );
4000b8cc: c4 01 a0 04 ld [ %g6 + 4 ], %g2
4000b8d0: 80 a0 80 1d cmp %g2, %i5
4000b8d4: 22 80 00 02 be,a 4000b8dc <_Thread_Kill_zombies+0xe0>
4000b8d8: c0 21 a0 04 clr [ %g6 + 4 ]
_Objects_Free( &information->Objects, &the_thread->Object );
4000b8dc: 92 10 00 1d mov %i5, %o1
4000b8e0: 40 00 09 84 call 4000def0 <_Objects_Free>
4000b8e4: 90 10 00 1b mov %i3, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b8e8: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000b8ec: fa 07 00 00 ld [ %i4 ], %i5
if ( !_Chain_Is_empty(the_chain))
4000b8f0: 80 a7 40 18 cmp %i5, %i0
4000b8f4: 02 80 00 06 be 4000b90c <_Thread_Kill_zombies+0x110>
4000b8f8: 01 00 00 00 nop
new_first = old_first->next;
4000b8fc: c4 07 40 00 ld [ %i5 ], %g2
head->next = new_first;
4000b900: c4 27 00 00 st %g2, [ %i4 ]
new_first->previous = head;
4000b904: 10 bf ff cd b 4000b838 <_Thread_Kill_zombies+0x3c>
4000b908: f8 20 a0 04 st %i4, [ %g2 + 4 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b90c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b910: 01 00 00 00 nop
}
4000b914: 81 c7 e0 08 ret
4000b918: 81 e8 00 00 restore
4000a7e4 <_Thread_Load_environment>:
#include <rtems/score/threadimpl.h>
void _Thread_Load_environment(
Thread_Control *the_thread
)
{
4000a7e4: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( the_thread->Start.fp_context ) {
4000a7e8: c2 06 20 d4 ld [ %i0 + 0xd4 ], %g1
4000a7ec: 80 a0 60 00 cmp %g1, 0
4000a7f0: 32 80 00 02 bne,a 4000a7f8 <_Thread_Load_environment+0x14>
4000a7f4: c2 26 21 50 st %g1, [ %i0 + 0x150 ]
the_thread->is_preemptible = the_thread->Start.is_preemptible;
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
the_thread->budget_callout = the_thread->Start.budget_callout;
_Context_Initialize(
4000a7f8: 19 10 00 29 sethi %hi(0x4000a400), %o4
the_thread->is_preemptible = the_thread->Start.is_preemptible;
4000a7fc: c8 0e 20 ac ldub [ %i0 + 0xac ], %g4
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
4000a800: c6 06 20 b0 ld [ %i0 + 0xb0 ], %g3
the_thread->budget_callout = the_thread->Start.budget_callout;
4000a804: c4 06 20 b4 ld [ %i0 + 0xb4 ], %g2
_Context_Initialize(
4000a808: c2 06 20 dc ld [ %i0 + 0xdc ], %g1
the_thread->is_preemptible = the_thread->Start.is_preemptible;
4000a80c: c8 2e 20 89 stb %g4, [ %i0 + 0x89 ]
_Context_Initialize(
4000a810: 98 13 20 50 or %o4, 0x50, %o4
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
4000a814: c6 26 20 90 st %g3, [ %i0 + 0x90 ]
_Context_Initialize(
4000a818: 90 06 20 f0 add %i0, 0xf0, %o0
the_thread->budget_callout = the_thread->Start.budget_callout;
4000a81c: c4 26 20 94 st %g2, [ %i0 + 0x94 ]
_Context_Initialize(
4000a820: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000a824: da 0e 20 8a ldub [ %i0 + 0x8a ], %o5
4000a828: d6 06 20 b8 ld [ %i0 + 0xb8 ], %o3
4000a82c: d4 06 20 cc ld [ %i0 + 0xcc ], %o2
4000a830: 7f ff e3 07 call 4000344c <_CPU_Context_Initialize>
4000a834: d2 06 20 d0 ld [ %i0 + 0xd0 ], %o1
the_thread->Start.isr_level,
_Thread_Handler,
the_thread->is_fp,
the_thread->Start.tls_area
);
}
4000a838: 81 c7 e0 08 ret
4000a83c: 81 e8 00 00 restore
4001053c <_Thread_Priority_remove>:
Thread_Control *the_thread,
Priority_Node *priority_node,
Thread_queue_Context *queue_context
)
{
_Thread_Priority_apply(
4001053c: 98 10 20 02 mov 2, %o4
<== NOT EXECUTED
40010540: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
40010544: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40010548: 7f ff ff e2 call 400104d0 <_Thread_Priority_apply>
<== NOT EXECUTED
4001054c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000e4c8 <_Thread_Priority_update>:
replacement_node
);
}
void _Thread_Priority_update( Thread_queue_Context *queue_context )
{
4000e4c8: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
size_t i;
size_t n;
n = queue_context->Priority.update_count;
4000e4cc: fa 06 20 14 ld [ %i0 + 0x14 ], %i5
<== NOT EXECUTED
/*
* Update the priority of all threads of the set. Do not care to clear the
* set, since the thread queue context will soon get destroyed anyway.
*/
for ( i = 0; i < n ; ++i ) {
4000e4d0: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4000e4d4: 02 80 00 13 be 4000e520 <_Thread_Priority_update+0x58>
<== NOT EXECUTED
4000e4d8: 39 10 00 63 sethi %hi(0x40018c00), %i4
4000e4dc: b8 17 21 c8 or %i4, 0x1c8, %i4 ! 40018dc8 <_Scheduler_Table> <== NOT EXECUTED
( *scheduler->Operations.update_priority )(
4000e4e0: f6 07 20 18 ld [ %i4 + 0x18 ], %i3
<== NOT EXECUTED
4000e4e4: bb 2f 60 02 sll %i5, 2, %i5
<== NOT EXECUTED
4000e4e8: ba 06 00 1d add %i0, %i5, %i5
<== NOT EXECUTED
Thread_Control *the_thread;
ISR_lock_Context lock_context;
the_thread = queue_context->Priority.update[ i ];
4000e4ec: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e4f0: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000e4f4: c2 27 bf fc st %g1, [ %fp + -4 ]
4000e4f8: d4 02 60 38 ld [ %o1 + 0x38 ], %o2
4000e4fc: 9f c6 c0 00 call %i3
4000e500: 90 10 00 1c mov %i4, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e504: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e508: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e50c: 01 00 00 00 nop
4000e510: b0 06 20 04 add %i0, 4, %i0
for ( i = 0; i < n ; ++i ) {
4000e514: 80 a6 00 1d cmp %i0, %i5
4000e518: 32 bf ff f6 bne,a 4000e4f0 <_Thread_Priority_update+0x28>
4000e51c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
_Thread_State_acquire( the_thread, &lock_context );
_Scheduler_Update_priority( the_thread );
_Thread_State_release( the_thread, &lock_context );
}
}
4000e520: 81 c7 e0 08 ret
4000e524: 81 e8 00 00 restore
4000b59c <_Thread_Restart_other>:
bool _Thread_Restart_other(
Thread_Control *the_thread,
const Thread_Entry_information *entry,
ISR_lock_Context *lock_context
)
{
4000b59c: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
Thread_Life_state previous;
Per_CPU_Control *cpu_self;
_Thread_State_acquire_critical( the_thread, lock_context );
if ( _States_Is_dormant( the_thread->current_state ) ) {
4000b5a0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
<== NOT EXECUTED
4000b5a4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000b5a8: 06 80 00 4f bl 4000b6e4 <_Thread_Restart_other+0x148>
<== NOT EXECUTED
4000b5ac: 01 00 00 00 nop
_Thread_State_release( the_thread, lock_context );
return false;
}
the_thread->Start.Entry = *entry;
4000b5b0: c2 06 40 00 ld [ %i1 ], %g1
4000b5b4: c2 26 20 a0 st %g1, [ %i0 + 0xa0 ]
4000b5b8: c2 06 60 04 ld [ %i1 + 4 ], %g1
4000b5bc: c2 26 20 a4 st %g1, [ %i0 + 0xa4 ]
previous = the_thread->Life.state;
4000b5c0: c2 06 21 70 ld [ %i0 + 0x170 ], %g1
the_thread->Start.Entry = *entry;
4000b5c4: c6 06 60 08 ld [ %i1 + 8 ], %g3
state |= set;
4000b5c8: 84 10 60 02 or %g1, 2, %g2
the_thread->Start.Entry = *entry;
4000b5cc: c6 26 20 a8 st %g3, [ %i0 + 0xa8 ]
if (
4000b5d0: 80 88 60 09 btst 9, %g1
4000b5d4: 02 80 00 15 be 4000b628 <_Thread_Restart_other+0x8c>
<== ALWAYS TAKEN
4000b5d8: c4 26 21 70 st %g2, [ %i0 + 0x170 ]
disable_level = cpu_self->thread_dispatch_disable_level;
4000b5dc: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000b5e0: 82 00 60 01 inc %g1
<== NOT EXECUTED
4000b5e4: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000b5e8: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
_Thread_Finalize_life_change(
the_thread,
the_thread->Start.initial_priority
);
} else {
_Thread_Clear_state_locked( the_thread, STATES_SUSPENDED );
4000b5ec: 13 00 00 20 sethi %hi(0x8000), %o1
<== NOT EXECUTED
4000b5f0: 40 00 0b c5 call 4000e504 <_Thread_Clear_state_locked>
<== NOT EXECUTED
4000b5f4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000b5f8: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b5fc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b600: 01 00 00 00 nop
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000b604: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000b608: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000b60c: 02 80 00 2a be 4000b6b4 <_Thread_Restart_other+0x118>
<== NOT EXECUTED
4000b610: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
_Thread_State_release( the_thread, lock_context );
}
_Thread_Dispatch_enable( cpu_self );
return true;
4000b614: b0 10 20 01 mov 1, %i0
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000b618: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
4000b61c: b0 0e 20 ff and %i0, 0xff, %i0
}
4000b620: 81 c7 e0 08 ret
4000b624: 81 e8 00 00 restore
4000b628: 7f ff fe 6d call 4000afdc <_Thread_Change_life_locked.part.37>
4000b62c: 90 10 00 18 mov %i0, %o0
disable_level = cpu_self->thread_dispatch_disable_level;
4000b630: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
pending_requests = the_thread->Life.pending_life_change_requests;
4000b634: c4 06 21 74 ld [ %i0 + 0x174 ], %g2
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000b638: 82 00 60 01 inc %g1
4000b63c: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
the_thread->Life.pending_life_change_requests = pending_requests + 1;
4000b640: 82 00 a0 01 add %g2, 1, %g1
4000b644: c2 26 21 74 st %g1, [ %i0 + 0x174 ]
if ( pending_requests == 0 ) {
4000b648: 80 a0 a0 00 cmp %g2, 0
4000b64c: 02 80 00 2d be 4000b700 <_Thread_Restart_other+0x164>
<== ALWAYS TAKEN
4000b650: ba 10 00 06 mov %g6, %i5
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000b654: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b658: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b65c: 01 00 00 00 nop
_Thread_Finalize_life_change(
4000b660: f4 1e 20 c0 ldd [ %i0 + 0xc0 ], %i2
_Thread_queue_Extract_with_proxy( the_thread );
4000b664: 40 00 0b d1 call 4000e5a8 <_Thread_queue_Extract_with_proxy>
4000b668: 90 10 00 18 mov %i0, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b66c: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000b670: c2 27 bf fc st %g1, [ %fp + -4 ]
4000b674: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
4000b678: 40 00 02 58 call 4000bfd8 <_Watchdog_Remove>
4000b67c: 92 06 20 68 add %i0, 0x68, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000b680: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b684: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b688: 01 00 00 00 nop
_Thread_Raise_real_priority( the_thread, priority );
4000b68c: 92 10 00 1a mov %i2, %o1
4000b690: 94 10 00 1b mov %i3, %o2
4000b694: 7f ff fe 2e call 4000af4c <_Thread_Raise_real_priority>
4000b698: 90 10 00 18 mov %i0, %o0
_Thread_Remove_life_change_request( the_thread );
4000b69c: 7f ff fe 17 call 4000aef8 <_Thread_Remove_life_change_request>
4000b6a0: 90 10 00 18 mov %i0, %o0
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000b6a4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
if ( disable_level == 1 ) {
4000b6a8: 80 a0 60 01 cmp %g1, 1
4000b6ac: 12 bf ff da bne 4000b614 <_Thread_Restart_other+0x78>
4000b6b0: 82 00 7f ff add %g1, -1, %g1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b6b4: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000b6b8: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
4000b6bc: 80 a0 a0 00 cmp %g2, 0
4000b6c0: 12 80 00 14 bne 4000b710 <_Thread_Restart_other+0x174> <== ALWAYS TAKEN
4000b6c4: 92 10 00 01 mov %g1, %o1
cpu_self->thread_dispatch_disable_level = 0;
4000b6c8: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b6cc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b6d0: 01 00 00 00 nop
return true;
4000b6d4: b0 10 20 01 mov 1, %i0 ! 1 <_TLS_Alignment>
4000b6d8: b0 0e 20 ff and %i0, 0xff, %i0
}
4000b6dc: 81 c7 e0 08 ret
4000b6e0: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000b6e4: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b6e8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b6ec: 01 00 00 00 nop
return false;
4000b6f0: b0 10 20 00 clr %i0 ! 0 <PROM_START>
4000b6f4: b0 0e 20 ff and %i0, 0xff, %i0
}
4000b6f8: 81 c7 e0 08 ret
4000b6fc: 81 e8 00 00 restore
_Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING );
4000b700: 13 00 00 80 sethi %hi(0x20000), %o1
4000b704: 40 00 00 5f call 4000b880 <_Thread_Set_state_locked>
4000b708: 90 10 00 18 mov %i0, %o0
4000b70c: 30 bf ff d2 b,a 4000b654 <_Thread_Restart_other+0xb8>
_Thread_Do_dispatch( cpu_self, level );
4000b710: c2 27 bf fc st %g1, [ %fp + -4 ]
4000b714: 7f ff f9 32 call 40009bdc <_Thread_Do_dispatch>
4000b718: 90 10 00 1d mov %i5, %o0
4000b71c: 10 bf ff ec b 4000b6cc <_Thread_Restart_other+0x130>
4000b720: c2 07 bf fc ld [ %fp + -4 ], %g1
4000b724 <_Thread_Restart_self>:
void _Thread_Restart_self(
Thread_Control *executing,
const Thread_Entry_information *entry,
ISR_lock_Context *lock_context
)
{
4000b724: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_clear_priority_updates( &queue_context );
_Thread_State_acquire_critical( executing, lock_context );
executing->Start.Entry = *entry;
4000b728: c2 06 40 00 ld [ %i1 ], %g1
<== NOT EXECUTED
4000b72c: c2 26 20 a0 st %g1, [ %i0 + 0xa0 ]
<== NOT EXECUTED
4000b730: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000b734: c2 06 60 04 ld [ %i1 + 4 ], %g1
<== NOT EXECUTED
4000b738: c2 26 20 a4 st %g1, [ %i0 + 0xa4 ]
<== NOT EXECUTED
state |= set;
4000b73c: c2 06 21 70 ld [ %i0 + 0x170 ], %g1
<== NOT EXECUTED
executing->Start.Entry = *entry;
4000b740: c4 06 60 08 ld [ %i1 + 8 ], %g2
<== NOT EXECUTED
state |= set;
4000b744: 82 10 60 02 or %g1, 2, %g1
<== NOT EXECUTED
executing->Start.Entry = *entry;
4000b748: c4 26 20 a8 st %g2, [ %i0 + 0xa8 ]
<== NOT EXECUTED
the_thread->Life.state = state;
4000b74c: c2 26 21 70 st %g1, [ %i0 + 0x170 ]
<== NOT EXECUTED
4000b750: 7f ff fe 23 call 4000afdc <_Thread_Change_life_locked.part.37>
<== NOT EXECUTED
4000b754: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000b758: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000b75c: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000b760: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000b764: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000b768: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b76c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b770: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b774: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( lock_context );
4000b778: c2 26 80 00 st %g1, [ %i2 ]
4000b77c: c4 1e 20 c0 ldd [ %i0 + 0xc0 ], %g2
4000b780: c4 3e 20 30 std %g2, [ %i0 + 0x30 ]
_Thread_Priority_changed(
4000b784: 94 10 20 00 clr %o2
4000b788: 96 07 bf dc add %fp, -36, %o3
4000b78c: 92 06 20 20 add %i0, 0x20, %o1
4000b790: 7f ff f8 b0 call 40009a50 <_Thread_Priority_changed>
4000b794: 90 10 00 18 mov %i0, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000b798: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b79c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b7a0: 01 00 00 00 nop
false,
&queue_context
);
_Thread_Wait_release_default( executing, lock_context );
_Thread_Priority_update( &queue_context );
4000b7a4: 7f ff f8 b2 call 40009a6c <_Thread_Priority_update>
4000b7a8: 90 07 bf dc add %fp, -36, %o0
_Thread_Dispatch_direct( cpu_self );
4000b7ac: 7f ff f9 54 call 40009cfc <_Thread_Dispatch_direct>
4000b7b0: 90 10 00 1d mov %i5, %o0
4000b7b4: 01 00 00 00 nop
<== NOT EXECUTED
4000b9cc <_Thread_Set_life_protection>:
Thread_Life_state _Thread_Set_life_protection( Thread_Life_state state )
{
return _Thread_Change_life(
4000b9cc: 92 0a 20 01 and %o0, 1, %o1
<== NOT EXECUTED
4000b9d0: 94 10 20 00 clr %o2
4000b9d4: 90 10 20 01 mov 1, %o0
4000b9d8: 82 13 c0 00 mov %o7, %g1
4000b9dc: 7f ff ff d0 call 4000b91c <_Thread_Change_life>
4000b9e0: 9e 10 40 00 mov %g1, %o7
4000a030 <_Thread_Set_name>:
Status_Control _Thread_Set_name(
Thread_Control *the_thread,
const char *name
)
{
4000a030: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
size_t length;
length = strlcpy(
4000a034: 03 10 00 3e sethi %hi(0x4000f800), %g1
<== NOT EXECUTED
4000a038: d0 06 20 18 ld [ %i0 + 0x18 ], %o0
<== NOT EXECUTED
4000a03c: fa 00 61 c0 ld [ %g1 + 0x1c0 ], %i5
<== NOT EXECUTED
4000a040: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000a044: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
4000a048: 40 00 12 33 call 4000e914 <strlcpy>
<== NOT EXECUTED
4000a04c: 33 00 00 08 sethi %hi(0x2000), %i1
<== NOT EXECUTED
name,
_Thread_Maximum_name_size
);
if ( length >= _Thread_Maximum_name_size ) {
return STATUS_RESULT_TOO_LARGE;
4000a050: b0 10 20 00 clr %i0
if ( length >= _Thread_Maximum_name_size ) {
4000a054: 80 a7 40 08 cmp %i5, %o0
4000a058: 08 80 00 04 bleu 4000a068 <_Thread_Set_name+0x38>
4000a05c: b2 16 62 0d or %i1, 0x20d, %i1
}
return STATUS_SUCCESSFUL;
4000a060: b0 10 20 00 clr %i0
4000a064: b2 10 20 00 clr %i1
}
4000a068: 81 c7 e0 08 ret
4000a06c: 81 e8 00 00 restore
4000ba1c <_Thread_Set_state>:
States_Control _Thread_Set_state(
Thread_Control *the_thread,
States_Control state
)
{
4000ba1c: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
4000ba20: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000ba24: 91 d0 20 09 ta 9
<== NOT EXECUTED
previous_state = the_thread->current_state;
4000ba28: f0 06 20 1c ld [ %i0 + 0x1c ], %i0
4000ba2c: b2 16 40 18 or %i1, %i0, %i1
if ( _States_Is_ready( previous_state ) ) {
4000ba30: 80 a6 20 00 cmp %i0, 0
4000ba34: 12 80 00 09 bne 4000ba58 <_Thread_Set_state+0x3c>
4000ba38: f2 22 60 1c st %i1, [ %o1 + 0x1c ]
4000ba3c: d4 02 60 38 ld [ %o1 + 0x38 ], %o2
4000ba40: 11 10 00 63 sethi %hi(0x40018c00), %o0
4000ba44: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 40018dc8 <_Scheduler_Table>
4000ba48: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
4000ba4c: 9f c0 80 00 call %g2
4000ba50: c2 27 bf fc st %g1, [ %fp + -4 ]
4000ba54: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ba58: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ba5c: 01 00 00 00 nop
_Thread_State_acquire( the_thread, &lock_context );
previous_state = _Thread_Set_state_locked( the_thread, state );
_Thread_State_release( the_thread, &lock_context );
return previous_state;
}
4000ba60: 81 c7 e0 08 ret
4000ba64: 81 e8 00 00 restore
4000b9e4 <_Thread_Set_state_locked>:
States_Control _Thread_Set_state_locked(
Thread_Control *the_thread,
States_Control state
)
{
4000b9e4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
4000b9e8: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
States_Control next_state;
_Assert( state != 0 );
_Assert( _Thread_State_is_owner( the_thread ) );
previous_state = the_thread->current_state;
4000b9ec: f0 06 20 1c ld [ %i0 + 0x1c ], %i0
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE States_Control _States_Set (
States_Control states_to_set,
States_Control current_state
)
{
return (current_state | states_to_set);
4000b9f0: b2 16 00 19 or %i0, %i1, %i1
<== NOT EXECUTED
next_state = _States_Set( state, previous_state);
the_thread->current_state = next_state;
if ( _States_Is_ready( previous_state ) ) {
4000b9f4: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4000b9f8: 12 80 00 07 bne 4000ba14 <_Thread_Set_state_locked+0x30>
<== NOT EXECUTED
4000b9fc: f2 22 60 1c st %i1, [ %o1 + 0x1c ]
<== NOT EXECUTED
( *scheduler->Operations.block )(
4000ba00: 11 10 00 63 sethi %hi(0x40018c00), %o0
<== NOT EXECUTED
4000ba04: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 40018dc8 <_Scheduler_Table>
<== NOT EXECUTED
4000ba08: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
<== NOT EXECUTED
4000ba0c: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000ba10: d4 02 60 38 ld [ %o1 + 0x38 ], %o2
<== NOT EXECUTED
_Scheduler_Block( the_thread );
}
return previous_state;
}
4000ba14: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ba18: 81 e8 00 00 restore
<== NOT EXECUTED
4000ba68 <_Thread_Stack_Allocate>:
size_t _Thread_Stack_Allocate(
Thread_Control *the_thread,
size_t stack_size
)
{
4000ba68: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
return rtems_minimum_stack_size;
4000ba6c: 03 10 00 6c sethi %hi(0x4001b000), %g1
<== NOT EXECUTED
4000ba70: fa 00 63 40 ld [ %g1 + 0x340 ], %i5 ! 4001b340 <_data_load_start>
<== NOT EXECUTED
4000ba74: 80 a7 40 19 cmp %i5, %i1
<== NOT EXECUTED
4000ba78: 2a 80 00 02 bcs,a 4000ba80 <_Thread_Stack_Allocate+0x18>
<== NOT EXECUTED
4000ba7c: ba 10 00 19 mov %i1, %i5
<== NOT EXECUTED
void *stack_addr = 0;
size_t the_stack_size;
rtems_stack_allocate_hook stack_allocate_hook =
4000ba80: 03 10 00 63 sethi %hi(0x40018c00), %g1
rtems_configuration_get_stack_allocate_hook();
the_stack_size = _Stack_Ensure_minimum( stack_size );
stack_addr = (*stack_allocate_hook)( the_stack_size );
4000ba84: c2 00 61 10 ld [ %g1 + 0x110 ], %g1 ! 40018d10 <Configuration+0x28>
4000ba88: 9f c0 40 00 call %g1
4000ba8c: 90 10 00 1d mov %i5, %o0
if ( !stack_addr )
the_stack_size = 0;
4000ba90: 80 a0 00 08 cmp %g0, %o0
the_thread->Start.stack = stack_addr;
4000ba94: d0 26 20 d8 st %o0, [ %i0 + 0xd8 ]
the_stack_size = 0;
4000ba98: b0 60 20 00 subx %g0, 0, %i0
return the_stack_size;
}
4000ba9c: b0 0f 40 18 and %i5, %i0, %i0
4000baa0: 81 c7 e0 08 ret
4000baa4: 81 e8 00 00 restore
4000baa8 <_Thread_Stack_Free>:
#include <rtems/config.h>
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
4000baa8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
#if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
/*
* If the API provided the stack space, then don't free it.
*/
if ( !the_thread->Start.core_allocated_stack )
4000baac: c2 0e 20 c8 ldub [ %i0 + 0xc8 ], %g1
<== NOT EXECUTED
4000bab0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
rtems_stack_free_hook stack_free_hook =
4000bab4: 03 10 00 63 sethi %hi(0x40018c00), %g1
<== NOT EXECUTED
if ( !the_thread->Start.core_allocated_stack )
4000bab8: 02 80 00 04 be 4000bac8 <_Thread_Stack_Free+0x20>
<== NOT EXECUTED
4000babc: c2 00 61 14 ld [ %g1 + 0x114 ], %g1 ! 40018d14 <Configuration+0x2c>
* Call ONLY the CPU table stack free hook, or the
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
(*stack_free_hook)( the_thread->Start.Initial_stack.area );
4000bac0: 9f c0 40 00 call %g1
4000bac4: d0 06 20 d0 ld [ %i0 + 0xd0 ], %o0
}
4000bac8: 81 c7 e0 08 ret
4000bacc: 81 e8 00 00 restore
4000baec <_Thread_Start>:
bool _Thread_Start(
Thread_Control *the_thread,
const Thread_Entry_information *entry,
ISR_lock_Context *lock_context
)
{
4000baec: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
Per_CPU_Control *cpu_self;
_Thread_State_acquire_critical( the_thread, lock_context );
if ( !_States_Is_dormant( the_thread->current_state ) ) {
4000baf0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4000baf4: 80 a0 60 00 cmp %g1, 0
4000baf8: 26 80 00 09 bl,a 4000bb1c <_Thread_Start+0x30>
<== ALWAYS TAKEN
4000bafc: c2 06 40 00 ld [ %i1 ], %g1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000bb00: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000bb04: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000bb08: 01 00 00 00 nop
_Thread_State_release( the_thread, lock_context );
return false;
4000bb0c: b0 10 20 00 clr %i0 ! 0 <PROM_START>
_User_extensions_Thread_start( the_thread );
_Thread_Dispatch_enable( cpu_self );
return true;
}
4000bb10: b0 0e 20 01 and %i0, 1, %i0
4000bb14: 81 c7 e0 08 ret
4000bb18: 81 e8 00 00 restore
the_thread->Start.Entry = *entry;
4000bb1c: c2 26 20 a0 st %g1, [ %i0 + 0xa0 ]
_Thread_Load_environment( the_thread );
4000bb20: 90 10 00 18 mov %i0, %o0
the_thread->Start.Entry = *entry;
4000bb24: c2 06 60 04 ld [ %i1 + 4 ], %g1
4000bb28: c2 26 20 a4 st %g1, [ %i0 + 0xa4 ]
4000bb2c: c2 06 60 08 ld [ %i1 + 8 ], %g1
_Thread_Load_environment( the_thread );
4000bb30: 7f ff fb 2d call 4000a7e4 <_Thread_Load_environment>
4000bb34: c2 26 20 a8 st %g1, [ %i0 + 0xa8 ]
_Thread_Clear_state_locked( the_thread, STATES_ALL_SET );
4000bb38: 92 10 3f ff mov -1, %o1
4000bb3c: 40 00 0a 84 call 4000e54c <_Thread_Clear_state_locked>
4000bb40: 90 10 00 18 mov %i0, %o0
disable_level = cpu_self->thread_dispatch_disable_level;
4000bb44: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000bb48: 82 00 60 01 inc %g1
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000bb4c: ba 10 00 06 mov %g6, %i5
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000bb50: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000bb54: c2 06 80 00 ld [ %i2 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000bb58: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000bb5c: 01 00 00 00 nop
_User_extensions_Iterate(
4000bb60: 94 10 20 00 clr %o2 ! 0 <PROM_START>
4000bb64: 90 10 00 18 mov %i0, %o0
4000bb68: 13 10 00 2f sethi %hi(0x4000bc00), %o1
4000bb6c: 40 00 00 99 call 4000bdd0 <_User_extensions_Iterate>
4000bb70: 92 12 60 f0 or %o1, 0xf0, %o1 ! 4000bcf0 <_User_extensions_Thread_start_visitor>
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000bb74: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
if ( disable_level == 1 ) {
4000bb78: 80 a0 60 01 cmp %g1, 1
4000bb7c: 02 80 00 07 be 4000bb98 <_Thread_Start+0xac>
4000bb80: 82 00 7f ff add %g1, -1, %g1
return true;
4000bb84: b0 10 20 01 mov 1, %i0
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000bb88: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
}
4000bb8c: b0 0e 20 01 and %i0, 1, %i0
4000bb90: 81 c7 e0 08 ret
4000bb94: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000bb98: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000bb9c: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
4000bba0: 80 a0 a0 00 cmp %g2, 0
4000bba4: 12 80 00 07 bne 4000bbc0 <_Thread_Start+0xd4>
4000bba8: 92 10 00 01 mov %g1, %o1
cpu_self->thread_dispatch_disable_level = 0;
4000bbac: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000bbb0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000bbb4: 01 00 00 00 nop
return true;
4000bbb8: 10 bf ff d6 b 4000bb10 <_Thread_Start+0x24>
4000bbbc: b0 10 20 01 mov 1, %i0 ! 1 <_TLS_Alignment>
_Thread_Do_dispatch( cpu_self, level );
4000bbc0: c2 27 bf fc st %g1, [ %fp + -4 ]
4000bbc4: 40 00 0a 84 call 4000e5d4 <_Thread_Do_dispatch>
4000bbc8: 90 10 00 1d mov %i5, %o0
4000bbcc: 10 bf ff f9 b 4000bbb0 <_Thread_Start+0xc4>
4000bbd0: c2 07 bf fc ld [ %fp + -4 ], %g1
4000bad0 <_Thread_Start_multitasking>:
#include <rtems/score/threadimpl.h>
#include <rtems/score/assert.h>
void _Thread_Start_multitasking( void )
{
4000bad0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
heir = cpu_self->heir;
4000bad4: c4 01 a0 24 ld [ %g6 + 0x24 ], %g2
<== NOT EXECUTED
cpu_self->dispatch_necessary = false;
4000bad8: c0 29 a0 1c clrb [ %g6 + 0x1c ]
<== NOT EXECUTED
_CPU_Context_Set_is_executing( &trash, true );
_CPU_Context_switch( &trash, &heir->Registers );
RTEMS_UNREACHABLE();
}
#else
_CPU_Context_Restart_self( &heir->Registers );
4000badc: 90 00 a0 f0 add %g2, 0xf0, %o0
4000bae0: 40 00 03 91 call 4000c924 <_CPU_Context_restore>
4000bae4: c4 21 a0 20 st %g2, [ %g6 + 0x20 ]
4000bae8: 01 00 00 00 nop
<== NOT EXECUTED
4000ef24 <_Thread_Timeout>:
the_thread = RTEMS_CONTAINER_OF(
the_watchdog,
Thread_Control,
Timer.Watchdog
);
_Thread_Continue( the_thread, STATUS_TIMEOUT );
4000ef24: 15 00 00 1d sethi %hi(0x7400), %o2
<== NOT EXECUTED
4000ef28: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000ef2c: 94 12 a0 06 or %o2, 6, %o2
<== NOT EXECUTED
4000ef30: 90 02 3f 98 add %o0, -104, %o0
<== NOT EXECUTED
4000ef34: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000ef38: 7f ff ff ce call 4000ee70 <_Thread_Continue>
4000ef3c: 9e 10 40 00 mov %g1, %o7
4000ce84 <_Thread_Wait_get_id>:
if ( _States_Is_waiting_for_rpc_reply( the_thread->current_state ) ) {
return the_thread->Wait.remote_id;
}
#endif
queue = the_thread->Wait.queue;
4000ce84: c2 02 20 54 ld [ %o0 + 0x54 ], %g1
<== NOT EXECUTED
if ( queue != NULL && queue->name == _Thread_queue_Object_name ) {
4000ce88: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000ce8c: 02 80 00 08 be 4000ceac <_Thread_Wait_get_id+0x28>
<== NOT EXECUTED
4000ce90: 90 10 20 00 clr %o0
4000ce94: c6 00 60 08 ld [ %g1 + 8 ], %g3
4000ce98: 05 10 00 44 sethi %hi(0x40011000), %g2
4000ce9c: 84 10 a2 80 or %g2, 0x280, %g2 ! 40011280 <_Thread_queue_Object_name>
4000cea0: 80 a0 c0 02 cmp %g3, %g2
4000cea4: 02 80 00 04 be 4000ceb4 <_Thread_Wait_get_id+0x30>
<== ALWAYS TAKEN
4000cea8: 01 00 00 00 nop
queue_object = THREAD_QUEUE_QUEUE_TO_OBJECT( queue );
return queue_object->Object.id;
}
return 0;
}
4000ceac: 81 c3 e0 08 retl
4000ceb0: 01 00 00 00 nop
4000ceb4: 81 c3 e0 08 retl
4000ceb8: d0 00 7f f8 ld [ %g1 + -8 ], %o0
4000bbd4 <_Thread_Yield>:
#include <rtems/score/threadimpl.h>
#include <rtems/score/schedulerimpl.h>
void _Thread_Yield( Thread_Control *executing )
{
4000bbd4: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000bbd8: 91 d0 20 09 ta 9
<== NOT EXECUTED
ISR_lock_Context lock_context;
_Thread_State_acquire( executing, &lock_context );
if ( _States_Is_ready( executing->current_state ) ) {
4000bbdc: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
4000bbe0: 80 a0 a0 00 cmp %g2, 0
4000bbe4: 12 80 00 09 bne 4000bc08 <_Thread_Yield+0x34>
<== NEVER TAKEN
4000bbe8: 11 10 00 63 sethi %hi(0x40018c00), %o0
( *scheduler->Operations.yield )(
4000bbec: d4 06 20 38 ld [ %i0 + 0x38 ], %o2
4000bbf0: 90 12 21 c8 or %o0, 0x1c8, %o0
4000bbf4: c4 02 20 0c ld [ %o0 + 0xc ], %g2
4000bbf8: c2 27 bf fc st %g1, [ %fp + -4 ]
4000bbfc: 9f c0 80 00 call %g2
4000bc00: 92 10 00 18 mov %i0, %o1
4000bc04: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000bc08: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000bc0c: 01 00 00 00 nop
_Scheduler_Yield( executing );
}
_Thread_State_release( executing, &lock_context );
}
4000bc10: 81 c7 e0 08 ret
4000bc14: 81 e8 00 00 restore
40011dec <_Thread_queue_Add_timeout_ticks>:
Thread_queue_Queue *queue,
Thread_Control *the_thread,
Per_CPU_Control *cpu_self,
Thread_queue_Context *queue_context
)
{
40011dec: 9d e3 bf 98 save %sp, -104, %sp
Watchdog_Interval ticks;
ticks = queue_context->Timeout.ticks;
40011df0: c4 06 e0 0c ld [ %i3 + 0xc ], %g2
if ( ticks != WATCHDOG_NO_TIMEOUT ) {
40011df4: 80 a0 a0 00 cmp %g2, 0
40011df8: 12 80 00 04 bne 40011e08 <_Thread_queue_Add_timeout_ticks+0x1c>
40011dfc: 01 00 00 00 nop
the_thread,
cpu_self,
queue_context->Timeout.ticks
);
}
}
40011e00: 81 c7 e0 08 ret
40011e04: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40011e08: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
40011e0c: c2 27 bf fc st %g1, [ %fp + -4 ]
the_thread->Timer.Watchdog.routine = _Thread_Timeout;
40011e10: 07 10 00 4a sethi %hi(0x40012800), %g3
expire = ticks + cpu->Watchdog.ticks;
40011e14: d4 1e a0 30 ldd [ %i2 + 0x30 ], %o2
&cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ];
40011e18: 90 06 a0 38 add %i2, 0x38, %o0
the_thread->Timer.Watchdog.routine = _Thread_Timeout;
40011e1c: 86 10 e0 70 or %g3, 0x70, %g3
the_thread->Timer.header =
40011e20: d0 26 60 60 st %o0, [ %i1 + 0x60 ]
_Watchdog_Insert(header, the_watchdog, expire);
40011e24: b6 82 c0 02 addcc %o3, %g2, %i3
the_thread->Timer.Watchdog.routine = _Thread_Timeout;
40011e28: c6 26 60 78 st %g3, [ %i1 + 0x78 ]
40011e2c: b4 42 a0 00 addx %o2, 0, %i2
40011e30: 92 06 60 68 add %i1, 0x68, %o1
40011e34: 94 10 00 1a mov %i2, %o2
40011e38: 40 00 03 93 call 40012c84 <_Watchdog_Insert>
40011e3c: 96 10 00 1b mov %i3, %o3
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40011e40: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40011e44: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40011e48: 01 00 00 00 nop
40011e4c: 81 c7 e0 08 ret
40011e50: 81 e8 00 00 restore
4000a9a4 <_Thread_queue_Deadlock_fatal>:
{
4000a9a4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_Internal_error( INTERNAL_ERROR_THREAD_QUEUE_DEADLOCK );
4000a9a8: 7f ff f3 bf call 400078a4 <_Internal_error>
<== NOT EXECUTED
4000a9ac: 90 10 20 1c mov 0x1c, %o0
<== NOT EXECUTED
4000a9b0: 01 00 00 00 nop
<== NOT EXECUTED
40010eb8 <_Thread_queue_Deadlock_status>:
the_thread->Wait.return_code = STATUS_DEADLOCK;
40010eb8: 03 00 00 0b sethi %hi(0x2c00), %g1
<== NOT EXECUTED
40010ebc: 82 10 61 0e or %g1, 0x10e, %g1 ! 2d0e <_Configuration_Interrupt_stack_size+0x1d0e>
<== NOT EXECUTED
}
40010ec0: 81 c3 e0 08 retl
<== NOT EXECUTED
40010ec4: c2 22 20 4c st %g1, [ %o0 + 0x4c ]
4000a9b4 <_Thread_queue_Enqueue>:
{
4000a9b4: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
the_thread->Wait.queue = queue;
4000a9b8: f0 26 a0 54 st %i0, [ %i2 + 0x54 ]
<== NOT EXECUTED
4000a9bc: 10 80 00 08 b 4000a9dc <_Thread_queue_Enqueue+0x28>
<== NOT EXECUTED
4000a9c0: 82 10 00 18 mov %i0, %g1
<== NOT EXECUTED
if ( owner == the_thread ) {
4000a9c4: 22 80 00 44 be,a 4000aad4 <_Thread_queue_Enqueue+0x120>
4000a9c8: c0 26 a0 54 clr [ %i2 + 0x54 ]
queue = owner->Wait.queue;
4000a9cc: c2 00 60 54 ld [ %g1 + 0x54 ], %g1
} while ( queue != NULL );
4000a9d0: 80 a0 60 00 cmp %g1, 0
4000a9d4: 22 80 00 07 be,a 4000a9f0 <_Thread_queue_Enqueue+0x3c>
4000a9d8: c0 26 e0 14 clr [ %i3 + 0x14 ]
owner = queue->owner;
4000a9dc: c2 00 60 04 ld [ %g1 + 4 ], %g1
if ( owner == NULL ) {
4000a9e0: 80 a0 60 00 cmp %g1, 0
4000a9e4: 12 bf ff f8 bne 4000a9c4 <_Thread_queue_Enqueue+0x10>
4000a9e8: 80 a6 80 01 cmp %i2, %g1
RTEMS_INLINE_ROUTINE void _Thread_queue_Context_clear_priority_updates(
Thread_queue_Context *queue_context
)
{
queue_context->Priority.update_count = 0;
4000a9ec: c0 26 e0 14 clr [ %i3 + 0x14 ]
( *operations->enqueue )( queue, the_thread, queue_context );
4000a9f0: 94 10 00 1b mov %i3, %o2
the_thread->Wait.operations = operations;
4000a9f4: f2 26 a0 58 st %i1, [ %i2 + 0x58 ]
4000a9f8: 92 10 00 1a mov %i2, %o1
4000a9fc: c2 06 60 04 ld [ %i1 + 4 ], %g1
4000aa00: 9f c0 40 00 call %g1
4000aa04: 90 10 00 18 mov %i0, %o0
the_thread->Wait.flags = flags;
4000aa08: 84 10 24 01 mov 0x401, %g2
disable_level = cpu_self->thread_dispatch_disable_level;
4000aa0c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
the_thread->Wait.return_code = STATUS_SUCCESSFUL;
4000aa10: c0 26 a0 4c clr [ %i2 + 0x4c ]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000aa14: 82 00 60 01 inc %g1
4000aa18: c4 26 a0 50 st %g2, [ %i2 + 0x50 ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000aa1c: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000aa20: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000aa24: c2 06 c0 00 ld [ %i3 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000aa28: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000aa2c: 01 00 00 00 nop
( *queue_context->enqueue_callout )(
4000aa30: c2 06 e0 08 ld [ %i3 + 8 ], %g1
4000aa34: 96 10 00 1b mov %i3, %o3
4000aa38: 94 10 00 06 mov %g6, %o2
4000aa3c: 92 10 00 1a mov %i2, %o1
4000aa40: 9f c0 40 00 call %g1
4000aa44: 90 10 00 18 mov %i0, %o0
_Thread_Set_state( the_thread, queue_context->thread_state );
4000aa48: d2 06 e0 04 ld [ %i3 + 4 ], %o1
4000aa4c: 40 00 03 f4 call 4000ba1c <_Thread_Set_state>
4000aa50: 90 10 00 1a mov %i2, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000aa54: 91 d0 20 09 ta 9
<== NOT EXECUTED
bool success = ( the_thread->Wait.flags == expected_flags );
4000aa58: c4 06 a0 50 ld [ %i2 + 0x50 ], %g2
if ( success ) {
4000aa5c: 80 a0 a4 01 cmp %g2, 0x401
4000aa60: 02 80 00 28 be 4000ab00 <_Thread_queue_Enqueue+0x14c>
4000aa64: 86 10 24 02 mov 0x402, %g3
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000aa68: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000aa6c: 01 00 00 00 nop
if ( !success ) {
4000aa70: 80 a0 a4 01 cmp %g2, 0x401
4000aa74: 12 80 00 07 bne 4000aa90 <_Thread_queue_Enqueue+0xdc>
<== ALWAYS TAKEN
4000aa78: 01 00 00 00 nop
_Thread_Priority_update( queue_context );
4000aa7c: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
4000aa80: 40 00 0e 92 call 4000e4c8 <_Thread_Priority_update>
4000aa84: b0 10 00 1d mov %i5, %i0
_Thread_Dispatch_direct( cpu_self );
4000aa88: 40 00 0f 1b call 4000e6f4 <_Thread_Dispatch_direct>
4000aa8c: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000aa90: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000aa94: c2 27 bf fc st %g1, [ %fp + -4 ]
4000aa98: d0 06 a0 60 ld [ %i2 + 0x60 ], %o0
4000aa9c: 40 00 05 4c call 4000bfcc <_Watchdog_Remove>
4000aaa0: 92 06 a0 68 add %i2, 0x68, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000aaa4: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000aaa8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000aaac: 01 00 00 00 nop
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4000aab0: 13 0c 00 57 sethi %hi(0x30015c00), %o1
4000aab4: 90 10 00 1a mov %i2, %o0
4000aab8: 40 00 0e b1 call 4000e57c <_Thread_Clear_state>
4000aabc: 92 12 63 ff or %o1, 0x3ff, %o1
_Thread_Priority_update( queue_context );
4000aac0: 90 10 00 1b mov %i3, %o0
4000aac4: 40 00 0e 81 call 4000e4c8 <_Thread_Priority_update>
4000aac8: b0 10 00 1d mov %i5, %i0
_Thread_Dispatch_direct( cpu_self );
4000aacc: 40 00 0f 0a call 4000e6f4 <_Thread_Dispatch_direct>
4000aad0: 81 e8 00 00 restore
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4000aad4: 03 10 00 66 sethi %hi(0x40019800), %g1
<== NOT EXECUTED
4000aad8: 82 10 61 50 or %g1, 0x150, %g1 ! 40019950 <_Thread_queue_Operations_default>
<== NOT EXECUTED
4000aadc: c2 26 a0 58 st %g1, [ %i2 + 0x58 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000aae0: c2 06 c0 00 ld [ %i3 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000aae4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000aae8: 01 00 00 00 nop
( *queue_context->deadlock_callout )( the_thread );
4000aaec: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1
4000aaf0: 9f c0 40 00 call %g1
4000aaf4: 90 10 00 1a mov %i2, %o0
}
4000aaf8: 81 c7 e0 08 ret
4000aafc: 81 e8 00 00 restore
the_thread->Wait.flags = desired_flags;
4000ab00: c6 26 a0 50 st %g3, [ %i2 + 0x50 ]
<== NOT EXECUTED
4000ab04: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ab08: 01 00 00 00 nop
if ( !success ) {
4000ab0c: 80 a0 a4 01 cmp %g2, 0x401
4000ab10: 22 bf ff dc be,a 4000aa80 <_Thread_queue_Enqueue+0xcc> <== ALWAYS TAKEN
4000ab14: 90 10 00 1b mov %i3, %o0
4000ab18: 30 bf ff de b,a 4000aa90 <_Thread_queue_Enqueue+0xdc> <== NOT EXECUTED
4000ab8c <_Thread_queue_Extract>:
&queue_context->Lock_context.Lock_context
);
}
void _Thread_queue_Extract( Thread_Control *the_thread )
{
4000ab8c: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
4000ab90: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000ab94: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
4000ab98: c2 27 bf dc st %g1, [ %fp + -36 ]
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_clear_priority_updates( &queue_context );
_Thread_Wait_acquire( the_thread, &queue_context );
queue = the_thread->Wait.queue;
4000ab9c: d0 06 20 54 ld [ %i0 + 0x54 ], %o0
if ( queue != NULL ) {
4000aba0: 80 a2 20 00 cmp %o0, 0
4000aba4: 02 80 00 1c be 4000ac14 <_Thread_queue_Extract+0x88>
4000aba8: 92 10 00 18 mov %i0, %o1
( *operations->extract )( queue, the_thread, queue_context );
4000abac: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
4000abb0: c2 00 60 08 ld [ %g1 + 8 ], %g1
4000abb4: 9f c0 40 00 call %g1
4000abb8: 94 07 bf dc add %fp, -36, %o2
if ( success ) {
4000abbc: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
4000abc0: 80 a0 64 01 cmp %g1, 0x401
the_thread->Wait.queue = NULL;
4000abc4: c0 26 20 54 clr [ %i0 + 0x54 ]
the_thread->Wait.flags = desired_flags;
4000abc8: 82 10 24 04 mov 0x404, %g1
if ( success ) {
4000abcc: 02 80 00 0a be 4000abf4 <_Thread_queue_Extract+0x68>
<== NEVER TAKEN
4000abd0: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4000abd4: 03 10 00 66 sethi %hi(0x40019800), %g1
4000abd8: 82 10 61 50 or %g1, 0x150, %g1 ! 40019950 <_Thread_queue_Operations_default>
4000abdc: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
4000abe0: 92 07 bf dc add %fp, -36, %o1
4000abe4: 7f ff ff 44 call 4000a8f4 <_Thread_queue_Unblock_critical.part.33>
4000abe8: 90 10 00 18 mov %i0, %o0
&queue_context.Lock_context.Lock_context
);
} else {
_Thread_Wait_release( the_thread, &queue_context );
}
}
4000abec: 81 c7 e0 08 ret
4000abf0: 81 e8 00 00 restore
4000abf4: 03 10 00 66 sethi %hi(0x40019800), %g1
<== NOT EXECUTED
4000abf8: 82 10 61 50 or %g1, 0x150, %g1 ! 40019950 <_Thread_queue_Operations_default>
<== NOT EXECUTED
4000abfc: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000ac00: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ac04: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ac08: 01 00 00 00 nop
<== NOT EXECUTED
4000ac0c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ac10: 81 e8 00 00 restore
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000ac14: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ac18: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ac1c: 01 00 00 00 nop
4000ac20: 81 c7 e0 08 ret
4000ac24: 81 e8 00 00 restore
400110b0 <_Thread_queue_Extract_critical>:
Thread_queue_Queue *queue,
const Thread_queue_Operations *operations,
Thread_Control *the_thread,
Thread_queue_Context *queue_context
)
{
400110b0: 9d e3 bf a0 save %sp, -96, %sp
( *operations->extract )( queue, the_thread, queue_context );
400110b4: c2 06 60 08 ld [ %i1 + 8 ], %g1
400110b8: 92 10 00 1a mov %i2, %o1
400110bc: 94 10 00 1b mov %i3, %o2
400110c0: 9f c0 40 00 call %g1
400110c4: 90 10 00 18 mov %i0, %o0
if ( success ) {
400110c8: c2 06 a0 50 ld [ %i2 + 0x50 ], %g1
400110cc: 80 a0 64 01 cmp %g1, 0x401
the_thread->Wait.queue = NULL;
400110d0: c0 26 a0 54 clr [ %i2 + 0x54 ]
the_thread->Wait.flags = desired_flags;
400110d4: 82 10 24 04 mov 0x404, %g1
if ( success ) {
400110d8: 02 80 00 08 be 400110f8 <_Thread_queue_Extract_critical+0x48>
400110dc: c2 26 a0 50 st %g1, [ %i2 + 0x50 ]
the_thread->Wait.operations = &_Thread_queue_Operations_default;
400110e0: 03 10 00 77 sethi %hi(0x4001dc00), %g1
400110e4: 82 10 63 08 or %g1, 0x308, %g1 ! 4001df08 <_Thread_queue_Operations_default>
400110e8: c2 26 a0 58 st %g1, [ %i2 + 0x58 ]
400110ec: b2 10 00 1b mov %i3, %i1
400110f0: 7f ff ff 46 call 40010e08 <_Thread_queue_Unblock_critical.part.33>
400110f4: 91 e8 00 1a restore %g0, %i2, %o0
400110f8: 03 10 00 77 sethi %hi(0x4001dc00), %g1
<== NOT EXECUTED
400110fc: 82 10 63 08 or %g1, 0x308, %g1 ! 4001df08 <_Thread_queue_Operations_default>
<== NOT EXECUTED
40011100: c2 26 a0 58 st %g1, [ %i2 + 0x58 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40011104: c2 06 c0 00 ld [ %i3 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40011108: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001110c: 01 00 00 00 nop
unblock,
queue,
the_thread,
&queue_context->Lock_context.Lock_context
);
}
40011110: 81 c7 e0 08 ret
40011114: 81 e8 00 00 restore
4000ab1c <_Thread_queue_Extract_locked>:
{
4000ab1c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
( *operations->extract )( queue, the_thread, queue_context );
4000ab20: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
4000ab24: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
4000ab28: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4000ab2c: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000ab30: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( success ) {
4000ab34: c2 06 a0 50 ld [ %i2 + 0x50 ], %g1
<== NOT EXECUTED
4000ab38: 80 a0 64 01 cmp %g1, 0x401
<== NOT EXECUTED
4000ab3c: 02 80 00 0b be 4000ab68 <_Thread_queue_Extract_locked+0x4c>
<== NOT EXECUTED
4000ab40: 82 10 24 04 mov 0x404, %g1
<== NOT EXECUTED
unblock = true;
4000ab44: b0 10 20 01 mov 1, %i0
<== NOT EXECUTED
the_thread->Wait.flags = flags;
4000ab48: c2 26 a0 50 st %g1, [ %i2 + 0x50 ]
<== NOT EXECUTED
return _Thread_queue_Make_ready_again( the_thread );
4000ab4c: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
the_thread->Wait.queue = NULL;
4000ab50: c0 26 a0 54 clr [ %i2 + 0x54 ]
<== NOT EXECUTED
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4000ab54: 03 10 00 66 sethi %hi(0x40019800), %g1
<== NOT EXECUTED
4000ab58: 82 10 61 50 or %g1, 0x150, %g1 ! 40019950 <_Thread_queue_Operations_default>
<== NOT EXECUTED
4000ab5c: c2 26 a0 58 st %g1, [ %i2 + 0x58 ]
<== NOT EXECUTED
}
4000ab60: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ab64: 81 e8 00 00 restore
<== NOT EXECUTED
unblock = false;
4000ab68: b0 10 20 00 clr %i0
<== NOT EXECUTED
the_thread->Wait.flags = desired_flags;
4000ab6c: c2 26 a0 50 st %g1, [ %i2 + 0x50 ]
<== NOT EXECUTED
return _Thread_queue_Make_ready_again( the_thread );
4000ab70: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
the_thread->Wait.queue = NULL;
4000ab74: c0 26 a0 54 clr [ %i2 + 0x54 ]
<== NOT EXECUTED
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4000ab78: 03 10 00 66 sethi %hi(0x40019800), %g1
<== NOT EXECUTED
4000ab7c: 82 10 61 50 or %g1, 0x150, %g1 ! 40019950 <_Thread_queue_Operations_default>
<== NOT EXECUTED
4000ab80: c2 26 a0 58 st %g1, [ %i2 + 0x58 ]
<== NOT EXECUTED
}
4000ab84: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ab88: 81 e8 00 00 restore
<== NOT EXECUTED
4000e720 <_Thread_queue_Extract_with_proxy>:
if ( proxy_extract_callout != NULL )
(*proxy_extract_callout)( the_thread, id );
}
#endif
_Thread_queue_Extract( the_thread );
4000e720: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000e724: 7f ff f1 1a call 4000ab8c <_Thread_queue_Extract>
<== NOT EXECUTED
4000e728: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40011200 <_Thread_queue_First>:
Thread_Control *_Thread_queue_First(
Thread_queue_Control *the_thread_queue,
const Thread_queue_Operations *operations
)
{
40011200: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40011204: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
40011208: d0 06 00 00 ld [ %i0 ], %o0
const Thread_queue_Operations *operations
)
{
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
if ( heads != NULL ) {
4001120c: 80 a2 20 00 cmp %o0, 0
40011210: 22 80 00 07 be,a 4001122c <_Thread_queue_First+0x2c>
40011214: b0 10 20 00 clr %i0
return ( *operations->first )( heads );
40011218: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
4001121c: 9f c0 80 00 call %g2
40011220: c2 27 bf fc st %g1, [ %fp + -4 ]
40011224: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
40011228: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001122c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40011230: 01 00 00 00 nop
_Thread_queue_Acquire( the_thread_queue, &queue_context );
the_thread = _Thread_queue_First_locked( the_thread_queue, operations );
_Thread_queue_Release( the_thread_queue, &queue_context );
return the_thread;
}
40011234: 81 c7 e0 08 ret
40011238: 81 e8 00 00 restore
4000e72c <_Thread_queue_Flush_critical>:
Thread_queue_Queue *queue,
const Thread_queue_Operations *operations,
Thread_queue_Flush_filter filter,
Thread_queue_Context *queue_context
)
{
4000e72c: 9d e3 bf 88 save %sp, -120, %sp
<== NOT EXECUTED
head->next = tail;
4000e730: a0 07 bf f8 add %fp, -8, %l0
<== NOT EXECUTED
tail->previous = head;
4000e734: 82 07 bf f4 add %fp, -12, %g1
<== NOT EXECUTED
head->previous = NULL;
4000e738: c0 27 bf f8 clr [ %fp + -8 ]
<== NOT EXECUTED
4000e73c: b8 10 00 18 mov %i0, %i4
<== NOT EXECUTED
head->next = tail;
4000e740: e0 27 bf f4 st %l0, [ %fp + -12 ]
<== NOT EXECUTED
tail->previous = head;
4000e744: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
while ( true ) {
Thread_queue_Heads *heads;
Thread_Control *first;
bool do_unblock;
heads = queue->heads;
4000e748: d0 06 00 00 ld [ %i0 ], %o0
<== NOT EXECUTED
owner = queue->owner;
4000e74c: e2 06 20 04 ld [ %i0 + 4 ], %l1
<== NOT EXECUTED
if ( heads == NULL ) {
4000e750: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e754: 12 80 00 16 bne 4000e7ac <_Thread_queue_Flush_critical+0x80>
<== NOT EXECUTED
4000e758: b0 10 20 00 clr %i0
4000e75c: 30 80 00 59 b,a 4000e8c0 <_Thread_queue_Flush_critical+0x194>
* updates, so clear it each time. We unconditionally do the priority
* update for the owner later if it exists.
*/
_Thread_queue_Context_clear_priority_updates( queue_context );
do_unblock = _Thread_queue_Extract_locked(
4000e760: 96 10 00 1b mov %i3, %o3
4000e764: 94 10 00 1d mov %i5, %o2
4000e768: 92 10 00 19 mov %i1, %o1
4000e76c: 7f ff f0 ec call 4000ab1c <_Thread_queue_Extract_locked>
4000e770: 90 10 00 1c mov %i4, %o0
queue,
operations,
first,
queue_context
);
if ( do_unblock ) {
4000e774: 80 a2 20 00 cmp %o0, 0
4000e778: 22 80 00 0a be,a 4000e7a0 <_Thread_queue_Flush_critical+0x74>
4000e77c: d0 07 00 00 ld [ %i4 ], %o0
4000e780: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
old_last = tail->previous;
4000e784: c4 07 bf fc ld [ %fp + -4 ], %g2
the_node->next = tail;
4000e788: e0 20 60 08 st %l0, [ %g1 + 8 ]
Scheduler_Node *scheduler_node;
scheduler_node = _Thread_Scheduler_get_home_node( first );
_Chain_Append_unprotected(
4000e78c: 86 00 60 08 add %g1, 8, %g3
tail->previous = the_node;
4000e790: c6 27 bf fc st %g3, [ %fp + -4 ]
old_last->next = the_node;
4000e794: c6 20 80 00 st %g3, [ %g2 ]
the_node->previous = old_last;
4000e798: c4 20 60 0c st %g2, [ %g1 + 0xc ]
heads = queue->heads;
4000e79c: d0 07 00 00 ld [ %i4 ], %o0
if ( heads == NULL ) {
4000e7a0: 80 a2 20 00 cmp %o0, 0
4000e7a4: 02 80 00 0b be 4000e7d0 <_Thread_queue_Flush_critical+0xa4>
4000e7a8: b0 06 20 01 inc %i0
first = ( *operations->first )( heads );
4000e7ac: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000e7b0: 9f c0 40 00 call %g1
4000e7b4: 01 00 00 00 nop
first = ( *filter )( first, queue, queue_context );
4000e7b8: 94 10 00 1b mov %i3, %o2
4000e7bc: 9f c6 80 00 call %i2
4000e7c0: 92 10 00 1c mov %i4, %o1
if ( first == NULL ) {
4000e7c4: ba 92 20 00 orcc %o0, 0, %i5
4000e7c8: 32 bf ff e6 bne,a 4000e760 <_Thread_queue_Flush_critical+0x34>
4000e7cc: c0 26 e0 14 clr [ %i3 + 0x14 ]
return _Chain_Immutable_head( the_chain )->next;
4000e7d0: c4 07 bf f4 ld [ %fp + -12 ], %g2
}
node = _Chain_First( &unblock );
tail = _Chain_Tail( &unblock );
if ( node != tail ) {
4000e7d4: 80 a0 80 10 cmp %g2, %l0
4000e7d8: 02 80 00 3a be 4000e8c0 <_Thread_queue_Flush_critical+0x194>
4000e7dc: 01 00 00 00 nop
disable_level = cpu_self->thread_dispatch_disable_level;
4000e7e0: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000e7e4: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000e7e8: b4 10 00 06 mov %g6, %i2
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000e7ec: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e7f0: c2 06 c0 00 ld [ %i3 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e7f4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e7f8: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4000e7fc: 37 0c 00 57 sethi %hi(0x30015c00), %i3
<== NOT EXECUTED
4000e800: b6 16 e3 ff or %i3, 0x3ff, %i3 ! 30015fff <RAM_SIZE+0x2fc15fff>
<== NOT EXECUTED
4000e804: f8 00 80 00 ld [ %g2 ], %i4
<== NOT EXECUTED
4000e808: fa 00 bf f8 ld [ %g2 + -8 ], %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e80c: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000e810: c2 27 bf ec st %g1, [ %fp + -20 ]
4000e814: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
4000e818: 7f ff f5 ed call 4000bfcc <_Watchdog_Remove>
4000e81c: 92 07 60 68 add %i5, 0x68, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e820: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e824: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e828: 01 00 00 00 nop
4000e82c: 92 10 00 1b mov %i3, %o1
4000e830: 7f ff ff 53 call 4000e57c <_Thread_Clear_state>
4000e834: 90 10 00 1d mov %i5, %o0
scheduler_node = SCHEDULER_NODE_OF_WAIT_PRIORITY_NODE( node );
the_thread = _Scheduler_Node_get_owner( scheduler_node );
_Thread_Remove_timer_and_unblock( the_thread, queue );
node = next;
} while ( node != tail );
4000e838: 80 a7 00 10 cmp %i4, %l0
4000e83c: 12 bf ff f2 bne 4000e804 <_Thread_queue_Flush_critical+0xd8>
4000e840: 84 10 00 1c mov %i4, %g2
if ( owner != NULL ) {
4000e844: 80 a4 60 00 cmp %l1, 0
4000e848: 02 80 00 0d be 4000e87c <_Thread_queue_Flush_critical+0x150>
4000e84c: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e850: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000e854: c2 27 bf ec st %g1, [ %fp + -20 ]
( *scheduler->Operations.update_priority )(
4000e858: 11 10 00 63 sethi %hi(0x40018c00), %o0
4000e85c: d4 04 60 38 ld [ %l1 + 0x38 ], %o2
4000e860: 90 12 21 c8 or %o0, 0x1c8, %o0
4000e864: c4 02 20 18 ld [ %o0 + 0x18 ], %g2
4000e868: 9f c0 80 00 call %g2
4000e86c: 92 10 00 11 mov %l1, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e870: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e874: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e878: 01 00 00 00 nop
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000e87c: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
if ( disable_level == 1 ) {
4000e880: 80 a0 60 01 cmp %g1, 1
4000e884: 02 80 00 05 be 4000e898 <_Thread_queue_Flush_critical+0x16c>
4000e888: 82 00 7f ff add %g1, -1, %g1
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000e88c: c2 26 a0 18 st %g1, [ %i2 + 0x18 ]
4000e890: 81 c7 e0 08 ret
4000e894: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e898: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000e89c: c4 0e a0 1c ldub [ %i2 + 0x1c ], %g2
4000e8a0: 80 a0 a0 00 cmp %g2, 0
4000e8a4: 12 80 00 0c bne 4000e8d4 <_Thread_queue_Flush_critical+0x1a8>
4000e8a8: 92 10 00 01 mov %g1, %o1
cpu_self->thread_dispatch_disable_level = 0;
4000e8ac: c0 26 a0 18 clr [ %i2 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e8b0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e8b4: 01 00 00 00 nop
4000e8b8: 81 c7 e0 08 ret
4000e8bc: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e8c0: c2 06 c0 00 ld [ %i3 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e8c4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e8c8: 01 00 00 00 nop
} else {
_Thread_queue_Queue_release( queue, &queue_context->Lock_context.Lock_context );
}
return flushed;
}
4000e8cc: 81 c7 e0 08 ret
4000e8d0: 81 e8 00 00 restore
_Thread_Do_dispatch( cpu_self, level );
4000e8d4: c2 27 bf ec st %g1, [ %fp + -20 ]
4000e8d8: 7f ff ff 3f call 4000e5d4 <_Thread_Do_dispatch>
4000e8dc: 90 10 00 1a mov %i2, %o0
4000e8e0: 10 bf ff f4 b 4000e8b0 <_Thread_queue_Flush_critical+0x184>
4000e8e4: c2 07 bf ec ld [ %fp + -20 ], %g1
4000b95c <_Thread_queue_Flush_default_filter>:
)
{
(void) queue;
(void) queue_context;
return the_thread;
}
4000b95c: 81 c3 e0 08 retl
<== NOT EXECUTED
4000b960: 01 00 00 00 nop
4000eeb8 <_Thread_queue_Flush_status_object_was_deleted>:
Thread_Control *the_thread,
Thread_queue_Queue *queue,
Thread_queue_Context *queue_context
)
{
the_thread->Wait.return_code = STATUS_OBJECT_WAS_DELETED;
4000eeb8: 03 00 00 05 sethi %hi(0x1400), %g1
<== NOT EXECUTED
4000eebc: 82 10 62 07 or %g1, 0x207, %g1 ! 1607 <_Configuration_Interrupt_stack_size+0x607>
<== NOT EXECUTED
(void) queue;
(void) queue_context;
return the_thread;
}
4000eec0: 81 c3 e0 08 retl
<== NOT EXECUTED
4000eec4: c2 22 20 4c st %g1, [ %o0 + 0x4c ]
4000b834 <_Thread_queue_Flush_status_unavailable>:
Thread_Control *the_thread,
Thread_queue_Queue *queue,
Thread_queue_Context *queue_context
)
{
the_thread->Wait.return_code = STATUS_UNAVAILABLE;
4000b834: 03 00 00 04 sethi %hi(0x1000), %g1
<== NOT EXECUTED
4000b838: 82 10 60 0d or %g1, 0xd, %g1 ! 100d <_Configuration_Interrupt_stack_size+0xd>
<== NOT EXECUTED
(void) queue;
(void) queue_context;
return the_thread;
}
4000b83c: 81 c3 e0 08 retl
<== NOT EXECUTED
4000b840: c2 22 20 4c st %g1, [ %o0 + 0x4c ]
40011498 <_Thread_queue_Object_initialize>:
queue->name = name;
40011498: 03 10 00 77 sethi %hi(0x4001dc00), %g1
<== NOT EXECUTED
queue->heads = NULL;
4001149c: c0 22 00 00 clr [ %o0 ]
<== NOT EXECUTED
queue->name = name;
400114a0: 82 10 62 c8 or %g1, 0x2c8, %g1
<== NOT EXECUTED
queue->owner = NULL;
400114a4: c0 22 20 04 clr [ %o0 + 4 ]
<== NOT EXECUTED
}
void _Thread_queue_Object_initialize( Thread_queue_Control *the_thread_queue )
{
_Thread_queue_Initialize( the_thread_queue, _Thread_queue_Object_name );
}
400114a8: 81 c3 e0 08 retl
<== NOT EXECUTED
400114ac: c2 22 20 08 st %g1, [ %o0 + 8 ]
40014a5c <_Thread_queue_Queue_get_name_and_id>:
const Thread_queue_Queue *queue,
char *buffer,
size_t buffer_size,
Objects_Id *id
)
{
40014a5c: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
const char *name;
name = queue->name;
40014a60: c4 06 20 08 ld [ %i0 + 8 ], %g2
<== NOT EXECUTED
if ( name == _Thread_queue_Object_name ) {
40014a64: 03 10 00 a5 sethi %hi(0x40029400), %g1
<== NOT EXECUTED
40014a68: 82 10 61 50 or %g1, 0x150, %g1 ! 40029550 <_Thread_queue_Object_name>
<== NOT EXECUTED
40014a6c: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
40014a70: 02 80 00 0c be 40014aa0 <_Thread_queue_Queue_get_name_and_id+0x44>
<== NOT EXECUTED
40014a74: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
false,
buffer,
buffer_size
);
} else {
if ( name == NULL ) {
40014a78: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40014a7c: 02 80 00 05 be 40014a90 <_Thread_queue_Queue_get_name_and_id+0x34>
<== NOT EXECUTED
40014a80: c0 26 c0 00 clr [ %i3 ]
<== NOT EXECUTED
name = _Thread_queue_Object_name;
}
*id = 0;
return strlcpy( buffer, name, buffer_size );
40014a84: b2 10 00 02 mov %g2, %i1
<== NOT EXECUTED
40014a88: 40 00 14 c6 call 40019da0 <strlcpy>
<== NOT EXECUTED
40014a8c: 91 e8 00 0a restore %g0, %o2, %o0
<== NOT EXECUTED
name = _Thread_queue_Object_name;
40014a90: 84 10 00 01 mov %g1, %g2
<== NOT EXECUTED
return strlcpy( buffer, name, buffer_size );
40014a94: b0 10 00 0a mov %o2, %i0
<== NOT EXECUTED
40014a98: 40 00 14 c2 call 40019da0 <strlcpy>
<== NOT EXECUTED
40014a9c: 93 e8 00 02 restore %g0, %g2, %o1
<== NOT EXECUTED
*id = queue_object->Object.id;
40014aa0: c4 06 3f f8 ld [ %i0 + -8 ], %g2
<== NOT EXECUTED
40014aa4: c4 26 c0 00 st %g2, [ %i3 ]
<== NOT EXECUTED
return _Objects_Name_to_string(
40014aa8: 96 10 00 1a mov %i2, %o3
<== NOT EXECUTED
40014aac: c2 06 3f fc ld [ %i0 + -4 ], %g1
<== NOT EXECUTED
40014ab0: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
40014ab4: 92 10 20 00 clr %o1
<== NOT EXECUTED
40014ab8: 7f ff fe 0a call 400142e0 <_Objects_Name_to_string>
<== NOT EXECUTED
40014abc: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
}
}
40014ac0: 81 c7 e0 08 ret
<== NOT EXECUTED
40014ac4: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000ac28 <_Thread_queue_Surrender>:
Thread_queue_Heads *heads,
Thread_Control *previous_owner,
Thread_queue_Context *queue_context,
const Thread_queue_Operations *operations
)
{
4000ac28: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
4000ac2c: c0 26 e0 14 clr [ %i3 + 0x14 ]
<== NOT EXECUTED
Per_CPU_Control *cpu_self;
_Assert( heads != NULL );
_Thread_queue_Context_clear_priority_updates( queue_context );
new_owner = ( *operations->surrender )(
4000ac30: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
4000ac34: c2 07 20 0c ld [ %i4 + 0xc ], %g1
<== NOT EXECUTED
4000ac38: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000ac3c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000ac40: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000ac44: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
queue,
heads,
previous_owner,
queue_context
);
queue->owner = new_owner;
4000ac48: d0 26 20 04 st %o0, [ %i0 + 4 ]
<== NOT EXECUTED
if ( success ) {
4000ac4c: c2 02 20 50 ld [ %o0 + 0x50 ], %g1
<== NOT EXECUTED
4000ac50: 80 a0 64 01 cmp %g1, 0x401
<== NOT EXECUTED
4000ac54: 02 80 00 1c be 4000acc4 <_Thread_queue_Surrender+0x9c>
<== NOT EXECUTED
4000ac58: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
the_thread->Wait.flags = flags;
4000ac5c: 82 10 24 04 mov 0x404, %g1
<== NOT EXECUTED
4000ac60: c2 22 20 50 st %g1, [ %o0 + 0x50 ]
<== NOT EXECUTED
unblock = true;
4000ac64: b4 10 20 01 mov 1, %i2
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000ac68: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
the_thread->Wait.queue = NULL;
4000ac6c: c0 27 60 54 clr [ %i5 + 0x54 ]
<== NOT EXECUTED
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4000ac70: 05 10 00 66 sethi %hi(0x40019800), %g2
<== NOT EXECUTED
4000ac74: 84 10 a1 50 or %g2, 0x150, %g2 ! 40019950 <_Thread_queue_Operations_default>
<== NOT EXECUTED
4000ac78: c4 27 60 58 st %g2, [ %i5 + 0x58 ]
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000ac7c: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000ac80: b8 10 00 06 mov %g6, %i4
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000ac84: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000ac88: c2 06 c0 00 ld [ %i3 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ac8c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ac90: 01 00 00 00 nop
_Thread_queue_Queue_release(
queue,
&queue_context->Lock_context.Lock_context
);
_Thread_Priority_update( queue_context );
4000ac94: 40 00 0e 0d call 4000e4c8 <_Thread_Priority_update>
4000ac98: 90 10 00 1b mov %i3, %o0
if ( unblock ) {
4000ac9c: 80 8e a0 ff btst 0xff, %i2
4000aca0: 12 80 00 0d bne 4000acd4 <_Thread_queue_Surrender+0xac> <== ALWAYS TAKEN
4000aca4: 01 00 00 00 nop
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000aca8: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000acac: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000acb0: 02 80 00 19 be 4000ad14 <_Thread_queue_Surrender+0xec>
<== NOT EXECUTED
4000acb4: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000acb8: c2 27 20 18 st %g1, [ %i4 + 0x18 ]
_Thread_Remove_timer_and_unblock( new_owner, queue );
}
_Thread_Dispatch_enable( cpu_self );
}
4000acbc: 81 c7 e0 08 ret
4000acc0: 81 e8 00 00 restore
the_thread->Wait.flags = desired_flags;
4000acc4: 82 10 24 04 mov 0x404, %g1
<== NOT EXECUTED
unblock = false;
4000acc8: b4 10 20 00 clr %i2
<== NOT EXECUTED
4000accc: 10 bf ff e7 b 4000ac68 <_Thread_queue_Surrender+0x40>
<== NOT EXECUTED
4000acd0: c2 22 20 50 st %g1, [ %o0 + 0x50 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000acd4: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000acd8: c2 27 bf fc st %g1, [ %fp + -4 ]
4000acdc: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
4000ace0: 40 00 04 bb call 4000bfcc <_Watchdog_Remove>
4000ace4: 92 07 60 68 add %i5, 0x68, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000ace8: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000acec: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000acf0: 01 00 00 00 nop
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4000acf4: 13 0c 00 57 sethi %hi(0x30015c00), %o1
4000acf8: 90 10 00 1d mov %i5, %o0
4000acfc: 40 00 0e 20 call 4000e57c <_Thread_Clear_state>
4000ad00: 92 12 63 ff or %o1, 0x3ff, %o1
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000ad04: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
if ( disable_level == 1 ) {
4000ad08: 80 a0 60 01 cmp %g1, 1
4000ad0c: 12 bf ff eb bne 4000acb8 <_Thread_queue_Surrender+0x90>
4000ad10: 82 00 7f ff add %g1, -1, %g1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000ad14: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000ad18: c4 0f 20 1c ldub [ %i4 + 0x1c ], %g2
4000ad1c: 80 a0 a0 00 cmp %g2, 0
4000ad20: 32 80 00 07 bne,a 4000ad3c <_Thread_queue_Surrender+0x114>
4000ad24: 92 10 00 01 mov %g1, %o1
cpu_self->thread_dispatch_disable_level = 0;
4000ad28: c0 27 20 18 clr [ %i4 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ad2c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ad30: 01 00 00 00 nop
4000ad34: 81 c7 e0 08 ret
4000ad38: 81 e8 00 00 restore
_Thread_Do_dispatch( cpu_self, level );
4000ad3c: c2 27 bf fc st %g1, [ %fp + -4 ]
4000ad40: 40 00 0e 25 call 4000e5d4 <_Thread_Do_dispatch>
4000ad44: 90 10 00 1c mov %i4, %o0
4000ad48: 10 bf ff f9 b 4000ad2c <_Thread_queue_Surrender+0x104>
4000ad4c: c2 07 bf fc ld [ %fp + -4 ], %g1
40008924 <_Timecounter_Bintime>:
{
40008924: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
40008928: 33 10 00 6d sethi %hi(0x4001b400), %i1
<== NOT EXECUTED
4000892c: b2 16 61 00 or %i1, 0x100, %i1 ! 4001b500 <timehands>
<== NOT EXECUTED
th = timehands;
40008930: fa 06 40 00 ld [ %i1 ], %i5
40008934: f4 07 60 70 ld [ %i5 + 0x70 ], %i2
*bt = th->th_bintime;
40008938: c4 1f 60 30 ldd [ %i5 + 0x30 ], %g2
4000893c: c4 3e 00 00 std %g2, [ %i0 ]
40008940: c4 1f 60 38 ldd [ %i5 + 0x38 ], %g2
40008944: f6 07 40 00 ld [ %i5 ], %i3
40008948: c4 3e 20 08 std %g2, [ %i0 + 8 ]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
4000894c: 90 10 00 1b mov %i3, %o0
40008950: c2 06 c0 00 ld [ %i3 ], %g1
bintime_addx(bt, th->th_scale * tc_delta(th));
40008954: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
40008958: 9f c0 40 00 call %g1
4000895c: e0 07 60 14 ld [ %i5 + 0x14 ], %l0
40008960: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
40008964: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
40008968: f6 06 e0 08 ld [ %i3 + 8 ], %i3
4000896c: 90 22 00 01 sub %o0, %g1, %o0
40008970: 90 0a 00 1b and %o0, %i3, %o0
bintime_addx(bt, th->th_scale * tc_delta(th));
40008974: b8 5f 00 08 smul %i4, %o0, %i4
40008978: 92 52 00 10 umul %o0, %l0, %o1
4000897c: 91 40 00 00 rd %y, %o0
40008980: 90 07 00 08 add %i4, %o0, %o0
40008984: 9a 82 40 03 addcc %o1, %g3, %o5
40008988: 98 c2 00 02 addxcc %o0, %g2, %o4
4000898c: 0a 80 00 12 bcs 400089d4 <_Timecounter_Bintime+0xb0>
40008990: 88 10 20 00 clr %g4
if (_u > _bt->frac)
40008994: 80 a1 20 00 cmp %g4, 0
40008998: 02 80 00 06 be 400089b0 <_Timecounter_Bintime+0x8c>
4000899c: d8 3e 20 08 std %o4, [ %i0 + 8 ]
_bt->sec++;
400089a0: c4 1e 00 00 ldd [ %i0 ], %g2
400089a4: 9a 80 e0 01 addcc %g3, 1, %o5
400089a8: 98 40 a0 00 addx %g2, 0, %o4
400089ac: d8 3e 00 00 std %o4, [ %i0 ]
} while (gen == 0 || gen != th->th_generation);
400089b0: 80 a6 a0 00 cmp %i2, 0
400089b4: 02 bf ff df be 40008930 <_Timecounter_Bintime+0xc>
<== NEVER TAKEN
400089b8: 01 00 00 00 nop
400089bc: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
400089c0: 80 a0 40 1a cmp %g1, %i2
400089c4: 12 bf ff db bne 40008930 <_Timecounter_Bintime+0xc>
400089c8: 01 00 00 00 nop
}
400089cc: 81 c7 e0 08 ret
400089d0: 81 e8 00 00 restore
400089d4: 10 bf ff f0 b 40008994 <_Timecounter_Bintime+0x70>
400089d8: 88 10 20 01 mov 1, %g4
40009208 <_Timecounter_Binuptime>:
{
40009208: 9d e3 bf a0 save %sp, -96, %sp
4000920c: 33 10 00 4b sethi %hi(0x40012c00), %i1
40009210: b2 16 62 c0 or %i1, 0x2c0, %i1 ! 40012ec0 <timehands>
th = timehands;
40009214: fa 06 40 00 ld [ %i1 ], %i5
40009218: f4 07 60 70 ld [ %i5 + 0x70 ], %i2
*bt = th->th_offset;
4000921c: c4 1f 60 20 ldd [ %i5 + 0x20 ], %g2
40009220: c4 3e 00 00 std %g2, [ %i0 ]
40009224: c4 1f 60 28 ldd [ %i5 + 0x28 ], %g2
40009228: f6 07 40 00 ld [ %i5 ], %i3
4000922c: c4 3e 20 08 std %g2, [ %i0 + 8 ]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
40009230: 90 10 00 1b mov %i3, %o0
40009234: c2 06 c0 00 ld [ %i3 ], %g1
bintime_addx(bt, th->th_scale * tc_delta(th));
40009238: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
4000923c: 9f c0 40 00 call %g1
40009240: e0 07 60 14 ld [ %i5 + 0x14 ], %l0
40009244: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
40009248: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000924c: f6 06 e0 08 ld [ %i3 + 8 ], %i3
40009250: 90 22 00 01 sub %o0, %g1, %o0
40009254: 90 0a 00 1b and %o0, %i3, %o0
bintime_addx(bt, th->th_scale * tc_delta(th));
40009258: b8 5f 00 08 smul %i4, %o0, %i4
4000925c: 92 52 00 10 umul %o0, %l0, %o1
40009260: 91 40 00 00 rd %y, %o0
40009264: 90 07 00 08 add %i4, %o0, %o0
40009268: 9a 82 40 03 addcc %o1, %g3, %o5
4000926c: 98 c2 00 02 addxcc %o0, %g2, %o4
40009270: 0a 80 00 12 bcs 400092b8 <_Timecounter_Binuptime+0xb0>
40009274: 88 10 20 00 clr %g4
if (_u > _bt->frac)
40009278: 80 a1 20 00 cmp %g4, 0
4000927c: 02 80 00 06 be 40009294 <_Timecounter_Binuptime+0x8c>
40009280: d8 3e 20 08 std %o4, [ %i0 + 8 ]
_bt->sec++;
40009284: c4 1e 00 00 ldd [ %i0 ], %g2
40009288: 9a 80 e0 01 addcc %g3, 1, %o5
4000928c: 98 40 a0 00 addx %g2, 0, %o4
40009290: d8 3e 00 00 std %o4, [ %i0 ]
} while (gen == 0 || gen != th->th_generation);
40009294: 80 a6 a0 00 cmp %i2, 0
40009298: 02 bf ff df be 40009214 <_Timecounter_Binuptime+0xc>
<== NEVER TAKEN
4000929c: 01 00 00 00 nop
400092a0: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
400092a4: 80 a0 40 1a cmp %g1, %i2
400092a8: 12 bf ff db bne 40009214 <_Timecounter_Binuptime+0xc>
400092ac: 01 00 00 00 nop
}
400092b0: 81 c7 e0 08 ret
400092b4: 81 e8 00 00 restore
400092b8: 10 bf ff f0 b 40009278 <_Timecounter_Binuptime+0x70>
400092bc: 88 10 20 01 mov 1, %g4
40008a64 <_Timecounter_Getbintime>:
{
40008a64: 07 10 00 6d sethi %hi(0x4001b400), %g3
<== NOT EXECUTED
40008a68: 86 10 e1 00 or %g3, 0x100, %g3 ! 4001b500 <timehands>
<== NOT EXECUTED
th = timehands;
40008a6c: c2 00 c0 00 ld [ %g3 ], %g1
40008a70: c4 00 60 70 ld [ %g1 + 0x70 ], %g2
*bt = th->th_bintime;
40008a74: d8 18 60 30 ldd [ %g1 + 0x30 ], %o4
40008a78: d8 3a 00 00 std %o4, [ %o0 ]
40008a7c: d8 18 60 38 ldd [ %g1 + 0x38 ], %o4
40008a80: d8 3a 20 08 std %o4, [ %o0 + 8 ]
} while (gen == 0 || gen != th->th_generation);
40008a84: 80 a0 a0 00 cmp %g2, 0
40008a88: 02 bf ff f9 be 40008a6c <_Timecounter_Getbintime+0x8>
<== NEVER TAKEN
40008a8c: 01 00 00 00 nop
40008a90: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
40008a94: 80 a0 40 02 cmp %g1, %g2
40008a98: 12 bf ff f5 bne 40008a6c <_Timecounter_Getbintime+0x8>
40008a9c: 01 00 00 00 nop
}
40008aa0: 81 c3 e0 08 retl
40008aa4: 01 00 00 00 nop
40004a14 <_Timecounter_Getbinuptime>:
{
40004a14: 07 10 00 32 sethi %hi(0x4000c800), %g3
<== NOT EXECUTED
40004a18: 86 10 e2 08 or %g3, 0x208, %g3 ! 4000ca08 <timehands>
<== NOT EXECUTED
th = timehands;
40004a1c: c2 00 c0 00 ld [ %g3 ], %g1
<== NOT EXECUTED
40004a20: c4 00 60 70 ld [ %g1 + 0x70 ], %g2
<== NOT EXECUTED
*bt = th->th_offset;
40004a24: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4
<== NOT EXECUTED
40004a28: d8 3a 00 00 std %o4, [ %o0 ]
<== NOT EXECUTED
40004a2c: d8 18 60 28 ldd [ %g1 + 0x28 ], %o4
<== NOT EXECUTED
40004a30: d8 3a 20 08 std %o4, [ %o0 + 8 ]
<== NOT EXECUTED
} while (gen == 0 || gen != th->th_generation);
40004a34: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40004a38: 02 bf ff f9 be 40004a1c <_Timecounter_Getbinuptime+0x8>
<== NOT EXECUTED
40004a3c: 01 00 00 00 nop
40004a40: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
40004a44: 80 a0 40 02 cmp %g1, %g2
40004a48: 12 bf ff f5 bne 40004a1c <_Timecounter_Getbinuptime+0x8> <== NEVER TAKEN
40004a4c: 01 00 00 00 nop
}
40004a50: 81 c3 e0 08 retl
40004a54: 01 00 00 00 nop
40004b88 <_Timecounter_Getmicrotime>:
{
40004b88: 07 10 00 32 sethi %hi(0x4000c800), %g3
<== NOT EXECUTED
40004b8c: 86 10 e2 08 or %g3, 0x208, %g3 ! 4000ca08 <timehands>
<== NOT EXECUTED
th = timehands;
40004b90: c2 00 c0 00 ld [ %g3 ], %g1
<== NOT EXECUTED
40004b94: c4 00 60 70 ld [ %g1 + 0x70 ], %g2
<== NOT EXECUTED
*tvp = th->th_microtime;
40004b98: d8 18 60 40 ldd [ %g1 + 0x40 ], %o4
<== NOT EXECUTED
40004b9c: d8 3a 00 00 std %o4, [ %o0 ]
<== NOT EXECUTED
40004ba0: d8 18 60 48 ldd [ %g1 + 0x48 ], %o4
<== NOT EXECUTED
40004ba4: d8 3a 20 08 std %o4, [ %o0 + 8 ]
<== NOT EXECUTED
} while (gen == 0 || gen != th->th_generation);
40004ba8: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40004bac: 02 bf ff f9 be 40004b90 <_Timecounter_Getmicrotime+0x8>
<== NOT EXECUTED
40004bb0: 01 00 00 00 nop
40004bb4: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
40004bb8: 80 a0 40 02 cmp %g1, %g2
40004bbc: 12 bf ff f5 bne 40004b90 <_Timecounter_Getmicrotime+0x8> <== NEVER TAKEN
40004bc0: 01 00 00 00 nop
}
40004bc4: 81 c3 e0 08 retl
40004bc8: 01 00 00 00 nop
40004aac <_Timecounter_Getmicrouptime>:
{
40004aac: 19 10 00 32 sethi %hi(0x4000c800), %o4
<== NOT EXECUTED
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
40004ab0: 1b 00 03 d0 sethi %hi(0xf4000), %o5
<== NOT EXECUTED
40004ab4: 98 13 22 08 or %o4, 0x208, %o4
<== NOT EXECUTED
40004ab8: 9a 13 62 40 or %o5, 0x240, %o5
<== NOT EXECUTED
th = timehands;
40004abc: c2 03 00 00 ld [ %o4 ], %g1
<== NOT EXECUTED
40004ac0: c8 00 60 70 ld [ %g1 + 0x70 ], %g4
<== NOT EXECUTED
_tv->tv_sec = _bt->sec;
40004ac4: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
<== NOT EXECUTED
40004ac8: c4 3a 00 00 std %g2, [ %o0 ]
<== NOT EXECUTED
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
40004acc: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
<== NOT EXECUTED
40004ad0: 86 50 80 0d umul %g2, %o5, %g3
<== NOT EXECUTED
40004ad4: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
40004ad8: c4 22 20 08 st %g2, [ %o0 + 8 ]
<== NOT EXECUTED
} while (gen == 0 || gen != th->th_generation);
40004adc: 80 a1 20 00 cmp %g4, 0
<== NOT EXECUTED
40004ae0: 02 bf ff f7 be 40004abc <_Timecounter_Getmicrouptime+0x10>
<== NOT EXECUTED
40004ae4: 01 00 00 00 nop
40004ae8: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
40004aec: 80 a0 40 04 cmp %g1, %g4
40004af0: 12 bf ff f3 bne 40004abc <_Timecounter_Getmicrouptime+0x10> <== NEVER TAKEN
40004af4: 01 00 00 00 nop
}
40004af8: 81 c3 e0 08 retl
40004afc: 01 00 00 00 nop
40008aa8 <_Timecounter_Getnanotime>:
{
40008aa8: 07 10 00 6d sethi %hi(0x4001b400), %g3
<== NOT EXECUTED
40008aac: 86 10 e1 00 or %g3, 0x100, %g3 ! 4001b500 <timehands>
<== NOT EXECUTED
th = timehands;
40008ab0: c2 00 c0 00 ld [ %g3 ], %g1
<== NOT EXECUTED
40008ab4: c4 00 60 70 ld [ %g1 + 0x70 ], %g2
*tsp = th->th_nanotime;
40008ab8: d8 18 60 50 ldd [ %g1 + 0x50 ], %o4
40008abc: d8 3a 00 00 std %o4, [ %o0 ]
40008ac0: d8 18 60 58 ldd [ %g1 + 0x58 ], %o4
40008ac4: d8 3a 20 08 std %o4, [ %o0 + 8 ]
} while (gen == 0 || gen != th->th_generation);
40008ac8: 80 a0 a0 00 cmp %g2, 0
40008acc: 02 bf ff f9 be 40008ab0 <_Timecounter_Getnanotime+0x8> <== NEVER TAKEN
40008ad0: 01 00 00 00 nop
40008ad4: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
40008ad8: 80 a0 40 02 cmp %g1, %g2
40008adc: 12 bf ff f5 bne 40008ab0 <_Timecounter_Getnanotime+0x8> <== NEVER TAKEN
40008ae0: 01 00 00 00 nop
}
40008ae4: 81 c3 e0 08 retl
40008ae8: 01 00 00 00 nop
40008a10 <_Timecounter_Getnanouptime>:
{
40008a10: 19 10 00 6d sethi %hi(0x4001b400), %o4
<== NOT EXECUTED
_ts->tv_nsec = ((uint64_t)1000000000 *
40008a14: 1b 0e e6 b2 sethi %hi(0x3b9ac800), %o5
<== NOT EXECUTED
40008a18: 98 13 21 00 or %o4, 0x100, %o4
<== NOT EXECUTED
40008a1c: 9a 13 62 00 or %o5, 0x200, %o5
<== NOT EXECUTED
th = timehands;
40008a20: c2 03 00 00 ld [ %o4 ], %g1
<== NOT EXECUTED
40008a24: c8 00 60 70 ld [ %g1 + 0x70 ], %g4
<== NOT EXECUTED
_ts->tv_sec = _bt->sec;
40008a28: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
40008a2c: c4 3a 00 00 std %g2, [ %o0 ]
(uint32_t)(_bt->frac >> 32)) >> 32;
40008a30: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
_ts->tv_nsec = ((uint64_t)1000000000 *
40008a34: 86 50 80 0d umul %g2, %o5, %g3
40008a38: 85 40 00 00 rd %y, %g2
40008a3c: c4 22 20 08 st %g2, [ %o0 + 8 ]
} while (gen == 0 || gen != th->th_generation);
40008a40: 80 a1 20 00 cmp %g4, 0
40008a44: 02 bf ff f7 be 40008a20 <_Timecounter_Getnanouptime+0x10> <== NEVER TAKEN
40008a48: 01 00 00 00 nop
40008a4c: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
40008a50: 80 a0 40 04 cmp %g1, %g4
40008a54: 12 bf ff f3 bne 40008a20 <_Timecounter_Getnanouptime+0x10> <== NEVER TAKEN
40008a58: 01 00 00 00 nop
}
40008a5c: 81 c3 e0 08 retl
40008a60: 01 00 00 00 nop
40008aec <_Timecounter_Install>:
{
40008aec: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
tc->tc_next = timecounters;
40008af0: 03 10 00 6d sethi %hi(0x4001b400), %g1
<== NOT EXECUTED
40008af4: c4 00 60 f8 ld [ %g1 + 0xf8 ], %g2 ! 4001b4f8 <timecounters>
<== NOT EXECUTED
40008af8: c4 26 20 28 st %g2, [ %i0 + 0x28 ]
<== NOT EXECUTED
(void)tc->tc_get_timecount(tc);
40008afc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40008b00: c4 06 00 00 ld [ %i0 ], %g2
<== NOT EXECUTED
40008b04: 9f c0 80 00 call %g2
40008b08: f0 20 60 f8 st %i0, [ %g1 + 0xf8 ]
(void)tc->tc_get_timecount(tc);
40008b0c: c2 06 00 00 ld [ %i0 ], %g1
40008b10: 9f c0 40 00 call %g1
40008b14: 90 10 00 18 mov %i0, %o0
timecounter = tc;
40008b18: 03 10 00 6d sethi %hi(0x4001b400), %g1
<== NOT EXECUTED
40008b1c: f0 20 60 fc st %i0, [ %g1 + 0xfc ] ! 4001b4fc <_Timecounter>
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008b20: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Timecounter_Acquire(&lock_context);
40008b24: c2 27 bf fc st %g1, [ %fp + -4 ]
_Timecounter_Windup(new_boottimebin, &lock_context);
40008b28: 90 10 20 00 clr %o0
40008b2c: 7f ff fe a6 call 400085c4 <_Timecounter_Windup>
40008b30: 92 07 bf fc add %fp, -4, %o1
}
40008b34: 81 c7 e0 08 ret
40008b38: 81 e8 00 00 restore
400089dc <_Timecounter_Microtime>:
{
400089dc: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
bintime(&bt);
400089e0: 7f ff ff d1 call 40008924 <_Timecounter_Bintime>
<== NOT EXECUTED
400089e4: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
_tv->tv_sec = _bt->sec;
400089e8: c4 1f bf f0 ldd [ %fp + -16 ], %g2
400089ec: c4 3e 00 00 std %g2, [ %i0 ]
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
400089f0: 03 00 03 d0 sethi %hi(0xf4000), %g1
400089f4: c4 07 bf f8 ld [ %fp + -8 ], %g2
400089f8: 82 10 62 40 or %g1, 0x240, %g1
400089fc: 86 50 80 01 umul %g2, %g1, %g3
40008a00: 85 40 00 00 rd %y, %g2
40008a04: c4 26 20 08 st %g2, [ %i0 + 8 ]
}
40008a08: 81 c7 e0 08 ret
40008a0c: 81 e8 00 00 restore
40007e70 <_Timecounter_Microuptime>:
{
40007e70: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
binuptime(&bt);
40007e74: 7f ff ff ac call 40007d24 <_Timecounter_Binuptime>
<== NOT EXECUTED
40007e78: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
_tv->tv_sec = _bt->sec;
40007e7c: c4 1f bf f0 ldd [ %fp + -16 ], %g2
40007e80: c4 3e 00 00 std %g2, [ %i0 ]
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
40007e84: 03 00 03 d0 sethi %hi(0xf4000), %g1
40007e88: c4 07 bf f8 ld [ %fp + -8 ], %g2
40007e8c: 82 10 62 40 or %g1, 0x240, %g1
40007e90: 86 50 80 01 umul %g2, %g1, %g3
40007e94: 85 40 00 00 rd %y, %g2
40007e98: c4 26 20 08 st %g2, [ %i0 + 8 ]
}
40007e9c: 81 c7 e0 08 ret
40007ea0: 81 e8 00 00 restore
400090bc <_Timecounter_Nanotime>:
{
400090bc: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
bintime(&bt);
400090c0: 7f ff ff d1 call 40009004 <_Timecounter_Bintime>
<== NOT EXECUTED
400090c4: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
_ts->tv_sec = _bt->sec;
400090c8: c4 1f bf f0 ldd [ %fp + -16 ], %g2
400090cc: c4 3e 00 00 std %g2, [ %i0 ]
_ts->tv_nsec = ((uint64_t)1000000000 *
400090d0: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1
400090d4: c4 07 bf f8 ld [ %fp + -8 ], %g2
400090d8: 82 10 62 00 or %g1, 0x200, %g1
400090dc: 86 50 80 01 umul %g2, %g1, %g3
400090e0: 85 40 00 00 rd %y, %g2
400090e4: c4 26 20 08 st %g2, [ %i0 + 8 ]
}
400090e8: 81 c7 e0 08 ret
400090ec: 81 e8 00 00 restore
40009354 <_Timecounter_Nanouptime>:
{
40009354: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
binuptime(&bt);
40009358: 7f ff ff ac call 40009208 <_Timecounter_Binuptime>
<== NOT EXECUTED
4000935c: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
_ts->tv_sec = _bt->sec;
40009360: c4 1f bf f0 ldd [ %fp + -16 ], %g2
40009364: c4 3e 00 00 std %g2, [ %i0 ]
_ts->tv_nsec = ((uint64_t)1000000000 *
40009368: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1
4000936c: c4 07 bf f8 ld [ %fp + -8 ], %g2
40009370: 82 10 62 00 or %g1, 0x200, %g1
40009374: 86 50 80 01 umul %g2, %g1, %g3
40009378: 85 40 00 00 rd %y, %g2
4000937c: c4 26 20 08 st %g2, [ %i0 + 8 ]
}
40009380: 81 c7 e0 08 ret
40009384: 81 e8 00 00 restore
40008890 <_Timecounter_Sbinuptime>:
{
40008890: 9d e3 bf a0 save %sp, -96, %sp
40008894: 33 10 00 6d sethi %hi(0x4001b400), %i1
40008898: b2 16 61 00 or %i1, 0x100, %i1 ! 4001b500 <timehands>
th = timehands;
4000889c: fa 06 40 00 ld [ %i1 ], %i5
400088a0: f6 07 60 70 ld [ %i5 + 0x70 ], %i3
RTEMS_COMPILER_MEMORY_BARRIER();
400088a4: f8 07 40 00 ld [ %i5 ], %i4
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
400088a8: c2 07 00 00 ld [ %i4 ], %g1
400088ac: e2 07 60 24 ld [ %i5 + 0x24 ], %l1
400088b0: e0 07 60 28 ld [ %i5 + 0x28 ], %l0
sbt += (th->th_scale * tc_delta(th)) >> 32;
400088b4: f4 07 60 10 ld [ %i5 + 0x10 ], %i2
400088b8: e4 07 60 14 ld [ %i5 + 0x14 ], %l2
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
400088bc: 9f c0 40 00 call %g1
400088c0: 90 10 00 1c mov %i4, %o0
400088c4: c4 07 60 18 ld [ %i5 + 0x18 ], %g2
tc->tc_counter_mask);
400088c8: c2 07 20 08 ld [ %i4 + 8 ], %g1
} while (gen == 0 || gen != th->th_generation);
400088cc: 80 a6 e0 00 cmp %i3, 0
400088d0: 02 bf ff f3 be 4000889c <_Timecounter_Sbinuptime+0xc>
<== NEVER TAKEN
400088d4: 01 00 00 00 nop
400088d8: c6 07 60 70 ld [ %i5 + 0x70 ], %g3
400088dc: 80 a0 c0 1b cmp %g3, %i3
400088e0: 12 bf ff ef bne 4000889c <_Timecounter_Sbinuptime+0xc>
400088e4: 84 22 00 02 sub %o0, %g2, %g2
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
400088e8: 84 08 80 01 and %g2, %g1, %g2
sbt += (th->th_scale * tc_delta(th)) >> 32;
400088ec: b4 5e 80 02 smul %i2, %g2, %i2
400088f0: 86 50 80 12 umul %g2, %l2, %g3
400088f4: 85 40 00 00 rd %y, %g2
return (((sbintime_t)_bt.sec << 32) + (_bt.frac >> 32));
400088f8: 9a 10 20 00 clr %o5
400088fc: ba 06 80 02 add %i2, %g2, %i5
40008900: b2 83 40 10 addcc %o5, %l0, %i1
40008904: 84 10 20 00 clr %g2
40008908: b0 44 40 02 addx %l1, %g2, %i0
4000890c: b8 10 20 00 clr %i4
}
40008910: 86 87 40 19 addcc %i5, %i1, %g3
40008914: 84 47 00 18 addx %i4, %i0, %g2
40008918: b2 10 00 03 mov %g3, %i1
4000891c: 81 c7 e0 08 ret
40008920: 91 e8 00 02 restore %g0, %g2, %o0
40009d00 <_Timecounter_Set_clock>:
{
40009d00: 9d e3 bf 80 save %sp, -128, %sp
<== NOT EXECUTED
bt = *_bt;
40009d04: f8 1e 00 00 ldd [ %i0 ], %i4
<== NOT EXECUTED
40009d08: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
<== NOT EXECUTED
40009d0c: f8 3f bf e0 std %i4, [ %fp + -32 ]
<== NOT EXECUTED
binuptime(&bt2);
40009d10: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
40009d14: 7f ff ff 22 call 4000999c <_Timecounter_Binuptime>
<== NOT EXECUTED
40009d18: c4 3f bf e8 std %g2, [ %fp + -24 ]
<== NOT EXECUTED
40009d1c: c4 1f bf f8 ldd [ %fp + -8 ], %g2
40009d20: f8 1f bf e8 ldd [ %fp + -24 ], %i4
40009d24: b6 a7 40 03 subcc %i5, %g3, %i3
40009d28: b4 e7 00 02 subxcc %i4, %g2, %i2
40009d2c: 0a 80 00 12 bcs 40009d74 <_Timecounter_Set_clock+0x74>
40009d30: 82 10 20 00 clr %g1
_bt->frac -= _bt2->frac;
40009d34: f4 3f bf e8 std %i2, [ %fp + -24 ]
if (_u < _bt->frac)
40009d38: 80 a0 60 00 cmp %g1, 0
40009d3c: 02 80 00 05 be 40009d50 <_Timecounter_Set_clock+0x50>
40009d40: f4 1f bf e0 ldd [ %fp + -32 ], %i2
_bt->sec--;
40009d44: c4 1f bf e0 ldd [ %fp + -32 ], %g2
40009d48: b6 80 ff ff addcc %g3, -1, %i3
40009d4c: b4 40 bf ff addx %g2, -1, %i2
_bt->sec -= _bt2->sec;
40009d50: f8 1f bf f0 ldd [ %fp + -16 ], %i4
40009d54: 86 a6 c0 1d subcc %i3, %i5, %g3
40009d58: 84 66 80 1c subx %i2, %i4, %g2
_Timecounter_Windup(&bt, lock_context);
40009d5c: 92 10 00 19 mov %i1, %o1
40009d60: c4 3f bf e0 std %g2, [ %fp + -32 ]
40009d64: 7f ff fe 5b call 400096d0 <_Timecounter_Windup>
40009d68: 90 07 bf e0 add %fp, -32, %o0
}
40009d6c: 81 c7 e0 08 ret
40009d70: 81 e8 00 00 restore
40009d74: 10 bf ff f0 b 40009d34 <_Timecounter_Set_clock+0x34>
40009d78: 82 10 20 01 mov 1, %g1
40008b3c <_Timecounter_Tick>:
}
}
#else /* __rtems__ */
void
_Timecounter_Tick(void)
{
40008b3c: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
Per_CPU_Control *cpu_self = _Per_CPU_Get();
40008b40: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
40008b44: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Timecounter_Acquire(&lock_context);
40008b48: c2 27 bf fc st %g1, [ %fp + -4 ]
_Timecounter_Windup(new_boottimebin, &lock_context);
40008b4c: 90 10 20 00 clr %o0
40008b50: 7f ff fe 9d call 400085c4 <_Timecounter_Windup>
40008b54: 92 07 bf fc add %fp, -4, %o1
if (_Per_CPU_Is_boot_processor(cpu_self)) {
tc_windup(NULL);
}
_Watchdog_Tick(cpu_self);
40008b58: 40 00 0d 67 call 4000c0f4 <_Watchdog_Tick>
40008b5c: 90 10 00 1d mov %i5, %o0
}
40008b60: 81 c7 e0 08 ret
40008b64: 81 e8 00 00 restore
40008b68 <_Timecounter_Tick_simple>:
void
_Timecounter_Tick_simple(uint32_t delta, uint32_t offset,
ISR_lock_Context *lock_context)
{
40008b68: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
struct bintime bt;
struct timehands *th;
uint32_t ogen;
th = timehands;
40008b6c: 03 10 00 6d sethi %hi(0x4001b400), %g1
40008b70: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 4001b500 <timehands>
ogen = th->th_generation;
th->th_offset_count = offset;
40008b74: f2 20 60 18 st %i1, [ %g1 + 0x18 ]
bintime_addx(&th->th_offset, th->th_scale * delta);
40008b78: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
40008b7c: f8 18 60 28 ldd [ %g1 + 0x28 ], %i4
40008b80: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
40008b84: 86 58 c0 18 smul %g3, %i0, %g3
ogen = th->th_generation;
40008b88: c8 00 60 70 ld [ %g1 + 0x70 ], %g4
bintime_addx(&th->th_offset, th->th_scale * delta);
40008b8c: b2 50 80 18 umul %g2, %i0, %i1
40008b90: b1 40 00 00 rd %y, %i0
40008b94: b0 00 c0 18 add %g3, %i0, %i0
40008b98: 96 86 40 1d addcc %i1, %i5, %o3
40008b9c: 94 c6 00 1c addxcc %i0, %i4, %o2
40008ba0: 0a 80 00 30 bcs 40008c60 <_Timecounter_Tick_simple+0xf8>
40008ba4: 84 10 20 00 clr %g2
if (_u > _bt->frac)
40008ba8: 80 a0 a0 00 cmp %g2, 0
40008bac: 12 80 00 28 bne 40008c4c <_Timecounter_Tick_simple+0xe4>
40008bb0: d4 38 60 28 std %o2, [ %g1 + 0x28 ]
40008bb4: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4
40008bb8: c4 18 60 68 ldd [ %g1 + 0x68 ], %g2
40008bbc: b2 80 c0 0b addcc %g3, %o3, %i1
40008bc0: b0 c0 80 0a addxcc %g2, %o2, %i0
_bt->sec++;
40008bc4: 0a 80 00 29 bcs 40008c68 <_Timecounter_Tick_simple+0x100>
40008bc8: 96 83 60 01 addcc %o5, 1, %o3
bt = th->th_offset;
40008bcc: 94 10 00 0c mov %o4, %o2
40008bd0: 96 10 00 0d mov %o5, %o3
_bt->sec += _bt2->sec;
40008bd4: c4 18 60 60 ldd [ %g1 + 0x60 ], %g2
40008bd8: ba 82 c0 03 addcc %o3, %g3, %i5
bintime_add(&bt, &th->th_boottime);
/* Update the UTC timestamps used by the get*() functions. */
th->th_bintime = bt;
40008bdc: f0 38 60 38 std %i0, [ %g1 + 0x38 ]
40008be0: b8 42 80 02 addx %o2, %g2, %i4
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
40008be4: 15 00 03 d0 sethi %hi(0xf4000), %o2
_ts->tv_nsec = ((uint64_t)1000000000 *
40008be8: 05 0e e6 b2 sethi %hi(0x3b9ac800), %g2
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
40008bec: 94 12 a2 40 or %o2, 0x240, %o2
_ts->tv_nsec = ((uint64_t)1000000000 *
40008bf0: 84 10 a2 00 or %g2, 0x200, %g2
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
40008bf4: 96 56 00 0a umul %i0, %o2, %o3
40008bf8: 95 40 00 00 rd %y, %o2
_ts->tv_nsec = ((uint64_t)1000000000 *
40008bfc: 86 56 00 02 umul %i0, %g2, %g3
40008c00: 85 40 00 00 rd %y, %g2
40008c04: f8 38 60 30 std %i4, [ %g1 + 0x30 ]
/*
* Now that the struct timehands is again consistent, set the new
* generation number, making sure to not make it zero.
*/
if (++ogen == 0)
40008c08: 88 81 20 01 inccc %g4
_tv->tv_sec = _bt->sec;
40008c0c: f8 38 60 40 std %i4, [ %g1 + 0x40 ]
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
40008c10: d4 20 60 48 st %o2, [ %g1 + 0x48 ]
_ts->tv_sec = _bt->sec;
40008c14: f8 38 60 50 std %i4, [ %g1 + 0x50 ]
40008c18: 12 80 00 03 bne 40008c24 <_Timecounter_Tick_simple+0xbc> <== ALWAYS TAKEN
40008c1c: c4 20 60 58 st %g2, [ %g1 + 0x58 ]
ogen = 1;
40008c20: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
th->th_generation = ogen;
/* Go live with the new struct timehands. */
time_second = th->th_microtime.tv_sec;
40008c24: 05 10 00 6d sethi %hi(0x4001b400), %g2
40008c28: f8 38 a0 f0 std %i4, [ %g2 + 0xf0 ] ! 4001b4f0 <_Timecounter_Time_second>
th->th_generation = ogen;
40008c2c: c8 20 60 70 st %g4, [ %g1 + 0x70 ]
time_uptime = th->th_offset.sec;
40008c30: 03 10 00 6d sethi %hi(0x4001b400), %g1
40008c34: da 20 60 e8 st %o5, [ %g1 + 0xe8 ] ! 4001b4e8 <_Timecounter_Time_uptime>
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008c38: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008c3c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008c40: 01 00 00 00 nop
_Timecounter_Release(lock_context);
_Watchdog_Tick(_Per_CPU_Get_snapshot());
40008c44: 40 00 0d 2c call 4000c0f4 <_Watchdog_Tick>
40008c48: 91 e8 00 06 restore %g0, %g6, %o0
_bt->sec++;
40008c4c: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
40008c50: 9a 80 e0 01 addcc %g3, 1, %o5
40008c54: 98 40 a0 00 addx %g2, 0, %o4
40008c58: 10 bf ff d8 b 40008bb8 <_Timecounter_Tick_simple+0x50>
40008c5c: d8 38 60 20 std %o4, [ %g1 + 0x20 ]
40008c60: 10 bf ff d2 b 40008ba8 <_Timecounter_Tick_simple+0x40>
40008c64: 84 10 20 01 mov 1, %g2
_bt->sec++;
40008c68: 10 bf ff db b 40008bd4 <_Timecounter_Tick_simple+0x6c>
40008c6c: 94 43 20 00 addx %o4, 0, %o2
4000baf4 <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
4000baf4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
uint32_t seconds = add->tv_sec;
4000baf8: f8 1e 40 00 ldd [ %i1 ], %i4
<== NOT EXECUTED
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
4000bafc: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
time->tv_sec += add->tv_sec;
4000bb00: d8 1e 00 00 ldd [ %i0 ], %o4
<== NOT EXECUTED
time->tv_nsec += add->tv_nsec;
4000bb04: c4 06 20 08 ld [ %i0 + 8 ], %g2
<== NOT EXECUTED
time->tv_sec += add->tv_sec;
4000bb08: b6 87 40 0d addcc %i5, %o5, %i3
<== NOT EXECUTED
time->tv_nsec += add->tv_nsec;
4000bb0c: 84 00 80 01 add %g2, %g1, %g2
<== NOT EXECUTED
time->tv_sec += add->tv_sec;
4000bb10: b4 47 00 0c addx %i4, %o4, %i2
<== NOT EXECUTED
time->tv_nsec += add->tv_nsec;
4000bb14: c4 26 20 08 st %g2, [ %i0 + 8 ]
<== NOT EXECUTED
uint32_t seconds = add->tv_sec;
4000bb18: 88 10 00 1d mov %i5, %g4
<== NOT EXECUTED
time->tv_sec += add->tv_sec;
4000bb1c: f4 3e 00 00 std %i2, [ %i0 ]
<== NOT EXECUTED
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
4000bb20: 3b 0e e6 b2 sethi %hi(0x3b9ac800), %i5
<== NOT EXECUTED
4000bb24: ba 17 61 ff or %i5, 0x1ff, %i5 ! 3b9ac9ff <RAM_SIZE+0x3b5ac9ff>
<== NOT EXECUTED
4000bb28: 80 a0 80 1d cmp %g2, %i5
<== NOT EXECUTED
4000bb2c: 08 80 00 10 bleu 4000bb6c <_Timespec_Add_to+0x78>
<== NOT EXECUTED
4000bb30: 82 10 00 02 mov %g2, %g1
4000bb34: 86 86 e0 01 addcc %i3, 1, %g3
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
4000bb38: 39 31 19 4d sethi %hi(0xc4653400), %i4
4000bb3c: 84 46 a0 00 addx %i2, 0, %g2
4000bb40: b8 17 22 00 or %i4, 0x200, %i4
time->tv_sec++;
4000bb44: b6 10 00 03 mov %g3, %i3
4000bb48: 86 80 e0 01 inccc %g3
4000bb4c: b4 10 00 02 mov %g2, %i2
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
4000bb50: 82 00 40 1c add %g1, %i4, %g1
4000bb54: 84 40 a0 00 addx %g2, 0, %g2
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
4000bb58: 80 a0 40 1d cmp %g1, %i5
4000bb5c: 18 bf ff fa bgu 4000bb44 <_Timespec_Add_to+0x50>
<== NEVER TAKEN
4000bb60: 88 01 20 01 inc %g4
4000bb64: c2 26 20 08 st %g1, [ %i0 + 8 ]
4000bb68: f4 3e 00 00 std %i2, [ %i0 ]
seconds++;
}
return seconds;
}
4000bb6c: 81 c7 e0 08 ret
4000bb70: 91 e8 00 04 restore %g0, %g4, %o0
4000d38c <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
4000d38c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
4000d390: de 06 60 08 ld [ %i1 + 8 ], %o7
<== NOT EXECUTED
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
4000d394: c8 06 40 00 ld [ %i1 ], %g4
<== NOT EXECUTED
4000d398: c4 06 60 04 ld [ %i1 + 4 ], %g2
<== NOT EXECUTED
4000d39c: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1
<== NOT EXECUTED
right += rhs->tv_nsec;
4000d3a0: b9 3b e0 1f sra %o7, 0x1f, %i4
<== NOT EXECUTED
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
4000d3a4: 82 10 62 00 or %g1, 0x200, %g1
<== NOT EXECUTED
4000d3a8: 86 50 80 01 umul %g2, %g1, %g3
<== NOT EXECUTED
4000d3ac: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
4000d3b0: 88 59 00 01 smul %g4, %g1, %g4
<== NOT EXECUTED
right += rhs->tv_nsec;
4000d3b4: 96 83 c0 03 addcc %o7, %g3, %o3
<== NOT EXECUTED
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
4000d3b8: 84 01 00 02 add %g4, %g2, %g2
<== NOT EXECUTED
right += rhs->tv_nsec;
4000d3bc: 94 47 00 02 addx %i4, %g2, %o2
<== NOT EXECUTED
if ( right == 0 ) {
4000d3c0: 80 92 80 0b orcc %o2, %o3, %g0
<== NOT EXECUTED
4000d3c4: 02 80 00 20 be 4000d444 <_Timespec_Divide+0xb8>
<== NOT EXECUTED
4000d3c8: 11 00 00 61 sethi %hi(0x18400), %o0
left += lhs->tv_nsec;
4000d3cc: f2 06 20 08 ld [ %i0 + 8 ], %i1
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
4000d3d0: c8 06 00 00 ld [ %i0 ], %g4
4000d3d4: c4 06 20 04 ld [ %i0 + 4 ], %g2
4000d3d8: 86 50 80 01 umul %g2, %g1, %g3
4000d3dc: 85 40 00 00 rd %y, %g2
4000d3e0: 88 59 00 01 smul %g4, %g1, %g4
left += lhs->tv_nsec;
4000d3e4: b9 3e 60 1f sra %i1, 0x1f, %i4
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
4000d3e8: 84 01 00 02 add %g4, %g2, %g2
left += lhs->tv_nsec;
4000d3ec: b2 86 40 03 addcc %i1, %g3, %i1
4000d3f0: b0 47 00 02 addx %i4, %g2, %i0
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
4000d3f4: 90 12 22 a0 or %o0, 0x2a0, %o0
4000d3f8: 82 5e 00 08 smul %i0, %o0, %g1
4000d3fc: 92 56 40 08 umul %i1, %o0, %o1
4000d400: 91 40 00 00 rd %y, %o0
4000d404: 40 00 0e 34 call 40010cd4 <__udivdi3>
4000d408: 90 00 40 08 add %g1, %o0, %o0
*ival_percentage = answer / 1000;
4000d40c: 94 10 20 00 clr %o2
answer = (left * 100000) / right;
4000d410: b8 10 00 08 mov %o0, %i4
4000d414: ba 10 00 09 mov %o1, %i5
*ival_percentage = answer / 1000;
4000d418: 40 00 0e 2f call 40010cd4 <__udivdi3>
4000d41c: 96 10 23 e8 mov 0x3e8, %o3
4000d420: d2 26 80 00 st %o1, [ %i2 ]
*fval_percentage = answer % 1000;
4000d424: 94 10 20 00 clr %o2
4000d428: 96 10 23 e8 mov 0x3e8, %o3
4000d42c: 90 10 00 1c mov %i4, %o0
4000d430: 40 00 0e a2 call 40010eb8 <__umoddi3>
4000d434: 92 10 00 1d mov %i5, %o1
4000d438: d2 26 c0 00 st %o1, [ %i3 ]
}
4000d43c: 81 c7 e0 08 ret
4000d440: 81 e8 00 00 restore
*ival_percentage = 0;
4000d444: c0 26 80 00 clr [ %i2 ]
*fval_percentage = 0;
4000d448: c0 26 c0 00 clr [ %i3 ]
return;
4000d44c: 81 c7 e0 08 ret
4000d450: 81 e8 00 00 restore
4000d830 <_Timespec_Divide_by_integer>:
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
4000d830: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
t = time->tv_sec;
t *= TOD_NANOSECONDS_PER_SECOND;
t += time->tv_nsec;
4000d834: fa 06 20 08 ld [ %i0 + 8 ], %i5
<== NOT EXECUTED
t = time->tv_sec;
4000d838: c6 06 00 00 ld [ %i0 ], %g3
<== NOT EXECUTED
4000d83c: c4 06 20 04 ld [ %i0 + 4 ], %g2
<== NOT EXECUTED
t += time->tv_nsec;
4000d840: 91 3f 60 1f sra %i5, 0x1f, %o0
<== NOT EXECUTED
t *= TOD_NANOSECONDS_PER_SECOND;
4000d844: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1
<== NOT EXECUTED
4000d848: 82 10 62 00 or %g1, 0x200, %g1 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
<== NOT EXECUTED
4000d84c: 88 58 c0 01 smul %g3, %g1, %g4
<== NOT EXECUTED
4000d850: 86 50 80 01 umul %g2, %g1, %g3
<== NOT EXECUTED
4000d854: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
4000d858: ba 87 40 03 addcc %i5, %g3, %i5
<== NOT EXECUTED
t *= TOD_NANOSECONDS_PER_SECOND;
4000d85c: 84 01 00 02 add %g4, %g2, %g2
<== NOT EXECUTED
t /= iterations;
4000d860: 94 10 20 00 clr %o2
<== NOT EXECUTED
4000d864: b8 42 00 02 addx %o0, %g2, %i4
<== NOT EXECUTED
4000d868: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
4000d86c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000d870: 40 00 0d e0 call 40010ff0 <__udivdi3>
<== NOT EXECUTED
4000d874: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
4000d878: 94 10 20 00 clr %o2
t /= iterations;
4000d87c: b8 10 00 08 mov %o0, %i4
4000d880: ba 10 00 09 mov %o1, %i5
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
4000d884: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
4000d888: 40 00 0d da call 40010ff0 <__udivdi3>
4000d88c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
4000d890: d0 3e 80 00 std %o0, [ %i2 ]
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
4000d894: 94 10 20 00 clr %o2
4000d898: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
4000d89c: 90 10 00 1c mov %i4, %o0
4000d8a0: 96 12 e2 00 or %o3, 0x200, %o3
4000d8a4: 40 00 0e 4c call 400111d4 <__umoddi3>
4000d8a8: 92 10 00 1d mov %i5, %o1
4000d8ac: d2 26 a0 08 st %o1, [ %i2 + 8 ]
}
4000d8b0: 81 c7 e0 08 ret
4000d8b4: 81 e8 00 00 restore
4000c4bc <_Timespec_From_ticks>:
struct timespec *time
)
{
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
4000c4bc: 03 10 00 5c sethi %hi(0x40017000), %g1
<== NOT EXECUTED
4000c4c0: c2 00 62 1c ld [ %g1 + 0x21c ], %g1 ! 4001721c <Configuration+0x14>
<== NOT EXECUTED
4000c4c4: 90 5a 00 01 smul %o0, %g1, %o0
<== NOT EXECUTED
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
4000c4c8: 05 00 03 d0 sethi %hi(0xf4000), %g2
<== NOT EXECUTED
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
4000c4cc: 03 10 c6 f7 sethi %hi(0x431bdc00), %g1
<== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
4000c4d0: 84 10 a2 40 or %g2, 0x240, %g2
<== NOT EXECUTED
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
4000c4d4: 82 10 62 83 or %g1, 0x283, %g1
<== NOT EXECUTED
4000c4d8: c0 22 40 00 clr [ %o1 ]
<== NOT EXECUTED
4000c4dc: 80 52 00 01 umul %o0, %g1, %g0
<== NOT EXECUTED
4000c4e0: 83 40 00 00 rd %y, %g1
<== NOT EXECUTED
4000c4e4: 83 30 60 12 srl %g1, 0x12, %g1
<== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
4000c4e8: 84 58 40 02 smul %g1, %g2, %g2
<== NOT EXECUTED
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
4000c4ec: c2 22 60 04 st %g1, [ %o1 + 4 ]
<== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
4000c4f0: 90 22 00 02 sub %o0, %g2, %o0
<== NOT EXECUTED
4000c4f4: 90 5a 23 e8 smul %o0, 0x3e8, %o0
<== NOT EXECUTED
TOD_NANOSECONDS_PER_MICROSECOND;
}
4000c4f8: 81 c3 e0 08 retl
<== NOT EXECUTED
4000c4fc: d0 22 60 08 st %o0, [ %o1 + 8 ]
400104bc <_Timespec_Get_as_nanoseconds>:
#include <rtems/score/todimpl.h>
uint64_t _Timespec_Get_as_nanoseconds(
const struct timespec *time
)
{
400104bc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
return ( ((uint64_t) time->tv_sec) * 1000000000ULL ) + time->tv_nsec;
400104c0: fa 06 20 08 ld [ %i0 + 8 ], %i5
400104c4: c8 06 00 00 ld [ %i0 ], %g4
400104c8: c4 06 20 04 ld [ %i0 + 4 ], %g2
400104cc: b1 3f 60 1f sra %i5, 0x1f, %i0
400104d0: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1
400104d4: 82 10 62 00 or %g1, 0x200, %g1 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
400104d8: 86 50 80 01 umul %g2, %g1, %g3
400104dc: 85 40 00 00 rd %y, %g2
400104e0: 88 59 00 01 smul %g4, %g1, %g4
}
400104e4: 9a 80 c0 1d addcc %g3, %i5, %o5
return ( ((uint64_t) time->tv_sec) * 1000000000ULL ) + time->tv_nsec;
400104e8: 84 01 00 02 add %g4, %g2, %g2
}
400104ec: b2 10 00 0d mov %o5, %i1
400104f0: 98 40 80 18 addx %g2, %i0, %o4
400104f4: 81 c7 e0 08 ret
400104f8: 91 e8 00 0c restore %g0, %o4, %o0
4000c088 <_Timespec_Is_valid>:
bool _Timespec_Is_valid(
const struct timespec *time
)
{
if ( !time )
4000c088: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000c08c: 02 80 00 0b be 4000c0b8 <_Timespec_Is_valid+0x30>
<== NOT EXECUTED
4000c090: 82 10 20 00 clr %g1
return false;
if ( time->tv_sec < 0 )
4000c094: c4 02 00 00 ld [ %o0 ], %g2
4000c098: 80 a0 a0 00 cmp %g2, 0
4000c09c: 06 80 00 07 bl 4000c0b8 <_Timespec_Is_valid+0x30>
4000c0a0: 01 00 00 00 nop
return false;
if ( time->tv_nsec < 0 )
return false;
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
4000c0a4: c4 02 20 08 ld [ %o0 + 8 ], %g2
4000c0a8: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1
4000c0ac: 82 10 61 ff or %g1, 0x1ff, %g1 ! 3b9ac9ff <RAM_SIZE+0x3b5ac9ff>
4000c0b0: 80 a0 40 02 cmp %g1, %g2
4000c0b4: 82 60 3f ff subx %g0, -1, %g1
return false;
return true;
}
4000c0b8: 81 c3 e0 08 retl
4000c0bc: 90 08 60 01 and %g1, 1, %o0
40010bc0 <_Timespec_Less_than>:
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
40010bc0: c4 02 00 00 ld [ %o0 ], %g2
40010bc4: c2 02 40 00 ld [ %o1 ], %g1
40010bc8: c8 02 20 04 ld [ %o0 + 4 ], %g4
40010bcc: 80 a0 40 02 cmp %g1, %g2
40010bd0: 14 80 00 13 bg 40010c1c <_Timespec_Less_than+0x5c>
<== NEVER TAKEN
40010bd4: c6 02 60 04 ld [ %o1 + 4 ], %g3
40010bd8: 02 80 00 0f be 40010c14 <_Timespec_Less_than+0x54>
<== ALWAYS TAKEN
40010bdc: 80 a0 c0 04 cmp %g3, %g4
return true;
if ( lhs->tv_sec > rhs->tv_sec )
40010be0: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
40010be4: 34 80 00 0a bg,a 40010c0c <_Timespec_Less_than+0x4c>
<== NEVER TAKEN
40010be8: 90 10 20 00 clr %o0
<== NOT EXECUTED
40010bec: 02 80 00 0f be 40010c28 <_Timespec_Less_than+0x68>
<== ALWAYS TAKEN
40010bf0: 80 a1 00 03 cmp %g4, %g3
return false;
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
40010bf4: c4 02 20 08 ld [ %o0 + 8 ], %g2
<== NOT EXECUTED
40010bf8: c2 02 60 08 ld [ %o1 + 8 ], %g1
40010bfc: 80 a0 80 01 cmp %g2, %g1
40010c00: 06 80 00 03 bl 40010c0c <_Timespec_Less_than+0x4c>
40010c04: 90 10 20 01 mov 1, %o0
return false;
40010c08: 90 10 20 00 clr %o0
return true;
return false;
}
40010c0c: 81 c3 e0 08 retl
40010c10: 90 0a 20 01 and %o0, 1, %o0
if ( lhs->tv_sec < rhs->tv_sec )
40010c14: 08 bf ff f4 bleu 40010be4 <_Timespec_Less_than+0x24>
40010c18: 80 a0 80 01 cmp %g2, %g1
return true;
40010c1c: 90 10 20 01 mov 1, %o0
}
40010c20: 81 c3 e0 08 retl
40010c24: 90 0a 20 01 and %o0, 1, %o0
if ( lhs->tv_sec > rhs->tv_sec )
40010c28: 28 bf ff f4 bleu,a 40010bf8 <_Timespec_Less_than+0x38>
40010c2c: c4 02 20 08 ld [ %o0 + 8 ], %g2
return false;
40010c30: 10 bf ff f7 b 40010c0c <_Timespec_Less_than+0x4c>
40010c34: 90 10 20 00 clr %o0
40010c38 <_Timespec_Subtract>:
void _Timespec_Subtract(
const struct timespec *start,
const struct timespec *end,
struct timespec *result
)
{
40010c38: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
40010c3c: d8 1e 00 00 ldd [ %i0 ], %o4
<== NOT EXECUTED
40010c40: d4 1e 40 00 ldd [ %i1 ], %o2
40010c44: ba a2 c0 0d subcc %o3, %o5, %i5
if (end->tv_nsec < start->tv_nsec) {
40010c48: c2 06 60 08 ld [ %i1 + 8 ], %g1
40010c4c: c4 06 20 08 ld [ %i0 + 8 ], %g2
40010c50: b8 62 80 0c subx %o2, %o4, %i4
40010c54: 80 a0 40 02 cmp %g1, %g2
40010c58: 26 80 00 07 bl,a 40010c74 <_Timespec_Subtract+0x3c>
40010c5c: b2 87 7f ff addcc %i5, -1, %i1
result->tv_sec = end->tv_sec - start->tv_sec - 1;
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
} else {
result->tv_sec = end->tv_sec - start->tv_sec;
result->tv_nsec = end->tv_nsec - start->tv_nsec;
40010c60: 82 20 40 02 sub %g1, %g2, %g1
result->tv_sec = end->tv_sec - start->tv_sec;
40010c64: f8 3e 80 00 std %i4, [ %i2 ]
result->tv_nsec = end->tv_nsec - start->tv_nsec;
40010c68: c2 26 a0 08 st %g1, [ %i2 + 8 ]
}
}
40010c6c: 81 c7 e0 08 ret
40010c70: 81 e8 00 00 restore
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
40010c74: 82 20 40 02 sub %g1, %g2, %g1
result->tv_sec = end->tv_sec - start->tv_sec - 1;
40010c78: b0 47 3f ff addx %i4, -1, %i0
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
40010c7c: 05 0e e6 b2 sethi %hi(0x3b9ac800), %g2
result->tv_sec = end->tv_sec - start->tv_sec - 1;
40010c80: f0 3e 80 00 std %i0, [ %i2 ]
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
40010c84: 84 10 a2 00 or %g2, 0x200, %g2
40010c88: 82 00 40 02 add %g1, %g2, %g1
result->tv_nsec =
40010c8c: c2 26 a0 08 st %g1, [ %i2 + 8 ]
40010c90: 81 c7 e0 08 ret
40010c94: 81 e8 00 00 restore
40026fc8 <_Timespec_To_ticks>:
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
40026fc8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
uint32_t ticks;
uint32_t nanoseconds_per_tick;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
40026fcc: c2 06 00 00 ld [ %i0 ], %g1
<== NOT EXECUTED
40026fd0: fa 06 20 04 ld [ %i0 + 4 ], %i5
<== NOT EXECUTED
40026fd4: 80 90 40 1d orcc %g1, %i5, %g0
<== NOT EXECUTED
40026fd8: 12 80 00 06 bne 40026ff0 <_Timespec_To_ticks+0x28>
<== NOT EXECUTED
40026fdc: 01 00 00 00 nop
40026fe0: c2 06 20 08 ld [ %i0 + 8 ], %g1
40026fe4: 80 a0 60 00 cmp %g1, 0
40026fe8: 02 80 00 11 be 4002702c <_Timespec_To_ticks+0x64>
40026fec: 90 10 20 00 clr %o0
/**
* We should ensure the ticks not be truncated by integer division. We
* need to have it be greater than or equal to the requested time. It
* should not be shorter.
*/
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
40026ff0: 40 00 5c 16 call 4003e048 <TOD_TICKS_PER_SECOND_method>
40026ff4: 01 00 00 00 nop
nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick();
ticks += time->tv_nsec / nanoseconds_per_tick;
40026ff8: c2 06 20 08 ld [ %i0 + 8 ], %g1
nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick();
40026ffc: 05 10 01 7a sethi %hi(0x4005e800), %g2
40027000: c4 00 a0 a4 ld [ %g2 + 0xa4 ], %g2 ! 4005e8a4 <_Watchdog_Nanoseconds_per_tick>
ticks += time->tv_nsec / nanoseconds_per_tick;
40027004: 81 80 20 00 wr %g0, %y
40027008: 01 00 00 00 nop
4002700c: 01 00 00 00 nop
40027010: 01 00 00 00 nop
40027014: b0 70 40 02 udiv %g1, %g2, %i0
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
40027018: 90 5a 00 1d smul %o0, %i5, %o0
if ( (time->tv_nsec % nanoseconds_per_tick) != 0 )
4002701c: 84 5e 00 02 smul %i0, %g2, %g2
40027020: 82 20 40 02 sub %g1, %g2, %g1
ticks += 1;
40027024: 80 a0 00 01 cmp %g0, %g1
40027028: 90 42 00 18 addx %o0, %i0, %o0
return ticks;
}
4002702c: 81 c7 e0 08 ret
40027030: 91 e8 00 08 restore %g0, %o0, %o0
4000bc18 <_User_extensions_Add_set>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000bc18: 91 d0 20 09 ta 9
<== NOT EXECUTED
old_last = tail->previous;
4000bc1c: 05 10 00 6d sethi %hi(0x4001b400), %g2
4000bc20: 84 10 a1 d8 or %g2, 0x1d8, %g2 ! 4001b5d8 <_User_extensions_List>
4000bc24: c6 00 a0 08 ld [ %g2 + 8 ], %g3
the_node->next = tail;
4000bc28: 88 00 a0 04 add %g2, 4, %g4
4000bc2c: c8 22 00 00 st %g4, [ %o0 ]
tail->previous = the_node;
4000bc30: d0 20 a0 08 st %o0, [ %g2 + 8 ]
old_last->next = the_node;
4000bc34: d0 20 c0 00 st %o0, [ %g3 ]
the_node->previous = old_last;
4000bc38: c6 22 20 04 st %g3, [ %o0 + 4 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000bc3c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000bc40: 01 00 00 00 nop
/*
* If a switch handler is present, append it to the switch chain.
*/
if ( the_extension->Callouts.thread_switch != NULL ) {
4000bc44: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
4000bc48: 80 a0 60 00 cmp %g1, 0
4000bc4c: 02 80 00 0f be 4000bc88 <_User_extensions_Add_set+0x70>
4000bc50: 01 00 00 00 nop
ISR_Level level;
the_extension->Switch.thread_switch =
4000bc54: c2 22 20 10 st %g1, [ %o0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000bc58: 91 d0 20 09 ta 9
<== NOT EXECUTED
old_last = tail->previous;
4000bc5c: 05 10 00 6d sethi %hi(0x4001b400), %g2
<== NOT EXECUTED
4000bc60: 84 10 a2 3c or %g2, 0x23c, %g2 ! 4001b63c <_User_extensions_Switches_list>
<== NOT EXECUTED
4000bc64: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
the_node->next = tail;
4000bc68: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
4000bc6c: c8 22 20 08 st %g4, [ %o0 + 8 ]
<== NOT EXECUTED
the_extension->Callouts.thread_switch;
_Per_CPU_Acquire_all( level );
_Chain_Initialize_node( &the_extension->Switch.Node );
4000bc70: 88 02 20 08 add %o0, 8, %g4
<== NOT EXECUTED
tail->previous = the_node;
4000bc74: c8 20 a0 08 st %g4, [ %g2 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
4000bc78: c8 20 c0 00 st %g4, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
4000bc7c: c6 22 20 0c st %g3, [ %o0 + 0xc ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000bc80: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000bc84: 01 00 00 00 nop
&_User_extensions_Switches_list,
&the_extension->Switch.Node
);
_Per_CPU_Release_all( level );
}
}
4000bc88: 81 c3 e0 08 retl
4000bc8c: 01 00 00 00 nop
4000bd80 <_User_extensions_Fatal_visitor>:
void _User_extensions_Fatal_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
4000bd80: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
User_extensions_fatal_extension callout = callouts->fatal;
4000bd84: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
<== NOT EXECUTED
if ( callout != NULL ) {
4000bd88: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000bd8c: 02 80 00 06 be 4000bda4 <_User_extensions_Fatal_visitor+0x24>
<== NOT EXECUTED
4000bd90: 01 00 00 00 nop
const User_extensions_Fatal_context *ctx = arg;
(*callout)( ctx->source, false, ctx->error );
4000bd94: d4 06 60 04 ld [ %i1 + 4 ], %o2
4000bd98: d0 06 40 00 ld [ %i1 ], %o0
4000bd9c: 9f c0 40 00 call %g1
4000bda0: 92 10 20 00 clr %o1
}
}
4000bda4: 81 c7 e0 08 ret
4000bda8: 81 e8 00 00 restore
4000bf48 <_User_extensions_Handler_initialization>:
#include <rtems/config.h>
#include <rtems/score/userextimpl.h>
#include <rtems/score/wkspace.h>
void _User_extensions_Handler_initialization(void)
{
4000bf48: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
User_extensions_Switch_control *initial_extension_switch_controls;
const User_extensions_Table *initial_table;
uint32_t n;
uint32_t i;
n = rtems_configuration_get_number_of_initial_extensions();
4000bf4c: 39 10 00 63 sethi %hi(0x40018c00), %i4
4000bf50: b8 17 20 e8 or %i4, 0xe8, %i4 ! 40018ce8 <Configuration>
4000bf54: f6 07 20 34 ld [ %i4 + 0x34 ], %i3
initial_extension_switch_controls = _Workspace_Allocate_or_fatal_error(
n * sizeof( *initial_extension_switch_controls )
4000bf58: 87 2e e0 01 sll %i3, 1, %g3
4000bf5c: 86 00 c0 1b add %g3, %i3, %g3
4000bf60: bb 28 e0 02 sll %g3, 2, %i5
initial_extension_switch_controls = _Workspace_Allocate_or_fatal_error(
4000bf64: 40 00 01 2b call 4000c410 <_Workspace_Allocate_or_fatal_error>
4000bf68: 90 10 00 1d mov %i5, %o0
);
initial_table = rtems_configuration_get_user_extension_table();
for ( i = 0 ; i < n ; ++i ) {
4000bf6c: 80 a6 e0 00 cmp %i3, 0
4000bf70: 02 80 00 15 be 4000bfc4 <_User_extensions_Handler_initialization+0x7c> <== NEVER TAKEN
4000bf74: c2 07 20 38 ld [ %i4 + 0x38 ], %g1
old_last = tail->previous;
4000bf78: 09 10 00 6d sethi %hi(0x4001b400), %g4
4000bf7c: 86 02 00 1d add %o0, %i5, %g3
4000bf80: 88 11 22 3c or %g4, 0x23c, %g4
4000bf84: 82 00 60 10 add %g1, 0x10, %g1
the_node->next = tail;
4000bf88: ba 01 20 04 add %g4, 4, %i5
User_extensions_thread_switch_extension callout;
callout = initial_table[ i ].thread_switch;
4000bf8c: c4 00 40 00 ld [ %g1 ], %g2
if ( callout != NULL ) {
4000bf90: 80 a0 a0 00 cmp %g2, 0
4000bf94: 22 80 00 09 be,a 4000bfb8 <_User_extensions_Handler_initialization+0x70>
4000bf98: 90 02 20 0c add %o0, 0xc, %o0
User_extensions_Switch_control *c;
c = &initial_extension_switch_controls[ i ];
c->thread_switch = callout;
4000bf9c: c4 22 20 08 st %g2, [ %o0 + 8 ]
old_last = tail->previous;
4000bfa0: c4 01 20 08 ld [ %g4 + 8 ], %g2
the_node->next = tail;
4000bfa4: fa 22 00 00 st %i5, [ %o0 ]
tail->previous = the_node;
4000bfa8: d0 21 20 08 st %o0, [ %g4 + 8 ]
old_last->next = the_node;
4000bfac: d0 20 80 00 st %o0, [ %g2 ]
the_node->previous = old_last;
4000bfb0: c4 22 20 04 st %g2, [ %o0 + 4 ]
4000bfb4: 90 02 20 0c add %o0, 0xc, %o0
for ( i = 0 ; i < n ; ++i ) {
4000bfb8: 80 a2 00 03 cmp %o0, %g3
4000bfbc: 12 bf ff f4 bne 4000bf8c <_User_extensions_Handler_initialization+0x44>
4000bfc0: 82 00 60 24 add %g1, 0x24, %g1
_Chain_Initialize_node( &c->Node );
_Chain_Append_unprotected( &_User_extensions_Switches_list, &c->Node );
}
}
}
4000bfc4: 81 c7 e0 08 ret
4000bfc8: 81 e8 00 00 restore
4000bdd0 <_User_extensions_Iterate>:
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor,
Chain_Iterator_direction direction
)
{
4000bdd0: 9d e3 bf 88 save %sp, -120, %sp
<== NOT EXECUTED
User_extensions_Iterator iter;
ISR_lock_Context lock_context;
executing = _Thread_Get_executing();
initial_begin = rtems_configuration_get_user_extension_table();
4000bdd4: 03 10 00 63 sethi %hi(0x40018c00), %g1
<== NOT EXECUTED
4000bdd8: 82 10 60 e8 or %g1, 0xe8, %g1 ! 40018ce8 <Configuration>
initial_end =
initial_begin + rtems_configuration_get_number_of_initial_extensions();
4000bddc: c4 00 60 34 ld [ %g1 + 0x34 ], %g2
initial_begin = rtems_configuration_get_user_extension_table();
4000bde0: e0 00 60 38 ld [ %g1 + 0x38 ], %l0
initial_begin + rtems_configuration_get_number_of_initial_extensions();
4000bde4: bb 28 a0 03 sll %g2, 3, %i5
4000bde8: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4
4000bdec: ba 07 40 02 add %i5, %g2, %i5
if ( direction == CHAIN_ITERATOR_FORWARD ) {
4000bdf0: 80 a6 a0 00 cmp %i2, 0
initial_begin + rtems_configuration_get_number_of_initial_extensions();
4000bdf4: bb 2f 60 02 sll %i5, 2, %i5
if ( direction == CHAIN_ITERATOR_FORWARD ) {
4000bdf8: 12 80 00 50 bne 4000bf38 <_User_extensions_Iterate+0x168>
4000bdfc: ba 04 00 1d add %l0, %i5, %i5
initial_current = initial_begin;
while ( initial_current != initial_end ) {
4000be00: 80 a4 00 1d cmp %l0, %i5
4000be04: 02 80 00 0a be 4000be2c <_User_extensions_Iterate+0x5c> <== NEVER TAKEN
4000be08: b6 10 00 10 mov %l0, %i3
(*visitor)( executing, arg, initial_current );
4000be0c: 94 10 00 1b mov %i3, %o2
4000be10: 92 10 00 18 mov %i0, %o1
4000be14: 9f c6 40 00 call %i1
4000be18: 90 10 00 1c mov %i4, %o0
++initial_current;
4000be1c: b6 06 e0 24 add %i3, 0x24, %i3
while ( initial_current != initial_end ) {
4000be20: 80 a7 40 1b cmp %i5, %i3
4000be24: 12 bf ff fb bne 4000be10 <_User_extensions_Iterate+0x40>
4000be28: 94 10 00 1b mov %i3, %o2
}
end = _Chain_Immutable_tail( &_User_extensions_List.Active );
4000be2c: 37 10 00 6d sethi %hi(0x4001b400), %i3
<== NOT EXECUTED
4000be30: b6 16 e1 dc or %i3, 0x1dc, %i3 ! 4001b5dc <_User_extensions_List+0x4>
<== NOT EXECUTED
4000be34: 84 06 ff fc add %i3, -4, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000be38: 91 d0 20 09 ta 9
<== NOT EXECUTED
old_last = tail->previous;
4000be3c: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
tail->previous = the_node;
4000be40: 86 07 bf ec add %fp, -20, %g3
the_node->next = tail;
4000be44: 9e 00 a0 10 add %g2, 0x10, %o7
tail->previous = the_node;
4000be48: c6 20 a0 14 st %g3, [ %g2 + 0x14 ]
&the_iterator->Registry_node
);
the_iterator->direction = direction;
if ( direction == CHAIN_ITERATOR_FORWARD ) {
4000be4c: 80 a6 a0 00 cmp %i2, 0
the_node->next = tail;
4000be50: de 27 bf ec st %o7, [ %fp + -20 ]
old_last->next = the_node;
4000be54: c6 21 00 00 st %g3, [ %g4 ]
the_node->previous = old_last;
4000be58: c8 27 bf f0 st %g4, [ %fp + -16 ]
if ( direction == CHAIN_ITERATOR_FORWARD ) {
4000be5c: 02 80 00 03 be 4000be68 <_User_extensions_Iterate+0x98>
4000be60: f4 27 bf f4 st %i2, [ %fp + -12 ]
the_iterator->position = _Chain_Head( the_chain );
} else {
the_iterator->position = _Chain_Tail( the_chain );
4000be64: 84 00 a0 04 add %g2, 4, %g2
&_User_extensions_List.Iterators,
&iter.Iterator,
direction
);
if ( executing != NULL ) {
4000be68: 80 a7 20 00 cmp %i4, 0
4000be6c: 02 80 00 05 be 4000be80 <_User_extensions_Iterate+0xb0>
4000be70: c4 27 bf f8 st %g2, [ %fp + -8 ]
iter.previous = executing->last_user_extensions_iterator;
4000be74: c4 07 21 88 ld [ %i4 + 0x188 ], %g2
4000be78: c4 27 bf fc st %g2, [ %fp + -4 ]
executing->last_user_extensions_iterator = &iter;
4000be7c: c6 27 21 88 st %g3, [ %i4 + 0x188 ]
end = _Chain_Immutable_head( &_User_extensions_List.Active );
4000be80: 10 80 00 0f b 4000bebc <_User_extensions_Iterate+0xec>
4000be84: 84 10 00 1a mov %i2, %g2
4000be88: d4 00 c0 00 ld [ %g3 ], %o2
}
while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) {
4000be8c: 80 a6 c0 0a cmp %i3, %o2
4000be90: 02 80 00 13 be 4000bedc <_User_extensions_Iterate+0x10c>
4000be94: 80 a7 20 00 cmp %i4, 0
RTEMS_INLINE_ROUTINE void _Chain_Iterator_set_position(
Chain_Iterator *the_iterator,
Chain_Node *the_node
)
{
the_iterator->position = the_node;
4000be98: d4 27 bf f8 st %o2, [ %fp + -8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000be9c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000bea0: 01 00 00 00 nop
_Chain_Iterator_set_position( &iter.Iterator, node );
_User_extensions_Release( &lock_context );
extension = (const User_extensions_Control *) node;
( *visitor )( executing, arg, &extension->Callouts );
4000bea4: 94 02 a0 14 add %o2, 0x14, %o2
4000bea8: 92 10 00 18 mov %i0, %o1
4000beac: 9f c6 40 00 call %i1
4000beb0: 90 10 00 1c mov %i4, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000beb4: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable_and_acquire(
4000beb8: c4 07 bf f4 ld [ %fp + -12 ], %g2
if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) {
4000bebc: 80 a0 a0 00 cmp %g2, 0
4000bec0: 02 bf ff f2 be 4000be88 <_User_extensions_Iterate+0xb8>
4000bec4: c6 07 bf f8 ld [ %fp + -8 ], %g3
4000bec8: d4 00 e0 04 ld [ %g3 + 4 ], %o2
while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) {
4000becc: 80 a6 c0 0a cmp %i3, %o2
4000bed0: 32 bf ff f3 bne,a 4000be9c <_User_extensions_Iterate+0xcc>
4000bed4: d4 27 bf f8 st %o2, [ %fp + -8 ]
_User_extensions_Acquire( &lock_context );
}
if ( executing != NULL ) {
4000bed8: 80 a7 20 00 cmp %i4, 0
4000bedc: 02 80 00 03 be 4000bee8 <_User_extensions_Iterate+0x118>
4000bee0: c4 07 bf fc ld [ %fp + -4 ], %g2
executing->last_user_extensions_iterator = iter.previous;
4000bee4: c4 27 21 88 st %g2, [ %i4 + 0x188 ]
next = the_node->next;
4000bee8: c6 07 bf ec ld [ %fp + -20 ], %g3
previous = the_node->previous;
4000beec: c4 07 bf f0 ld [ %fp + -16 ], %g2
next->previous = previous;
4000bef0: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
4000bef4: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000bef8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000befc: 01 00 00 00 nop
_Chain_Iterator_destroy( &iter.Iterator );
_User_extensions_Release( &lock_context );
if ( direction == CHAIN_ITERATOR_BACKWARD ) {
4000bf00: 80 a6 a0 01 cmp %i2, 1
4000bf04: 02 80 00 09 be 4000bf28 <_User_extensions_Iterate+0x158>
4000bf08: 80 a4 00 1d cmp %l0, %i5
while ( initial_current != initial_begin ) {
--initial_current;
(*visitor)( executing, arg, initial_current );
}
}
}
4000bf0c: 81 c7 e0 08 ret
4000bf10: 81 e8 00 00 restore
(*visitor)( executing, arg, initial_current );
4000bf14: 92 10 00 18 mov %i0, %o1
4000bf18: 94 10 00 1d mov %i5, %o2
4000bf1c: 9f c6 40 00 call %i1
4000bf20: 90 10 00 1c mov %i4, %o0
while ( initial_current != initial_begin ) {
4000bf24: 80 a4 00 1d cmp %l0, %i5
4000bf28: 12 bf ff fb bne 4000bf14 <_User_extensions_Iterate+0x144>
4000bf2c: ba 07 7f dc add %i5, -36, %i5
}
4000bf30: 81 c7 e0 08 ret
4000bf34: 81 e8 00 00 restore
end = _Chain_Immutable_head( &_User_extensions_List.Active );
4000bf38: 05 10 00 6d sethi %hi(0x4001b400), %g2
4000bf3c: 84 10 a1 d8 or %g2, 0x1d8, %g2 ! 4001b5d8 <_User_extensions_List>
4000bf40: 10 bf ff be b 4000be38 <_User_extensions_Iterate+0x68>
4000bf44: b6 10 00 02 mov %g2, %i3
4000c5b8 <_User_extensions_Remove_set>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000c5b8: 91 d0 20 09 ta 9
<== NOT EXECUTED
iter_node = _Chain_Head( &the_registry->Iterators );
4000c5bc: 05 10 00 57 sethi %hi(0x40015c00), %g2
4000c5c0: 84 10 a2 68 or %g2, 0x268, %g2 ! 40015e68 <_User_extensions_List+0xc>
4000c5c4: 88 00 a0 04 add %g2, 4, %g4
4000c5c8: c4 00 80 00 ld [ %g2 ], %g2
while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
4000c5cc: 80 a0 80 04 cmp %g2, %g4
4000c5d0: 22 80 00 11 be,a 4000c614 <_User_extensions_Remove_set+0x5c> <== ALWAYS TAKEN
4000c5d4: c6 02 00 00 ld [ %o0 ], %g3
if ( iter->position == the_node_to_extract ) {
4000c5d8: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
<== NOT EXECUTED
4000c5dc: 80 a2 00 03 cmp %o0, %g3
<== NOT EXECUTED
4000c5e0: 32 bf ff fb bne,a 4000c5cc <_User_extensions_Remove_set+0x14>
<== NOT EXECUTED
4000c5e4: c4 00 80 00 ld [ %g2 ], %g2
<== NOT EXECUTED
if ( iter->direction == CHAIN_ITERATOR_FORWARD ) {
4000c5e8: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
4000c5ec: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
4000c5f0: 32 80 00 1b bne,a 4000c65c <_User_extensions_Remove_set+0xa4>
<== NOT EXECUTED
4000c5f4: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
4000c5f8: c6 02 20 04 ld [ %o0 + 4 ], %g3
<== NOT EXECUTED
iter->position = _Chain_Previous( the_node_to_extract );
4000c5fc: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
<== NOT EXECUTED
4000c600: c4 00 80 00 ld [ %g2 ], %g2
<== NOT EXECUTED
while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
4000c604: 80 a0 80 04 cmp %g2, %g4
<== NOT EXECUTED
4000c608: 32 bf ff f5 bne,a 4000c5dc <_User_extensions_Remove_set+0x24>
<== NOT EXECUTED
4000c60c: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
<== NOT EXECUTED
next = the_node->next;
4000c610: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
previous = the_node->previous;
4000c614: c4 02 20 04 ld [ %o0 + 4 ], %g2
<== NOT EXECUTED
next->previous = previous;
4000c618: c4 20 e0 04 st %g2, [ %g3 + 4 ]
<== NOT EXECUTED
previous->next = next;
4000c61c: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c620: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c624: 01 00 00 00 nop
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL ) {
4000c628: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
4000c62c: 80 a0 60 00 cmp %g1, 0
4000c630: 02 80 00 09 be 4000c654 <_User_extensions_Remove_set+0x9c>
4000c634: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000c638: 91 d0 20 09 ta 9
<== NOT EXECUTED
next = the_node->next;
4000c63c: c6 02 20 08 ld [ %o0 + 8 ], %g3
<== NOT EXECUTED
previous = the_node->previous;
4000c640: c4 02 20 0c ld [ %o0 + 0xc ], %g2
<== NOT EXECUTED
next->previous = previous;
4000c644: c4 20 e0 04 st %g2, [ %g3 + 4 ]
<== NOT EXECUTED
previous->next = next;
4000c648: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c64c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c650: 01 00 00 00 nop
_Per_CPU_Acquire_all( level );
_Chain_Extract_unprotected( &the_extension->Switch.Node );
_Per_CPU_Release_all( level );
}
}
4000c654: 81 c3 e0 08 retl
4000c658: 01 00 00 00 nop
iter->position = _Chain_Next( the_node_to_extract );
4000c65c: 10 bf ff db b 4000c5c8 <_User_extensions_Remove_set+0x10>
<== NOT EXECUTED
4000c660: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
<== NOT EXECUTED
4000bd38 <_User_extensions_Thread_begin_visitor>:
void _User_extensions_Thread_begin_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
4000bd38: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
User_extensions_thread_begin_extension callout = callouts->thread_begin;
4000bd3c: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1
<== NOT EXECUTED
if ( callout != NULL ) {
4000bd40: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000bd44: 02 80 00 04 be 4000bd54 <_User_extensions_Thread_begin_visitor+0x1c>
<== NOT EXECUTED
4000bd48: 01 00 00 00 nop
(*callout)( executing );
4000bd4c: 9f c0 40 00 call %g1
4000bd50: 90 10 00 18 mov %i0, %o0
}
}
4000bd54: 81 c7 e0 08 ret
4000bd58: 81 e8 00 00 restore
4000bc90 <_User_extensions_Thread_create_visitor>:
void _User_extensions_Thread_create_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
4000bc90: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
User_extensions_thread_create_extension callout = callouts->thread_create;
4000bc94: c4 06 80 00 ld [ %i2 ], %g2
if ( callout != NULL ) {
4000bc98: 80 a0 a0 00 cmp %g2, 0
4000bc9c: 02 80 00 0a be 4000bcc4 <_User_extensions_Thread_create_visitor+0x34>
4000bca0: 01 00 00 00 nop
User_extensions_Thread_create_context *ctx = arg;
ctx->ok = ctx->ok && (*callout)( executing, ctx->created );
4000bca4: d0 0e 60 04 ldub [ %i1 + 4 ], %o0
4000bca8: 80 8a 20 ff btst 0xff, %o0
4000bcac: 22 80 00 06 be,a 4000bcc4 <_User_extensions_Thread_create_visitor+0x34> <== NEVER TAKEN
4000bcb0: d0 2e 60 04 stb %o0, [ %i1 + 4 ]
<== NOT EXECUTED
4000bcb4: d2 06 40 00 ld [ %i1 ], %o1
4000bcb8: 9f c0 80 00 call %g2
4000bcbc: 90 10 00 18 mov %i0, %o0
4000bcc0: d0 2e 60 04 stb %o0, [ %i1 + 4 ]
}
}
4000bcc4: 81 c7 e0 08 ret
4000bcc8: 81 e8 00 00 restore
4000bccc <_User_extensions_Thread_delete_visitor>:
void _User_extensions_Thread_delete_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
4000bccc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
User_extensions_thread_delete_extension callout = callouts->thread_delete;
4000bcd0: c2 06 a0 0c ld [ %i2 + 0xc ], %g1
<== NOT EXECUTED
if ( callout != NULL ) {
4000bcd4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000bcd8: 02 80 00 04 be 4000bce8 <_User_extensions_Thread_delete_visitor+0x1c>
4000bcdc: 92 10 00 19 mov %i1, %o1
(*callout)( executing, arg );
4000bce0: 9f c0 40 00 call %g1
4000bce4: 90 10 00 18 mov %i0, %o0
}
}
4000bce8: 81 c7 e0 08 ret
4000bcec: 81 e8 00 00 restore
4000bd5c <_User_extensions_Thread_exitted_visitor>:
void _User_extensions_Thread_exitted_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
4000bd5c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
User_extensions_thread_exitted_extension callout = callouts->thread_exitted;
4000bd60: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
<== NOT EXECUTED
if ( callout != NULL ) {
4000bd64: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000bd68: 02 80 00 04 be 4000bd78 <_User_extensions_Thread_exitted_visitor+0x1c>
<== NOT EXECUTED
4000bd6c: 01 00 00 00 nop
(*callout)( executing );
4000bd70: 9f c0 40 00 call %g1
4000bd74: 90 10 00 18 mov %i0, %o0
}
}
4000bd78: 81 c7 e0 08 ret
4000bd7c: 81 e8 00 00 restore
4000bd14 <_User_extensions_Thread_restart_visitor>:
void _User_extensions_Thread_restart_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
4000bd14: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
User_extensions_thread_restart_extension callout = callouts->thread_restart;
4000bd18: c2 06 a0 08 ld [ %i2 + 8 ], %g1
<== NOT EXECUTED
if ( callout != NULL ) {
4000bd1c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000bd20: 02 80 00 04 be 4000bd30 <_User_extensions_Thread_restart_visitor+0x1c>
<== NOT EXECUTED
4000bd24: 92 10 00 19 mov %i1, %o1
(*callout)( executing, arg );
4000bd28: 9f c0 40 00 call %g1
4000bd2c: 90 10 00 18 mov %i0, %o0
}
}
4000bd30: 81 c7 e0 08 ret
4000bd34: 81 e8 00 00 restore
4000bcf0 <_User_extensions_Thread_start_visitor>:
void _User_extensions_Thread_start_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
4000bcf0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
User_extensions_thread_start_extension callout = callouts->thread_start;
4000bcf4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
if ( callout != NULL ) {
4000bcf8: 80 a0 60 00 cmp %g1, 0
4000bcfc: 02 80 00 04 be 4000bd0c <_User_extensions_Thread_start_visitor+0x1c>
4000bd00: 92 10 00 19 mov %i1, %o1
(*callout)( executing, arg );
4000bd04: 9f c0 40 00 call %g1
4000bd08: 90 10 00 18 mov %i0, %o0
}
}
4000bd0c: 81 c7 e0 08 ret
4000bd10: 81 e8 00 00 restore
4000bdac <_User_extensions_Thread_terminate_visitor>:
void _User_extensions_Thread_terminate_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
4000bdac: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
User_extensions_thread_terminate_extension callout =
4000bdb0: c2 06 a0 20 ld [ %i2 + 0x20 ], %g1
<== NOT EXECUTED
callouts->thread_terminate;
if ( callout != NULL ) {
4000bdb4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000bdb8: 02 80 00 04 be 4000bdc8 <_User_extensions_Thread_terminate_visitor+0x1c>
4000bdbc: 01 00 00 00 nop
(*callout)( executing );
4000bdc0: 9f c0 40 00 call %g1
4000bdc4: 90 10 00 18 mov %i0, %o0
}
}
4000bdc8: 81 c7 e0 08 ret
4000bdcc: 81 e8 00 00 restore
4000c044 <_Watchdog_Do_tickle>:
#ifdef RTEMS_SMP
ISR_lock_Control *lock,
#endif
ISR_lock_Context *lock_context
)
{
4000c044: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
4000c048: ba 10 20 02 mov 2, %i5
do {
if ( first->expire <= now ) {
4000c04c: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
4000c050: 80 a0 40 1a cmp %g1, %i2
4000c054: 18 80 00 26 bgu 4000c0ec <_Watchdog_Do_tickle+0xa8>
4000c058: 01 00 00 00 nop
4000c05c: 22 80 00 21 be,a 4000c0e0 <_Watchdog_Do_tickle+0x9c>
4000c060: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4000c064: c4 06 60 04 ld [ %i1 + 4 ], %g2
if ( node != NULL ) {
4000c068: 80 a0 a0 00 cmp %g2, 0
4000c06c: 32 80 00 05 bne,a 4000c080 <_Watchdog_Do_tickle+0x3c>
4000c070: c2 00 80 00 ld [ %g2 ], %g1
4000c074: 10 80 00 19 b 4000c0d8 <_Watchdog_Do_tickle+0x94>
4000c078: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000c07c: c2 00 80 00 ld [ %g2 ], %g1
<== NOT EXECUTED
while ( ( left = _RBTree_Left( node ) ) != NULL ) {
4000c080: 80 a0 60 00 cmp %g1, 0
4000c084: 32 bf ff fe bne,a 4000c07c <_Watchdog_Do_tickle+0x38> <== NEVER TAKEN
4000c088: 84 10 00 01 mov %g1, %g2
<== NOT EXECUTED
header->first = node;
4000c08c: c4 26 20 04 st %g2, [ %i0 + 4 ]
Watchdog_Service_routine_entry routine;
_Watchdog_Next_first( header, first );
_RBTree_Extract( &header->Watchdogs, &first->Node.RBTree );
4000c090: 92 10 00 19 mov %i1, %o1
4000c094: 7f ff f4 9e call 4000930c <_RBTree_Extract>
4000c098: 90 10 00 18 mov %i0, %o0
_Watchdog_Set_state( first, WATCHDOG_INACTIVE );
routine = first->routine;
4000c09c: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
<== NOT EXECUTED
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
4000c0a0: fa 26 60 0c st %i5, [ %i1 + 0xc ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000c0a4: c2 07 00 00 ld [ %i4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c0a8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c0ac: 01 00 00 00 nop
_ISR_lock_Release_and_ISR_enable( lock, lock_context );
( *routine )( first );
4000c0b0: 9f c0 80 00 call %g2
4000c0b4: 90 10 00 19 mov %i1, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000c0b8: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable_and_acquire( lock, lock_context );
4000c0bc: c2 27 00 00 st %g1, [ %i4 ]
4000c0c0: f2 06 20 04 ld [ %i0 + 4 ], %i1
} else {
break;
}
first = _Watchdog_Header_first( header );
} while ( first != NULL );
4000c0c4: 80 a6 60 00 cmp %i1, 0
4000c0c8: 32 bf ff e2 bne,a 4000c050 <_Watchdog_Do_tickle+0xc>
4000c0cc: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
}
4000c0d0: 81 c7 e0 08 ret
4000c0d4: 81 e8 00 00 restore
header->first = _RBTree_Parent( &the_watchdog->Node.RBTree );
4000c0d8: 10 bf ff ee b 4000c090 <_Watchdog_Do_tickle+0x4c>
4000c0dc: c2 26 20 04 st %g1, [ %i0 + 4 ]
if ( first->expire <= now ) {
4000c0e0: 80 a0 40 1b cmp %g1, %i3
4000c0e4: 28 bf ff e1 bleu,a 4000c068 <_Watchdog_Do_tickle+0x24>
4000c0e8: c4 06 60 04 ld [ %i1 + 4 ], %g2
}
4000c0ec: 81 c7 e0 08 ret
4000c0f0: 81 e8 00 00 restore
4000f338 <_Watchdog_Insert>:
_Assert( _Watchdog_Get_state( the_watchdog ) == WATCHDOG_INACTIVE );
link = _RBTree_Root_reference( &header->Watchdogs );
parent = NULL;
old_first = header->first;
4000f338: d8 02 20 04 ld [ %o0 + 4 ], %o4
<== NOT EXECUTED
new_first = &the_watchdog->Node.RBTree;
the_watchdog->expire = expire;
4000f33c: d4 22 60 18 st %o2, [ %o1 + 0x18 ]
<== NOT EXECUTED
link = _RBTree_Root_reference( &header->Watchdogs );
4000f340: 84 10 00 08 mov %o0, %g2
the_watchdog->expire = expire;
4000f344: d6 22 60 1c st %o3, [ %o1 + 0x1c ]
{
4000f348: 86 10 00 09 mov %o1, %g3
while ( *link != NULL ) {
4000f34c: c2 00 80 00 ld [ %g2 ], %g1
new_first = &the_watchdog->Node.RBTree;
4000f350: 9a 10 00 09 mov %o1, %o5
while ( *link != NULL ) {
4000f354: 80 a0 60 00 cmp %g1, 0
4000f358: 02 80 00 12 be 4000f3a0 <_Watchdog_Insert+0x68>
4000f35c: 88 10 20 00 clr %g4
Watchdog_Control *parent_watchdog;
parent = *link;
parent_watchdog = (Watchdog_Control *) parent;
if ( expire < parent_watchdog->expire ) {
4000f360: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4000f364: 80 a0 80 0a cmp %g2, %o2
4000f368: 18 80 00 09 bgu 4000f38c <_Watchdog_Insert+0x54>
4000f36c: 84 10 00 01 mov %g1, %g2
4000f370: 12 80 00 17 bne 4000f3cc <_Watchdog_Insert+0x94>
4000f374: 84 00 60 04 add %g1, 4, %g2
4000f378: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
4000f37c: 80 a0 80 0b cmp %g2, %o3
4000f380: 08 80 00 13 bleu 4000f3cc <_Watchdog_Insert+0x94>
4000f384: 84 00 60 04 add %g1, 4, %g2
return &RB_LEFT( the_node, Node );
4000f388: 84 10 00 01 mov %g1, %g2
link = _RBTree_Left_reference( parent );
} else {
link = _RBTree_Right_reference( parent );
new_first = old_first;
4000f38c: 88 10 00 01 mov %g1, %g4
while ( *link != NULL ) {
4000f390: c2 00 80 00 ld [ %g2 ], %g1
4000f394: 80 a0 60 00 cmp %g1, 0
4000f398: 32 bf ff f3 bne,a 4000f364 <_Watchdog_Insert+0x2c>
4000f39c: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
}
}
header->first = new_first;
4000f3a0: da 22 20 04 st %o5, [ %o0 + 4 ]
RB_SET( child, parent, Node );
4000f3a4: 82 10 20 01 mov 1, %g1
4000f3a8: c8 20 e0 08 st %g4, [ %g3 + 8 ]
_RBTree_Initialize_node( &the_watchdog->Node.RBTree );
_RBTree_Add_child( &the_watchdog->Node.RBTree, parent, link );
_RBTree_Insert_color( &header->Watchdogs, &the_watchdog->Node.RBTree );
4000f3ac: 92 10 00 03 mov %g3, %o1
4000f3b0: c0 20 e0 04 clr [ %g3 + 4 ]
4000f3b4: c0 20 c0 00 clr [ %g3 ]
4000f3b8: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
*link = child;
4000f3bc: c6 20 80 00 st %g3, [ %g2 ]
4000f3c0: 82 13 c0 00 mov %o7, %g1
4000f3c4: 7f ff f4 d3 call 4000c710 <_RBTree_Insert_color>
4000f3c8: 9e 10 40 00 mov %g1, %o7
new_first = old_first;
4000f3cc: 9a 10 00 0c mov %o4, %o5
4000f3d0: 10 bf ff f0 b 4000f390 <_Watchdog_Insert+0x58>
4000f3d4: 88 10 00 01 mov %g1, %g4
4000bfcc <_Watchdog_Remove>:
void _Watchdog_Remove(
Watchdog_Header *header,
Watchdog_Control *the_watchdog
)
{
4000bfcc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( _Watchdog_Is_scheduled( the_watchdog ) ) {
4000bfd0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
<== NOT EXECUTED
4000bfd4: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000bfd8: 28 80 00 04 bleu,a 4000bfe8 <_Watchdog_Remove+0x1c>
<== NOT EXECUTED
4000bfdc: c2 06 20 04 ld [ %i0 + 4 ], %g1
}
_RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree );
_Watchdog_Set_state( the_watchdog, WATCHDOG_INACTIVE );
}
}
4000bfe0: 81 c7 e0 08 ret
4000bfe4: 81 e8 00 00 restore
if ( header->first == &the_watchdog->Node.RBTree ) {
4000bfe8: 80 a0 40 19 cmp %g1, %i1
4000bfec: 22 80 00 09 be,a 4000c010 <_Watchdog_Remove+0x44>
4000bff0: c4 06 60 04 ld [ %i1 + 4 ], %g2
_RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree );
4000bff4: 92 10 00 19 mov %i1, %o1
4000bff8: 7f ff f4 c5 call 4000930c <_RBTree_Extract>
4000bffc: 90 10 00 18 mov %i0, %o0
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
4000c000: 82 10 20 02 mov 2, %g1
4000c004: c2 26 60 0c st %g1, [ %i1 + 0xc ]
}
4000c008: 81 c7 e0 08 ret
4000c00c: 81 e8 00 00 restore
if ( node != NULL ) {
4000c010: 80 a0 a0 00 cmp %g2, 0
4000c014: 32 80 00 05 bne,a 4000c028 <_Watchdog_Remove+0x5c>
4000c018: c2 00 80 00 ld [ %g2 ], %g1
4000c01c: 10 80 00 08 b 4000c03c <_Watchdog_Remove+0x70>
4000c020: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000c024: c2 00 80 00 ld [ %g2 ], %g1
<== NOT EXECUTED
while ( ( left = _RBTree_Left( node ) ) != NULL ) {
4000c028: 80 a0 60 00 cmp %g1, 0
4000c02c: 32 bf ff fe bne,a 4000c024 <_Watchdog_Remove+0x58>
<== NEVER TAKEN
4000c030: 84 10 00 01 mov %g1, %g2
<== NOT EXECUTED
header->first = node;
4000c034: 10 bf ff f0 b 4000bff4 <_Watchdog_Remove+0x28>
4000c038: c4 26 20 04 st %g2, [ %i0 + 4 ]
header->first = _RBTree_Parent( &the_watchdog->Node.RBTree );
4000c03c: 10 bf ff ee b 4000bff4 <_Watchdog_Remove+0x28>
4000c040: c2 26 20 04 st %g1, [ %i0 + 4 ]
4000c0f4 <_Watchdog_Tick>:
void _Watchdog_Tick( Per_CPU_Control *cpu )
{
4000c0f4: 9d e3 bf 88 save %sp, -120, %sp
<== NOT EXECUTED
Watchdog_Control *first;
uint64_t ticks;
struct timespec now;
if ( _Per_CPU_Is_boot_processor( cpu ) ) {
++_Watchdog_Ticks_since_boot;
4000c0f8: 05 10 00 7e sethi %hi(0x4001f800), %g2
<== NOT EXECUTED
4000c0fc: c2 00 a1 dc ld [ %g2 + 0x1dc ], %g1 ! 4001f9dc <_Watchdog_Ticks_since_boot>
<== NOT EXECUTED
4000c100: 82 00 60 01 inc %g1
<== NOT EXECUTED
4000c104: c2 20 a1 dc st %g1, [ %g2 + 0x1dc ]
<== NOT EXECUTED
4000c108: 91 d0 20 09 ta 9
<== NOT EXECUTED
}
_ISR_lock_ISR_disable_and_acquire( &cpu->Watchdog.Lock, &lock_context );
4000c10c: c2 27 bf ec st %g1, [ %fp + -20 ]
ticks = cpu->Watchdog.ticks;
4000c110: c4 1e 20 30 ldd [ %i0 + 0x30 ], %g2
_Assert( ticks < UINT64_MAX );
++ticks;
4000c114: 96 80 e0 01 addcc %g3, 1, %o3
4000c118: 94 40 a0 00 addx %g2, 0, %o2
cpu->Watchdog.ticks = ticks;
4000c11c: d4 3e 20 30 std %o2, [ %i0 + 0x30 ]
4000c120: d2 06 20 3c ld [ %i0 + 0x3c ], %o1
header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ];
first = _Watchdog_Header_first( header );
if ( first != NULL ) {
4000c124: 80 a2 60 00 cmp %o1, 0
4000c128: 02 80 00 04 be 4000c138 <_Watchdog_Tick+0x44>
4000c12c: 98 07 bf ec add %fp, -20, %o4
_Watchdog_Tickle(
4000c130: 7f ff ff c5 call 4000c044 <_Watchdog_Do_tickle>
4000c134: 90 06 20 38 add %i0, 0x38, %o0
4000c138: fa 06 20 4c ld [ %i0 + 0x4c ], %i5
}
header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_MONOTONIC ];
first = _Watchdog_Header_first( header );
if ( first != NULL ) {
4000c13c: 80 a7 60 00 cmp %i5, 0
4000c140: 22 80 00 11 be,a 4000c184 <_Watchdog_Tick+0x90>
4000c144: fa 06 20 44 ld [ %i0 + 0x44 ], %i5
_Timecounter_Getnanouptime( &now );
4000c148: 7f ff f2 32 call 40008a10 <_Timecounter_Getnanouptime>
4000c14c: 90 07 bf f0 add %fp, -16, %o0
ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS;
4000c150: c2 07 bf f0 ld [ %fp + -16 ], %g1
ticks = (uint64_t) ts->tv_sec;
4000c154: d6 07 bf f4 ld [ %fp + -12 ], %o3
ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS;
4000c158: 83 28 60 1e sll %g1, 0x1e, %g1
4000c15c: 95 32 e0 02 srl %o3, 2, %o2
_Watchdog_Tickle(
4000c160: 94 12 80 01 or %o2, %g1, %o2
4000c164: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000c168: 97 2a e0 1e sll %o3, 0x1e, %o3
4000c16c: 98 07 bf ec add %fp, -20, %o4
4000c170: 96 10 40 0b or %g1, %o3, %o3
4000c174: 92 10 00 1d mov %i5, %o1
4000c178: 7f ff ff b3 call 4000c044 <_Watchdog_Do_tickle>
4000c17c: 90 06 20 48 add %i0, 0x48, %o0
4000c180: fa 06 20 44 ld [ %i0 + 0x44 ], %i5
}
header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_REALTIME ];
first = _Watchdog_Header_first( header );
if ( first != NULL ) {
4000c184: 80 a7 60 00 cmp %i5, 0
4000c188: 02 80 00 10 be 4000c1c8 <_Watchdog_Tick+0xd4>
4000c18c: 01 00 00 00 nop
_Timecounter_Getnanotime( &now );
4000c190: 7f ff f2 46 call 40008aa8 <_Timecounter_Getnanotime>
4000c194: 90 07 bf f0 add %fp, -16, %o0
4000c198: c2 07 bf f0 ld [ %fp + -16 ], %g1
ticks = (uint64_t) ts->tv_sec;
4000c19c: d6 07 bf f4 ld [ %fp + -12 ], %o3
ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS;
4000c1a0: 83 28 60 1e sll %g1, 0x1e, %g1
4000c1a4: 95 32 e0 02 srl %o3, 2, %o2
_Watchdog_Tickle(
4000c1a8: 94 12 80 01 or %o2, %g1, %o2
4000c1ac: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000c1b0: 97 2a e0 1e sll %o3, 0x1e, %o3
4000c1b4: 98 07 bf ec add %fp, -20, %o4
4000c1b8: 96 10 40 0b or %g1, %o3, %o3
4000c1bc: 92 10 00 1d mov %i5, %o1
4000c1c0: 7f ff ff a1 call 4000c044 <_Watchdog_Do_tickle>
4000c1c4: 90 06 20 40 add %i0, 0x40, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000c1c8: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c1cc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c1d0: 01 00 00 00 nop
Thread_Control *executing = cpu->executing;
4000c1d4: d2 06 20 20 ld [ %i0 + 0x20 ], %o1
if ( scheduler != NULL && executing != NULL ) {
4000c1d8: 80 a2 60 00 cmp %o1, 0
4000c1dc: 02 80 00 06 be 4000c1f4 <_Watchdog_Tick+0x100>
4000c1e0: 11 10 00 63 sethi %hi(0x40018c00), %o0
( *scheduler->Operations.tick )( scheduler, executing );
4000c1e4: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 40018dc8 <_Scheduler_Table>
4000c1e8: c2 02 20 34 ld [ %o0 + 0x34 ], %g1
4000c1ec: 9f c0 40 00 call %g1
4000c1f0: 01 00 00 00 nop
}
_ISR_lock_Release_and_ISR_enable( &cpu->Watchdog.Lock, &lock_context );
_Scheduler_Tick( cpu );
}
4000c1f4: 81 c7 e0 08 ret
4000c1f8: 81 e8 00 00 restore
4000c3b8 <_Workspace_Allocate>:
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
4000c3b8: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
4000c3bc: 96 10 20 00 clr %o3
4000c3c0: 11 10 00 7e sethi %hi(0x4001f800), %o0
4000c3c4: 94 10 20 00 clr %o2
4000c3c8: 90 12 21 e0 or %o0, 0x1e0, %o0
4000c3cc: 82 13 c0 00 mov %o7, %g1
4000c3d0: 7f ff eb 8e call 40007208 <_Heap_Allocate_aligned_with_boundary>
4000c3d4: 9e 10 40 00 mov %g1, %o7
4000c3d8 <_Workspace_Allocate_aligned>:
return _Heap_Allocate_aligned_with_boundary( heap, size, alignment, 0 );
4000c3d8: 94 10 00 09 mov %o1, %o2
<== NOT EXECUTED
4000c3dc: 96 10 20 00 clr %o3
<== NOT EXECUTED
4000c3e0: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
4000c3e4: 11 10 00 7e sethi %hi(0x4001f800), %o0
<== NOT EXECUTED
4000c3e8: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 4001f9e0 <_Workspace_Area>
<== NOT EXECUTED
4000c3ec: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000c3f0: 7f ff eb 86 call 40007208 <_Heap_Allocate_aligned_with_boundary>
<== NOT EXECUTED
4000c3f4: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000c410 <_Workspace_Allocate_or_fatal_error>:
}
void *_Workspace_Allocate_or_fatal_error(
size_t size
)
{
4000c410: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
4000c414: 96 10 20 00 clr %o3
<== NOT EXECUTED
4000c418: 94 10 20 00 clr %o2
<== NOT EXECUTED
4000c41c: 92 10 00 18 mov %i0, %o1
4000c420: 11 10 00 7e sethi %hi(0x4001f800), %o0
4000c424: 7f ff eb 79 call 40007208 <_Heap_Allocate_aligned_with_boundary>
4000c428: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 4001f9e0 <_Workspace_Area>
__builtin_return_address( 1 ),
memory
);
#endif
if ( memory == NULL )
4000c42c: 80 a2 20 00 cmp %o0, 0
4000c430: 02 80 00 04 be 4000c440 <_Workspace_Allocate_or_fatal_error+0x30>
4000c434: b0 10 00 08 mov %o0, %i0
_Internal_error( INTERNAL_ERROR_WORKSPACE_ALLOCATION );
return memory;
}
4000c438: 81 c7 e0 08 ret
4000c43c: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_WORKSPACE_ALLOCATION );
4000c440: 7f ff ed 19 call 400078a4 <_Internal_error>
4000c444: 90 10 20 03 mov 3, %o0
4000c448: 01 00 00 00 nop
<== NOT EXECUTED
...
4000c3f8 <_Workspace_Free>:
block,
__builtin_return_address( 0 ),
__builtin_return_address( 1 )
);
#endif
_Heap_Free( &_Workspace_Area, block );
4000c3f8: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
4000c3fc: 11 10 00 7e sethi %hi(0x4001f800), %o0
4000c400: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 4001f9e0 <_Workspace_Area>
4000c404: 82 13 c0 00 mov %o7, %g1
4000c408: 40 00 06 35 call 4000dcdc <_Heap_Free>
4000c40c: 9e 10 40 00 mov %g1, %o7
4000c1fc <_Workspace_Handler_initialization>:
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
4000c1fc: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize; uintptr_t remaining = rtems_configuration_get_work_space_size();
4000c200: 03 10 00 63 sethi %hi(0x40018c00), %g1
<== NOT EXECUTED
4000c204: 86 10 60 e8 or %g1, 0xe8, %g3 ! 40018ce8 <Configuration>
4000c208: c4 08 e0 32 ldub [ %g3 + 0x32 ], %g2
4000c20c: 80 a0 a0 00 cmp %g2, 0
4000c210: 12 80 00 04 bne 4000c220 <_Workspace_Handler_initialization+0x24>
4000c214: f8 00 60 e8 ld [ %g1 + 0xe8 ], %i4
4000c218: c2 00 e0 04 ld [ %g3 + 4 ], %g1
4000c21c: b8 07 00 01 add %i4, %g1, %i4
bool do_zero = rtems_configuration_get_do_zero_of_workspace();
4000c220: c8 08 e0 30 ldub [ %g3 + 0x30 ], %g4
bool unified = rtems_configuration_get_unified_work_area();
4000c224: c6 08 e0 31 ldub [ %g3 + 0x31 ], %g3
bool do_zero = rtems_configuration_get_do_zero_of_workspace();
4000c228: c8 2f bf ff stb %g4, [ %fp + -1 ]
return (uintptr_t) _TLS_BSS_end - (uintptr_t) _TLS_Data_begin;
4000c22c: 03 10 00 68 sethi %hi(0x4001a000), %g1
4000c230: 82 10 62 d0 or %g1, 0x2d0, %g1 ! 4001a2d0 <_Linker_set__Sysinit_bsp_work_area_initialize>
4000c234: 05 10 00 68 sethi %hi(0x4001a000), %g2
4000c238: 84 10 a2 d0 or %g2, 0x2d0, %g2 ! 4001a2d0 <_Linker_set__Sysinit_bsp_work_area_initialize>
* workspace is large enough to fulfill all requests known at configuration
* time (so excluding the unlimited option). It is not possible to estimate
* the TLS size in the configuration at compile-time. The TLS size is
* determined at application link-time.
*/
if ( tls_size > 0 ) {
4000c23c: 82 a0 40 02 subcc %g1, %g2, %g1
4000c240: 02 80 00 1b be 4000c2ac <_Workspace_Handler_initialization+0xb0>
4000c244: c6 2f bf fe stb %g3, [ %fp + -2 ]
return (val + msk) & ~msk;
4000c248: 05 00 00 00 sethi %hi(0), %g2
4000c24c: 84 10 a0 01 or %g2, 1, %g2 ! 1 <_TLS_Alignment>
4000c250: 84 00 a0 07 add %g2, 7, %g2
4000c254: 84 08 bf f8 and %g2, -8, %g2
sizeof(TLS_Thread_control_block) : alignment;
4000c258: 80 a0 a0 08 cmp %g2, 8
4000c25c: 2a 80 00 02 bcs,a 4000c264 <_Workspace_Handler_initialization+0x68> <== NEVER TAKEN
4000c260: 84 10 20 08 mov 8, %g2
<== NOT EXECUTED
thread_count += rtems_resource_maximum_per_allocation(
4000c264: 09 10 00 6e sethi %hi(0x4001b800), %g4
if ( page_size < alignment ) {
page_size = alignment;
}
return HEAP_BLOCK_HEADER_SIZE + page_size - 1 + size;
4000c268: 85 28 a0 01 sll %g2, 1, %g2
4000c26c: fa 01 21 60 ld [ %g4 + 0x160 ], %i5
4000c270: 07 10 00 6c sethi %hi(0x4001b000), %g3
4000c274: c6 00 e3 44 ld [ %g3 + 0x344 ], %g3 ! 4001b344 <Configuration_RTEMS_API>
return (val + msk) & ~msk;
4000c278: 82 00 60 07 add %g1, 7, %g1
4000c27c: 09 00 00 3f sethi %hi(0xfc00), %g4
4000c280: 82 08 7f f8 and %g1, -8, %g1
4000c284: 88 11 23 ff or %g4, 0x3ff, %g4
4000c288: 82 00 60 0f add %g1, 0xf, %g1
4000c28c: 86 08 c0 04 and %g3, %g4, %g3
4000c290: 82 00 80 01 add %g2, %g1, %g1
4000c294: 84 0f 40 04 and %i5, %g4, %g2
4000c298: 84 00 c0 02 add %g3, %g2, %g2
4000c29c: 84 00 a0 01 inc %g2
* size.
*/
remaining += _Heap_Min_block_size( page_size );
remaining += _Get_maximum_thread_count()
* _Heap_Size_with_overhead( page_size, tls_alloc, tls_align );
4000c2a0: 82 58 40 02 smul %g1, %g2, %g1
remaining += _Get_maximum_thread_count()
4000c2a4: 82 00 60 10 add %g1, 0x10, %g1
4000c2a8: b8 07 00 01 add %i4, %g1, %i4
}
for (i = 0; i < area_count; ++i) {
4000c2ac: 80 a6 60 00 cmp %i1, 0
4000c2b0: 02 80 00 2d be 4000c364 <_Workspace_Handler_initialization+0x168> <== NEVER TAKEN
4000c2b4: 80 a7 20 00 cmp %i4, 0
4000c2b8: f6 0f bf ff ldub [ %fp + -1 ], %i3
if ( area->size > overhead ) {
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
4000c2bc: e2 0f bf fe ldub [ %fp + -2 ], %l1
4000c2c0: b3 2e 60 03 sll %i1, 3, %i1
for (i = 0; i < area_count; ++i) {
4000c2c4: 21 10 00 1d sethi %hi(0x40007400), %l0
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
4000c2c8: 25 10 00 7e sethi %hi(0x4001f800), %l2
4000c2cc: b2 06 00 19 add %i0, %i1, %i1
for (i = 0; i < area_count; ++i) {
4000c2d0: a0 14 21 80 or %l0, 0x180, %l0
space_available = (*init_or_extend)(
4000c2d4: a4 14 a1 e0 or %l2, 0x1e0, %l2
if ( do_zero ) {
4000c2d8: 80 a6 e0 00 cmp %i3, 0
4000c2dc: 12 80 00 26 bne 4000c374 <_Workspace_Handler_initialization+0x178>
4000c2e0: fa 06 20 04 ld [ %i0 + 4 ], %i5
if ( area->size > overhead ) {
4000c2e4: 80 a7 60 16 cmp %i5, 0x16
4000c2e8: 28 80 00 1b bleu,a 4000c354 <_Workspace_Handler_initialization+0x158>
4000c2ec: b0 06 20 08 add %i0, 8, %i0
if ( unified ) {
4000c2f0: 80 a4 60 00 cmp %l1, 0
4000c2f4: 12 80 00 09 bne 4000c318 <_Workspace_Handler_initialization+0x11c>
4000c2f8: d2 06 00 00 ld [ %i0 ], %o1
if ( remaining > 0 ) {
4000c2fc: 80 a7 20 00 cmp %i4, 0
4000c300: 02 80 00 23 be 4000c38c <_Workspace_Handler_initialization+0x190> <== NEVER TAKEN
4000c304: 96 10 20 08 mov 8, %o3
size = remaining < area->size - overhead ?
4000c308: 82 07 7f ea add %i5, -22, %g1
remaining + overhead : area->size;
4000c30c: 80 a0 40 1c cmp %g1, %i4
4000c310: 38 80 00 02 bgu,a 4000c318 <_Workspace_Handler_initialization+0x11c> <== ALWAYS TAKEN
4000c314: ba 07 20 16 add %i4, 0x16, %i5
space_available = (*init_or_extend)(
4000c318: 94 10 00 1d mov %i5, %o2
4000c31c: 96 10 20 08 mov 8, %o3
4000c320: 9f c4 00 00 call %l0
4000c324: 90 10 00 12 mov %l2, %o0
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
4000c328: c4 06 00 00 ld [ %i0 ], %g2
area->size -= size;
4000c32c: c2 06 20 04 ld [ %i0 + 4 ], %g1
area->begin = (char *) area->begin + size;
4000c330: 84 00 80 1d add %g2, %i5, %g2
area->size -= size;
4000c334: ba 20 40 1d sub %g1, %i5, %i5
area->begin = (char *) area->begin + size;
4000c338: c4 26 00 00 st %g2, [ %i0 ]
if ( space_available < remaining ) {
4000c33c: 80 a2 00 1c cmp %o0, %i4
4000c340: 1a 80 00 18 bcc 4000c3a0 <_Workspace_Handler_initialization+0x1a4> <== ALWAYS TAKEN
4000c344: fa 26 20 04 st %i5, [ %i0 + 4 ]
remaining -= space_available;
4000c348: b8 27 00 08 sub %i4, %o0, %i4
<== NOT EXECUTED
} else {
remaining = 0;
}
init_or_extend = extend;
4000c34c: a0 10 00 1a mov %i2, %l0
<== NOT EXECUTED
4000c350: b0 06 20 08 add %i0, 8, %i0
for (i = 0; i < area_count; ++i) {
4000c354: 80 a6 40 18 cmp %i1, %i0
4000c358: 12 bf ff e1 bne 4000c2dc <_Workspace_Handler_initialization+0xe0> <== NEVER TAKEN
4000c35c: 80 a6 e0 00 cmp %i3, 0
}
}
if ( remaining > 0 ) {
4000c360: 80 a7 20 00 cmp %i4, 0
4000c364: 12 80 00 12 bne 4000c3ac <_Workspace_Handler_initialization+0x1b0>
4000c368: 01 00 00 00 nop
_Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE );
}
_Heap_Protection_set_delayed_free_fraction( &_Workspace_Area, 1 );
}
4000c36c: 81 c7 e0 08 ret
4000c370: 81 e8 00 00 restore
memset( area->begin, 0, area->size );
4000c374: d0 06 00 00 ld [ %i0 ], %o0
4000c378: 94 10 00 1d mov %i5, %o2
4000c37c: 40 00 0b a1 call 4000f200 <memset>
4000c380: 92 10 20 00 clr %o1
4000c384: 10 bf ff d8 b 4000c2e4 <_Workspace_Handler_initialization+0xe8>
4000c388: fa 06 20 04 ld [ %i0 + 4 ], %i5
space_available = (*init_or_extend)(
4000c38c: 94 10 20 00 clr %o2
<== NOT EXECUTED
4000c390: 9f c4 00 00 call %l0
<== NOT EXECUTED
4000c394: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
init_or_extend = extend;
4000c398: 10 bf ff ee b 4000c350 <_Workspace_Handler_initialization+0x154>
<== NOT EXECUTED
4000c39c: a0 10 00 1a mov %i2, %l0
<== NOT EXECUTED
4000c3a0: a0 10 00 1a mov %i2, %l0
remaining = 0;
4000c3a4: 10 bf ff eb b 4000c350 <_Workspace_Handler_initialization+0x154>
4000c3a8: b8 10 20 00 clr %i4
_Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE );
4000c3ac: 7f ff ed 3e call 400078a4 <_Internal_error>
4000c3b0: 90 10 20 02 mov 2, %o0
4000c3b4: 01 00 00 00 nop
<== NOT EXECUTED
400104a4 <_Workspace_String_duplicate>:
char *_Workspace_String_duplicate(
const char *string,
size_t len
)
{
400104a4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
char *dup = _Workspace_Allocate(len + 1);
400104a8: 7f ff ff da call 40010410 <_Workspace_Allocate>
<== NOT EXECUTED
400104ac: 90 06 60 01 add %i1, 1, %o0
<== NOT EXECUTED
if (dup != NULL) {
400104b0: ba 92 20 00 orcc %o0, 0, %i5
400104b4: 02 80 00 05 be 400104c8 <_Workspace_String_duplicate+0x24>
400104b8: 94 10 00 19 mov %i1, %o2
dup [len] = '\0';
400104bc: c0 2f 40 19 clrb [ %i5 + %i1 ]
memcpy(dup, string, len);
400104c0: 40 00 07 de call 40012438 <memcpy>
400104c4: 92 10 00 18 mov %i0, %o1
}
return dup;
}
400104c8: 81 c7 e0 08 ret
400104cc: 91 e8 00 1d restore %g0, %i5, %o0
...