RTEMS-5
Annotated Report
Wed Aug 8 20:48:22 2018
4001bc14 <TOD_TICKS_PER_SECOND_method>:
uint32_t TOD_TICKS_PER_SECOND_method(void)
{
return (TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick());
}
4001bc14: 11 00 03 d0 sethi %hi(0xf4000), %o0
<== NOT EXECUTED
4001bc18: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <_Configuration_Interrupt_stack_size+0xf3240>
<== NOT EXECUTED
4001bc1c: 03 10 00 b4 sethi %hi(0x4002d000), %g1
<== NOT EXECUTED
4001bc20: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
4001bc24: c4 00 63 2c ld [ %g1 + 0x32c ], %g2
<== NOT EXECUTED
4001bc28: 01 00 00 00 nop
<== NOT EXECUTED
4001bc2c: 01 00 00 00 nop
<== NOT EXECUTED
4001bc30: 84 72 00 02 udiv %o0, %g2, %g2
<== NOT EXECUTED
4001bc34: 81 c3 e0 08 retl
<== NOT EXECUTED
4001bc38: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
40006ab4 <_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();
40006ab4: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
40006ab8: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2
<== NOT EXECUTED
40006abc: 82 18 40 02 xor %g1, %g2, %g1
<== NOT EXECUTED
}
40006ac0: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
40006ac4: 81 c3 e0 08 retl
<== NOT EXECUTED
40006ac8: 90 60 3f ff subx %g0, -1, %o0
4001a658 <_CORE_message_queue_Close>:
void _CORE_message_queue_Close(
CORE_message_queue_Control *the_message_queue,
Thread_queue_Context *queue_context
)
{
4001a658: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
/*
* This will flush blocked threads whether they were blocked on
* a send or receive.
*/
_Thread_queue_Flush_critical(
4001a65c: d2 06 20 0c ld [ %i0 + 0xc ], %o1
<== NOT EXECUTED
4001a660: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001a664: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
4001a668: 15 10 00 69 sethi %hi(0x4001a400), %o2
<== NOT EXECUTED
4001a66c: 7f ff e6 a9 call 40014110 <_Thread_queue_Flush_critical>
<== NOT EXECUTED
4001a670: 94 12 a2 4c or %o2, 0x24c, %o2 ! 4001a64c <_CORE_message_queue_Was_deleted>
<== NOT EXECUTED
the_message_queue->operations,
_CORE_message_queue_Was_deleted,
queue_context
);
(void) _Workspace_Free( the_message_queue->message_buffers );
4001a674: f0 06 20 28 ld [ %i0 + 0x28 ], %i0
<== NOT EXECUTED
4001a678: 7f ff ee ea call 40016220 <_Workspace_Free>
<== NOT EXECUTED
4001a67c: 81 e8 00 00 restore
<== NOT EXECUTED
4000f5d8 <_CORE_mutex_Seize_slow>:
const Thread_queue_Operations *operations,
Thread_Control *executing,
bool wait,
Thread_queue_Context *queue_context
)
{
4000f5d8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( wait ) {
4000f5dc: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
4000f5e0: 02 80 00 0f be 4000f61c <_CORE_mutex_Seize_slow+0x44>
<== NOT EXECUTED
4000f5e4: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
queue_context->thread_state = thread_state;
4000f5e8: c2 27 20 04 st %g1, [ %i4 + 4 ]
<== NOT EXECUTED
queue_context->deadlock_callout = deadlock_callout;
4000f5ec: 03 10 00 4f sethi %hi(0x40013c00), %g1
<== NOT EXECUTED
4000f5f0: 82 10 60 dc or %g1, 0xdc, %g1 ! 40013cdc <_Thread_queue_Deadlock_status>
<== NOT EXECUTED
4000f5f4: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
<== NOT EXECUTED
);
_Thread_queue_Context_set_deadlock_callout(
queue_context,
_Thread_queue_Deadlock_status
);
_Thread_queue_Enqueue(
4000f5f8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000f5fc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000f600: 96 10 00 1c mov %i4, %o3
<== NOT EXECUTED
4000f604: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000f608: 40 00 11 bd call 40013cfc <_Thread_queue_Enqueue>
<== NOT EXECUTED
4000f60c: b0 10 20 00 clr %i0
<== NOT EXECUTED
return (Status_Control) the_thread->Wait.return_code;
4000f610: f2 06 a0 4c ld [ %i2 + 0x4c ], %i1
<== NOT EXECUTED
return _Thread_Wait_get_status( executing );
} else {
_CORE_mutex_Release( the_mutex, queue_context );
return STATUS_UNAVAILABLE;
}
}
4000f614: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f618: 81 e8 00 00 restore
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f61c: c2 07 00 00 ld [ %i4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f620: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f624: 01 00 00 00 nop
<== NOT EXECUTED
return STATUS_UNAVAILABLE;
4000f628: 33 00 00 04 sethi %hi(0x1000), %i1
<== NOT EXECUTED
4000f62c: b2 16 60 0d or %i1, 0xd, %i1 ! 100d <_Configuration_Interrupt_stack_size+0xd>
<== NOT EXECUTED
}
4000f630: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f634: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
4000f638 <_CORE_semaphore_Initialize>:
void _CORE_semaphore_Initialize(
CORE_semaphore_Control *the_semaphore,
uint32_t initial_value
)
{
the_semaphore->count = initial_value;
4000f638: d2 22 20 0c st %o1, [ %o0 + 0xc ]
<== NOT EXECUTED
_Thread_queue_Object_initialize( &the_semaphore->Wait_queue );
4000f63c: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000f640: 40 00 13 23 call 400142cc <_Thread_queue_Object_initialize>
<== NOT EXECUTED
4000f644: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
400578fc <_Condition_Broadcast>:
_Condition_Wake( _condition, 1 );
}
void _Condition_Broadcast( struct _Condition_Control *_condition )
{
_Condition_Wake( _condition, INT_MAX );
400578fc: 13 1f ff ff sethi %hi(0x7ffffc00), %o1
<== NOT EXECUTED
40057900: 92 12 63 ff or %o1, 0x3ff, %o1 ! 7fffffff <RAM_END+0x3fbfffff>
<== NOT EXECUTED
40057904: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40057908: 7f ff ff d2 call 40057850 <_Condition_Wake>
<== NOT EXECUTED
4005790c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40019fec <_Condition_Wait>:
{
40019fec: 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;
40019ff0: 03 10 00 67 sethi %hi(0x40019c00), %g1
<== NOT EXECUTED
context->mutex = _mutex;
40019ff4: f2 27 bf fc st %i1, [ %fp + -4 ]
<== NOT EXECUTED
40019ff8: 82 10 63 88 or %g1, 0x388, %g1
<== NOT EXECUTED
40019ffc: c2 27 bf e0 st %g1, [ %fp + -32 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001a000: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &context->Base.Lock_context.Lock_context );
4001a004: c2 27 bf d8 st %g1, [ %fp + -40 ]
<== NOT EXECUTED
queue_context->thread_state = thread_state;
4001a008: 82 10 20 20 mov 0x20, %g1
<== NOT EXECUTED
_Thread_queue_Enqueue(
4001a00c: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
<== NOT EXECUTED
4001a010: 90 06 20 08 add %i0, 8, %o0
<== NOT EXECUTED
4001a014: 96 07 bf d8 add %fp, -40, %o3
<== NOT EXECUTED
4001a018: c2 27 bf dc st %g1, [ %fp + -36 ]
<== NOT EXECUTED
4001a01c: 13 10 01 f5 sethi %hi(0x4007d400), %o1
<== NOT EXECUTED
4001a020: 40 00 10 c3 call 4001e32c <_Thread_queue_Enqueue>
<== NOT EXECUTED
4001a024: 92 12 63 98 or %o1, 0x398, %o1 ! 4007d798 <_Thread_queue_Operations_FIFO>
<== NOT EXECUTED
_Mutex_Acquire( _mutex );
4001a028: 40 00 07 7c call 4001be18 <_Mutex_Acquire>
<== NOT EXECUTED
4001a02c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
}
4001a030: 81 c7 e0 08 ret
<== NOT EXECUTED
4001a034: 81 e8 00 00 restore
<== NOT EXECUTED
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 ]
<== NOT EXECUTED
queue_context->thread_state = thread_state;
400578c8: 82 10 20 20 mov 0x20, %g1
<== NOT EXECUTED
_Thread_queue_Enqueue(
400578cc: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
<== NOT EXECUTED
400578d0: 96 07 bf d8 add %fp, -40, %o3
<== NOT EXECUTED
400578d4: 90 06 20 08 add %i0, 8, %o0
<== NOT EXECUTED
400578d8: c2 27 bf dc st %g1, [ %fp + -36 ]
<== NOT EXECUTED
400578dc: 13 10 02 46 sethi %hi(0x40091800), %o1
<== NOT EXECUTED
400578e0: 40 00 0d e5 call 4005b074 <_Thread_queue_Enqueue>
<== NOT EXECUTED
400578e4: 92 12 63 b8 or %o1, 0x3b8, %o1 ! 40091bb8 <_Thread_queue_Operations_FIFO>
<== NOT EXECUTED
_Mutex_recursive_Acquire( _mutex );
400578e8: 40 00 06 14 call 40059138 <_Mutex_recursive_Acquire>
<== NOT EXECUTED
400578ec: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
_mutex->_nest_level = nest_level;
400578f0: fa 26 60 14 st %i5, [ %i1 + 0x14 ]
<== NOT EXECUTED
}
400578f4: 81 c7 e0 08 ret
<== NOT EXECUTED
400578f8: 81 e8 00 00 restore
<== NOT EXECUTED
40006bb0 <_Freechain_Get>:
Freechain_Control *freechain,
Freechain_Allocator allocator,
size_t number_nodes_to_extend,
size_t node_size
)
{
40006bb0: 9d e3 bf a0 save %sp, -96, %sp
40006bb4: ba 10 00 18 mov %i0, %i5
return _Chain_Immutable_head( the_chain )->next;
40006bb8: f0 06 00 00 ld [ %i0 ], %i0
return &the_chain->Tail.Node;
40006bbc: 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 ) {
40006bc0: 80 a6 00 1c cmp %i0, %i4
40006bc4: 12 80 00 04 bne 40006bd4 <_Freechain_Get+0x24>
40006bc8: 80 a6 a0 00 cmp %i2, 0
40006bcc: 12 80 00 0a bne 40006bf4 <_Freechain_Get+0x44>
<== ALWAYS TAKEN
40006bd0: 01 00 00 00 nop
if ( !_Chain_Is_empty(the_chain))
40006bd4: 80 a7 00 18 cmp %i4, %i0
40006bd8: 02 80 00 12 be 40006c20 <_Freechain_Get+0x70>
<== NEVER TAKEN
40006bdc: 01 00 00 00 nop
new_first = old_first->next;
40006be0: c2 06 00 00 ld [ %i0 ], %g1
head->next = new_first;
40006be4: c2 27 40 00 st %g1, [ %i5 ]
new_first->previous = head;
40006be8: fa 20 60 04 st %i5, [ %g1 + 4 ]
40006bec: 81 c7 e0 08 ret
40006bf0: 81 e8 00 00 restore
void *starting_address;
starting_address = ( *allocator )( number_nodes_to_extend * node_size );
40006bf4: 9f c6 40 00 call %i1
40006bf8: 90 5e 80 1b smul %i2, %i3, %o0
number_nodes_to_extend *= ( starting_address != NULL );
40006bfc: 80 a0 00 08 cmp %g0, %o0
starting_address = ( *allocator )( number_nodes_to_extend * node_size );
40006c00: 92 10 00 08 mov %o0, %o1
number_nodes_to_extend *= ( starting_address != NULL );
40006c04: 94 40 20 00 addx %g0, 0, %o2
_Chain_Initialize(
40006c08: 96 10 00 1b mov %i3, %o3
40006c0c: 94 5a 80 1a smul %o2, %i2, %o2
40006c10: 7f ff ff c7 call 40006b2c <_Chain_Initialize>
40006c14: 90 10 00 1d mov %i5, %o0
40006c18: 10 bf ff ef b 40006bd4 <_Freechain_Get+0x24>
40006c1c: f0 07 40 00 ld [ %i5 ], %i0
node_size
);
}
return _Chain_Get_unprotected( &freechain->Free );
}
40006c20: 81 c7 e0 08 ret
<== NOT EXECUTED
40006c24: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
40006c28 <_Freechain_Put>:
void _Freechain_Put( Freechain_Control *freechain, void *node )
{
if ( node != NULL ) {
40006c28: 80 a2 60 00 cmp %o1, 0
40006c2c: 02 80 00 07 be 40006c48 <_Freechain_Put+0x20>
<== NEVER TAKEN
40006c30: 01 00 00 00 nop
the_node->previous = after_node;
40006c34: d0 22 60 04 st %o0, [ %o1 + 4 ]
before_node = after_node->next;
40006c38: c2 02 00 00 ld [ %o0 ], %g1
after_node->next = the_node;
40006c3c: d2 22 00 00 st %o1, [ %o0 ]
the_node->next = before_node;
40006c40: c2 22 40 00 st %g1, [ %o1 ]
before_node->previous = the_node;
40006c44: d2 20 60 04 st %o1, [ %g1 + 4 ]
_Chain_Initialize_node( node );
_Chain_Prepend_unprotected( &freechain->Free, node );
}
}
40006c48: 81 c3 e0 08 retl
40006c4c: 01 00 00 00 nop
40006c50 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
40006c50: 9d e3 bf a0 save %sp, -96, %sp
40006c54: 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 ) {
40006c58: 80 a6 7f fc cmp %i1, -4
40006c5c: 1a 80 00 8a bcc 40006e84 <_Heap_Allocate_aligned_with_boundary+0x234>
<== NEVER TAKEN
40006c60: da 06 20 10 ld [ %i0 + 0x10 ], %o5
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
40006c64: 80 a6 e0 00 cmp %i3, 0
40006c68: 12 80 00 81 bne 40006e6c <_Heap_Allocate_aligned_with_boundary+0x21c>
<== NEVER TAKEN
40006c6c: 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;
40006c70: 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 ) {
40006c74: 80 a6 00 09 cmp %i0, %o1
40006c78: 02 80 00 78 be 40006e58 <_Heap_Allocate_aligned_with_boundary+0x208>
<== NEVER TAKEN
40006c7c: ba 10 20 00 clr %i5
uintptr_t alloc_begin = alloc_end - alloc_size;
40006c80: 9e 10 20 04 mov 4, %o7
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
40006c84: 96 03 60 07 add %o5, 7, %o3
uintptr_t alloc_begin = alloc_end - alloc_size;
40006c88: 9e 23 c0 19 sub %o7, %i1, %o7
uintptr_t const free_size = alloc_block_begin - block_begin;
40006c8c: 10 80 00 09 b 40006cb0 <_Heap_Allocate_aligned_with_boundary+0x60>
40006c90: 94 10 3f f8 mov -8, %o2
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
40006c94: 80 a7 20 00 cmp %i4, 0
40006c98: 32 80 00 5b bne,a 40006e04 <_Heap_Allocate_aligned_with_boundary+0x1b4>
<== ALWAYS TAKEN
40006c9c: 96 10 00 19 mov %i1, %o3
break;
}
block = block->next;
40006ca0: d2 02 60 08 ld [ %o1 + 8 ], %o1
while ( block != free_list_tail ) {
40006ca4: 80 a6 00 09 cmp %i0, %o1
40006ca8: 22 80 00 6d be,a 40006e5c <_Heap_Allocate_aligned_with_boundary+0x20c>
<== NEVER TAKEN
40006cac: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
<== NOT EXECUTED
if ( block->size_and_flag > block_size_floor ) {
40006cb0: c2 02 60 04 ld [ %o1 + 4 ], %g1
40006cb4: 80 a0 40 04 cmp %g1, %g4
40006cb8: 08 bf ff fa bleu 40006ca0 <_Heap_Allocate_aligned_with_boundary+0x50>
40006cbc: ba 07 60 01 inc %i5
if ( alignment == 0 ) {
40006cc0: 80 a6 a0 00 cmp %i2, 0
40006cc4: 02 bf ff f4 be 40006c94 <_Heap_Allocate_aligned_with_boundary+0x44>
<== ALWAYS TAKEN
40006cc8: b8 02 60 08 add %o1, 8, %i4
40006ccc: d8 06 20 14 ld [ %i0 + 0x14 ], %o4
<== NOT EXECUTED
- 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;
40006cd0: 82 08 7f fe and %g1, -2, %g1
<== NOT EXECUTED
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
40006cd4: 86 22 c0 0c sub %o3, %o4, %g3
<== NOT EXECUTED
uintptr_t const block_end = block_begin + block_size;
40006cd8: 82 00 40 09 add %g1, %o1, %g1
<== NOT EXECUTED
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
40006cdc: 86 00 c0 01 add %g3, %g1, %g3
<== NOT EXECUTED
uintptr_t alloc_begin = alloc_end - alloc_size;
40006ce0: 82 03 c0 01 add %o7, %g1, %g1
<== NOT EXECUTED
return value - (value % alignment);
40006ce4: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40006ce8: 01 00 00 00 nop
<== NOT EXECUTED
40006cec: 01 00 00 00 nop
<== NOT EXECUTED
40006cf0: 01 00 00 00 nop
<== NOT EXECUTED
40006cf4: 84 70 40 1a udiv %g1, %i2, %g2
<== NOT EXECUTED
40006cf8: 84 58 80 1a smul %g2, %i2, %g2
<== NOT EXECUTED
if ( alloc_begin > alloc_begin_ceiling ) {
40006cfc: 80 a0 c0 02 cmp %g3, %g2
<== NOT EXECUTED
40006d00: 1a 80 00 08 bcc 40006d20 <_Heap_Allocate_aligned_with_boundary+0xd0>
<== NOT EXECUTED
40006d04: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
40006d08: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40006d0c: 01 00 00 00 nop
<== NOT EXECUTED
40006d10: 01 00 00 00 nop
<== NOT EXECUTED
40006d14: 01 00 00 00 nop
<== NOT EXECUTED
40006d18: 84 70 c0 1a udiv %g3, %i2, %g2
<== NOT EXECUTED
40006d1c: 84 58 80 1a smul %g2, %i2, %g2
<== NOT EXECUTED
if ( boundary != 0 ) {
40006d20: 02 80 00 26 be 40006db8 <_Heap_Allocate_aligned_with_boundary+0x168>
<== NOT EXECUTED
40006d24: 80 a7 00 02 cmp %i4, %g2
<== NOT EXECUTED
alloc_end = alloc_begin + alloc_size;
40006d28: 86 06 40 02 add %i1, %g2, %g3
<== NOT EXECUTED
40006d2c: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40006d30: 01 00 00 00 nop
<== NOT EXECUTED
40006d34: 01 00 00 00 nop
<== NOT EXECUTED
40006d38: 01 00 00 00 nop
<== NOT EXECUTED
40006d3c: 82 70 c0 1b udiv %g3, %i3, %g1
<== NOT EXECUTED
40006d40: 82 58 40 1b smul %g1, %i3, %g1
<== NOT EXECUTED
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
40006d44: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
40006d48: 1a 80 00 1b bcc 40006db4 <_Heap_Allocate_aligned_with_boundary+0x164>
<== NOT EXECUTED
40006d4c: 90 06 40 1c add %i1, %i4, %o0
<== NOT EXECUTED
40006d50: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
40006d54: 2a 80 00 06 bcs,a 40006d6c <_Heap_Allocate_aligned_with_boundary+0x11c>
<== NOT EXECUTED
40006d58: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
if ( alloc_begin >= alloc_begin_floor ) {
40006d5c: 10 80 00 17 b 40006db8 <_Heap_Allocate_aligned_with_boundary+0x168>
<== NOT EXECUTED
40006d60: 80 a7 00 02 cmp %i4, %g2
<== NOT EXECUTED
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
40006d64: 1a 80 00 14 bcc 40006db4 <_Heap_Allocate_aligned_with_boundary+0x164>
<== NOT EXECUTED
40006d68: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
if ( boundary_line < boundary_floor ) {
40006d6c: 18 bf ff cd bgu 40006ca0 <_Heap_Allocate_aligned_with_boundary+0x50>
<== NOT EXECUTED
40006d70: 82 20 40 19 sub %g1, %i1, %g1
<== NOT EXECUTED
40006d74: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40006d78: 01 00 00 00 nop
<== NOT EXECUTED
40006d7c: 01 00 00 00 nop
<== NOT EXECUTED
40006d80: 01 00 00 00 nop
<== NOT EXECUTED
40006d84: 84 70 40 1a udiv %g1, %i2, %g2
<== NOT EXECUTED
40006d88: 84 58 80 1a smul %g2, %i2, %g2
<== NOT EXECUTED
alloc_end = alloc_begin + alloc_size;
40006d8c: 86 06 40 02 add %i1, %g2, %g3
<== NOT EXECUTED
40006d90: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40006d94: 01 00 00 00 nop
<== NOT EXECUTED
40006d98: 01 00 00 00 nop
<== NOT EXECUTED
40006d9c: 01 00 00 00 nop
<== NOT EXECUTED
40006da0: 82 70 c0 1b udiv %g3, %i3, %g1
<== NOT EXECUTED
40006da4: 82 58 40 1b smul %g1, %i3, %g1
<== NOT EXECUTED
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
40006da8: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
40006dac: 0a bf ff ee bcs 40006d64 <_Heap_Allocate_aligned_with_boundary+0x114>
<== NOT EXECUTED
40006db0: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
if ( alloc_begin >= alloc_begin_floor ) {
40006db4: 80 a7 00 02 cmp %i4, %g2
<== NOT EXECUTED
40006db8: 18 bf ff ba bgu 40006ca0 <_Heap_Allocate_aligned_with_boundary+0x50>
<== NOT EXECUTED
40006dbc: 82 22 80 09 sub %o2, %o1, %g1
<== NOT EXECUTED
40006dc0: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40006dc4: 01 00 00 00 nop
<== NOT EXECUTED
40006dc8: 01 00 00 00 nop
<== NOT EXECUTED
40006dcc: 01 00 00 00 nop
<== NOT EXECUTED
40006dd0: 86 70 80 0d udiv %g2, %o5, %g3
<== NOT EXECUTED
40006dd4: 86 58 c0 0d smul %g3, %o5, %g3
<== NOT EXECUTED
uintptr_t const free_size = alloc_block_begin - block_begin;
40006dd8: 82 00 40 03 add %g1, %g3, %g1
<== NOT EXECUTED
if ( free_size >= min_block_size || free_size == 0 ) {
40006ddc: 80 a0 40 0c cmp %g1, %o4
<== NOT EXECUTED
40006de0: 1a 80 00 04 bcc 40006df0 <_Heap_Allocate_aligned_with_boundary+0x1a0>
<== NOT EXECUTED
40006de4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40006de8: 32 bf ff af bne,a 40006ca4 <_Heap_Allocate_aligned_with_boundary+0x54>
<== NOT EXECUTED
40006dec: d2 02 60 08 ld [ %o1 + 8 ], %o1
<== NOT EXECUTED
40006df0: b8 10 00 02 mov %g2, %i4
<== NOT EXECUTED
if ( alloc_begin != 0 ) {
40006df4: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
40006df8: 22 bf ff ab be,a 40006ca4 <_Heap_Allocate_aligned_with_boundary+0x54>
<== NOT EXECUTED
40006dfc: 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 );
40006e00: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
40006e04: 94 10 00 1c mov %i4, %o2
40006e08: 40 00 00 d3 call 40007154 <_Heap_Block_allocate>
40006e0c: 90 10 00 18 mov %i0, %o0
alignment,
boundary
);
/* Statistics */
++stats->allocs;
40006e10: f6 06 20 58 ld [ %i0 + 0x58 ], %i3
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40006e14: c8 02 20 04 ld [ %o0 + 4 ], %g4
stats->searches += search_count;
stats->lifetime_allocated += _Heap_Block_size( block );
40006e18: c4 1e 20 28 ldd [ %i0 + 0x28 ], %g2
stats->searches += search_count;
40006e1c: c2 06 20 54 ld [ %i0 + 0x54 ], %g1
++stats->allocs;
40006e20: b6 06 e0 01 inc %i3
stats->searches += search_count;
40006e24: 82 00 40 1d add %g1, %i5, %g1
40006e28: 88 09 3f fe and %g4, -2, %g4
++stats->allocs;
40006e2c: f6 26 20 58 st %i3, [ %i0 + 0x58 ]
stats->lifetime_allocated += _Heap_Block_size( block );
40006e30: b6 80 c0 04 addcc %g3, %g4, %i3
stats->searches += search_count;
40006e34: c2 26 20 54 st %g1, [ %i0 + 0x54 ]
stats->lifetime_allocated += _Heap_Block_size( block );
40006e38: b4 40 a0 00 addx %g2, 0, %i2
40006e3c: f4 3e 20 28 std %i2, [ %i0 + 0x28 ]
/* Statistics */
++stats->failed_allocs;
}
/* Statistics */
if ( stats->max_search < search_count ) {
40006e40: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
40006e44: 80 a0 40 1d cmp %g1, %i5
40006e48: 2a 80 00 02 bcs,a 40006e50 <_Heap_Allocate_aligned_with_boundary+0x200>
40006e4c: fa 26 20 50 st %i5, [ %i0 + 0x50 ]
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
40006e50: 81 c7 e0 08 ret
40006e54: 91 e8 00 1c restore %g0, %i4, %o0
++stats->failed_allocs;
40006e58: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
<== NOT EXECUTED
40006e5c: 82 00 60 01 inc %g1
<== NOT EXECUTED
40006e60: b8 10 20 00 clr %i4
<== NOT EXECUTED
40006e64: 10 bf ff f7 b 40006e40 <_Heap_Allocate_aligned_with_boundary+0x1f0>
<== NOT EXECUTED
40006e68: c2 26 20 5c st %g1, [ %i0 + 0x5c ]
<== NOT EXECUTED
if ( boundary < alloc_size ) {
40006e6c: 18 80 00 06 bgu 40006e84 <_Heap_Allocate_aligned_with_boundary+0x234>
<== NOT EXECUTED
40006e70: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
if ( alignment == 0 ) {
40006e74: 22 bf ff 7f be,a 40006c70 <_Heap_Allocate_aligned_with_boundary+0x20>
<== NOT EXECUTED
40006e78: b4 10 00 0d mov %o5, %i2
<== NOT EXECUTED
return _Heap_Free_list_head(heap)->next;
40006e7c: 10 bf ff 7e b 40006c74 <_Heap_Allocate_aligned_with_boundary+0x24>
<== NOT EXECUTED
40006e80: d2 06 20 08 ld [ %i0 + 8 ], %o1
<== NOT EXECUTED
return NULL;
40006e84: b8 10 20 00 clr %i4
<== NOT EXECUTED
}
40006e88: 81 c7 e0 08 ret
<== NOT EXECUTED
40006e8c: 91 e8 00 1c restore %g0, %i4, %o0
<== NOT EXECUTED
40007154 <_Heap_Block_allocate>:
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
40007154: 9d e3 bf a0 save %sp, -96, %sp
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40007158: c2 06 60 04 ld [ %i1 + 4 ], %g1
4000715c: 82 08 7f fe and %g1, -2, %g1
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40007160: 84 06 40 01 add %i1, %g1, %g2
40007164: c4 00 a0 04 ld [ %g2 + 4 ], %g2
40007168: ba 10 00 18 mov %i0, %i5
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
4000716c: 80 88 a0 01 btst 1, %g2
40007170: b0 06 bf f8 add %i2, -8, %i0
return &heap->free_list;
40007174: 94 10 00 1d mov %i5, %o2
40007178: 12 80 00 0f bne 400071b4 <_Heap_Block_allocate+0x60>
<== NEVER TAKEN
4000717c: 96 26 00 19 sub %i0, %i1, %o3
40007180: c4 06 60 08 ld [ %i1 + 8 ], %g2
free_list_anchor = block->prev;
40007184: d4 06 60 0c ld [ %i1 + 0xc ], %o2
prev->next = next;
40007188: c4 22 a0 08 st %g2, [ %o2 + 8 ]
next->prev = prev;
4000718c: d4 20 a0 0c st %o2, [ %g2 + 0xc ]
_Heap_Free_list_remove( block );
/* Statistics */
--stats->free_blocks;
40007190: f8 07 60 44 ld [ %i5 + 0x44 ], %i4
++stats->used_blocks;
40007194: c8 07 60 4c ld [ %i5 + 0x4c ], %g4
stats->free_size -= _Heap_Block_size( block );
40007198: c4 07 60 3c ld [ %i5 + 0x3c ], %g2
--stats->free_blocks;
4000719c: b8 07 3f ff add %i4, -1, %i4
++stats->used_blocks;
400071a0: 88 01 20 01 inc %g4
stats->free_size -= _Heap_Block_size( block );
400071a4: 82 20 80 01 sub %g2, %g1, %g1
--stats->free_blocks;
400071a8: f8 27 60 44 st %i4, [ %i5 + 0x44 ]
++stats->used_blocks;
400071ac: c8 27 60 4c st %g4, [ %i5 + 0x4c ]
stats->free_size -= _Heap_Block_size( block );
400071b0: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
} else {
free_list_anchor = _Heap_Free_list_head( heap );
}
if ( alloc_area_offset < heap->page_size ) {
400071b4: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
400071b8: 80 a0 80 0b cmp %g2, %o3
400071bc: 28 80 00 0e bleu,a 400071f4 <_Heap_Block_allocate+0xa0>
<== NEVER TAKEN
400071c0: c6 07 60 3c ld [ %i5 + 0x3c ], %g3
<== NOT EXECUTED
_Heap_Block_split( heap, block, free_list_anchor, alloc_size );
400071c4: 96 02 c0 1b add %o3, %i3, %o3
400071c8: 92 10 00 19 mov %i1, %o1
400071cc: 90 10 00 1d mov %i5, %o0
400071d0: 7f ff ff 30 call 40006e90 <_Heap_Block_split>
400071d4: b0 10 00 19 mov %i1, %i0
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
400071d8: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
400071dc: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
400071e0: 80 a0 80 01 cmp %g2, %g1
400071e4: 38 80 00 02 bgu,a 400071ec <_Heap_Block_allocate+0x98>
400071e8: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
400071ec: 81 c7 e0 08 ret
400071f0: 81 e8 00 00 restore
return value - (value % alignment);
400071f4: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
400071f8: 01 00 00 00 nop
<== NOT EXECUTED
400071fc: 01 00 00 00 nop
<== NOT EXECUTED
40007200: 01 00 00 00 nop
<== NOT EXECUTED
40007204: 88 76 80 02 udiv %i2, %g2, %g4
<== NOT EXECUTED
40007208: 84 59 00 02 smul %g4, %g2, %g2
<== NOT EXECUTED
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000720c: c2 06 60 04 ld [ %i1 + 4 ], %g1
<== NOT EXECUTED
return value - (value % alignment);
40007210: b4 26 80 02 sub %i2, %g2, %i2
<== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
40007214: b0 26 00 1a sub %i0, %i2, %i0
<== NOT EXECUTED
block_size = block_end - block_begin;
40007218: 84 26 00 19 sub %i0, %i1, %g2
<== NOT EXECUTED
stats->free_size += block_size;
4000721c: 86 00 c0 02 add %g3, %g2, %g3
<== NOT EXECUTED
40007220: c6 27 60 3c st %g3, [ %i5 + 0x3c ]
<== NOT EXECUTED
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40007224: 82 08 7f fe and %g1, -2, %g1
<== NOT EXECUTED
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40007228: c6 06 60 04 ld [ %i1 + 4 ], %g3
<== NOT EXECUTED
uintptr_t block_end = block_begin + block_size;
4000722c: 82 06 40 01 add %i1, %g1, %g1
<== NOT EXECUTED
if ( _Heap_Is_prev_used( block ) ) {
40007230: 80 88 e0 01 btst 1, %g3
<== NOT EXECUTED
40007234: 12 80 00 11 bne 40007278 <_Heap_Block_allocate+0x124>
<== NOT EXECUTED
40007238: 82 20 40 18 sub %g1, %i0, %g1
<== NOT EXECUTED
return (Heap_Block *) ((uintptr_t) block - block->prev_size);
4000723c: c6 06 40 00 ld [ %i1 ], %g3
<== NOT EXECUTED
40007240: b2 26 40 03 sub %i1, %g3, %i1
<== NOT EXECUTED
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40007244: c6 06 60 04 ld [ %i1 + 4 ], %g3
<== NOT EXECUTED
40007248: 86 08 ff fe and %g3, -2, %g3
<== NOT EXECUTED
block_size += prev_block_size;
4000724c: 84 00 80 03 add %g2, %g3, %g2
<== NOT EXECUTED
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
40007250: 86 10 a0 01 or %g2, 1, %g3
<== NOT EXECUTED
40007254: c6 26 60 04 st %g3, [ %i1 + 4 ]
<== NOT EXECUTED
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
40007258: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
new_block->prev_size = block_size;
4000725c: c4 26 00 00 st %g2, [ %i0 ]
<== NOT EXECUTED
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
40007260: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
new_block->size_and_flag = new_block_size;
40007264: c2 26 20 04 st %g1, [ %i0 + 4 ]
<== NOT EXECUTED
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
40007268: 7f ff ff 0a call 40006e90 <_Heap_Block_split>
<== NOT EXECUTED
4000726c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
if ( stats->min_free_size > stats->free_size ) {
40007270: 10 bf ff db b 400071dc <_Heap_Block_allocate+0x88>
<== NOT EXECUTED
40007274: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
<== NOT EXECUTED
Heap_Block *next = block_before->next;
40007278: c8 02 a0 08 ld [ %o2 + 8 ], %g4
<== NOT EXECUTED
new_block->next = next;
4000727c: c8 26 60 08 st %g4, [ %i1 + 8 ]
<== NOT EXECUTED
new_block->prev = block_before;
40007280: d4 26 60 0c st %o2, [ %i1 + 0xc ]
<== NOT EXECUTED
block_before->next = new_block;
40007284: f2 22 a0 08 st %i1, [ %o2 + 8 ]
<== NOT EXECUTED
++stats->free_blocks;
40007288: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
4000728c: c6 07 60 44 ld [ %i5 + 0x44 ], %g3
<== NOT EXECUTED
next->prev = new_block;
40007290: f2 21 20 0c st %i1, [ %g4 + 0xc ]
<== NOT EXECUTED
40007294: 86 00 e0 01 inc %g3
<== NOT EXECUTED
40007298: 10 bf ff ee b 40007250 <_Heap_Block_allocate+0xfc>
<== NOT EXECUTED
4000729c: c6 27 60 44 st %g3, [ %i5 + 0x44 ]
<== NOT EXECUTED
4000dc38 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
4000dc38: 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 ) {
4000dc3c: 80 a6 60 00 cmp %i1, 0
4000dc40: 02 80 00 41 be 4000dd44 <_Heap_Free+0x10c>
4000dc44: 84 10 20 01 mov 1, %g2
return value - (value % alignment);
4000dc48: c8 06 20 10 ld [ %i0 + 0x10 ], %g4
return (uintptr_t) block >= (uintptr_t) heap->first_block
4000dc4c: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
return value - (value % alignment);
4000dc50: 81 80 20 00 wr %g0, %y
4000dc54: 01 00 00 00 nop
4000dc58: 01 00 00 00 nop
4000dc5c: 01 00 00 00 nop
4000dc60: 82 76 40 04 udiv %i1, %g4, %g1
4000dc64: 82 58 40 04 smul %g1, %g4, %g1
- HEAP_BLOCK_HEADER_SIZE);
4000dc68: 82 00 7f f8 add %g1, -8, %g1
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000dc6c: 80 a0 40 03 cmp %g1, %g3
4000dc70: 0a 80 00 35 bcs 4000dd44 <_Heap_Free+0x10c>
<== NEVER TAKEN
4000dc74: 84 10 20 00 clr %g2
4000dc78: f6 06 20 24 ld [ %i0 + 0x24 ], %i3
4000dc7c: 80 a0 40 1b cmp %g1, %i3
4000dc80: 38 80 00 32 bgu,a 4000dd48 <_Heap_Free+0x110>
<== NEVER TAKEN
4000dc84: b0 08 a0 ff and %g2, 0xff, %i0
<== NOT EXECUTED
4000dc88: fa 00 60 04 ld [ %g1 + 4 ], %i5
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000dc8c: b8 0f 7f fe and %i5, -2, %i4
return (Heap_Block *) ((uintptr_t) block + offset);
4000dc90: 88 00 40 1c add %g1, %i4, %g4
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000dc94: 80 a0 c0 04 cmp %g3, %g4
4000dc98: 38 80 00 2c bgu,a 4000dd48 <_Heap_Free+0x110>
<== NEVER TAKEN
4000dc9c: b0 08 a0 ff and %g2, 0xff, %i0
<== NOT EXECUTED
4000dca0: 80 a6 c0 04 cmp %i3, %g4
4000dca4: 2a 80 00 29 bcs,a 4000dd48 <_Heap_Free+0x110>
<== NEVER TAKEN
4000dca8: b0 08 a0 ff and %g2, 0xff, %i0
<== NOT EXECUTED
4000dcac: f4 01 20 04 ld [ %g4 + 4 ], %i2
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
4000dcb0: 80 8e a0 01 btst 1, %i2
4000dcb4: 02 80 00 24 be 4000dd44 <_Heap_Free+0x10c>
<== NEVER TAKEN
4000dcb8: 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 ));
4000dcbc: 80 a6 c0 04 cmp %i3, %g4
4000dcc0: 02 80 00 24 be 4000dd50 <_Heap_Free+0x118>
<== NEVER TAKEN
4000dcc4: ba 0f 60 01 and %i5, 1, %i5
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000dcc8: 84 01 00 1a add %g4, %i2, %g2
4000dccc: c4 00 a0 04 ld [ %g2 + 4 ], %g2
4000dcd0: 80 88 a0 01 btst 1, %g2
4000dcd4: 12 80 00 20 bne 4000dd54 <_Heap_Free+0x11c>
4000dcd8: 80 a7 60 00 cmp %i5, 0
if ( !_Heap_Is_prev_used( block ) ) {
4000dcdc: 02 80 00 20 be 4000dd5c <_Heap_Free+0x124>
4000dce0: 9e 10 20 01 mov 1, %o7
4000dce4: c6 01 20 08 ld [ %g4 + 8 ], %g3
4000dce8: c4 01 20 0c ld [ %g4 + 0xc ], %g2
new_block->prev = prev;
4000dcec: 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;
4000dcf0: b4 07 00 1a add %i4, %i2, %i2
new_block->next = next;
4000dcf4: c6 20 60 08 st %g3, [ %g1 + 8 ]
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000dcf8: 88 16 a0 01 or %i2, 1, %g4
next->prev = new_block;
4000dcfc: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
prev->next = new_block;
4000dd00: c2 20 a0 08 st %g1, [ %g2 + 8 ]
4000dd04: c8 20 60 04 st %g4, [ %g1 + 4 ]
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
4000dd08: 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 );
4000dd0c: 84 10 20 01 mov 1, %g2
stats->lifetime_freed += block_size;
4000dd10: f4 1e 20 30 ldd [ %i0 + 0x30 ], %i2
--stats->used_blocks;
4000dd14: c8 06 20 4c ld [ %i0 + 0x4c ], %g4
++stats->frees;
4000dd18: c6 06 20 60 ld [ %i0 + 0x60 ], %g3
stats->free_size += block_size;
4000dd1c: c2 06 20 3c ld [ %i0 + 0x3c ], %g1
stats->lifetime_freed += block_size;
4000dd20: 9a 86 c0 1c addcc %i3, %i4, %o5
--stats->used_blocks;
4000dd24: 88 01 3f ff add %g4, -1, %g4
++stats->frees;
4000dd28: 86 00 e0 01 inc %g3
stats->free_size += block_size;
4000dd2c: 82 00 40 1c add %g1, %i4, %g1
stats->lifetime_freed += block_size;
4000dd30: 98 46 a0 00 addx %i2, 0, %o4
--stats->used_blocks;
4000dd34: c8 26 20 4c st %g4, [ %i0 + 0x4c ]
++stats->frees;
4000dd38: c6 26 20 60 st %g3, [ %i0 + 0x60 ]
stats->free_size += block_size;
4000dd3c: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
stats->lifetime_freed += block_size;
4000dd40: d8 3e 20 30 std %o4, [ %i0 + 0x30 ]
4000dd44: b0 08 a0 ff and %g2, 0xff, %i0
}
4000dd48: 81 c7 e0 08 ret
4000dd4c: 81 e8 00 00 restore
if ( !_Heap_Is_prev_used( block ) ) {
4000dd50: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4000dd54: 12 80 00 1c bne 4000ddc4 <_Heap_Free+0x18c>
4000dd58: 9e 10 20 00 clr %o7
uintptr_t const prev_size = block->prev_size;
4000dd5c: f2 00 40 00 ld [ %g1 ], %i1
4000dd60: ba 20 40 19 sub %g1, %i1, %i5
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000dd64: 80 a7 40 03 cmp %i5, %g3
4000dd68: 0a bf ff f7 bcs 4000dd44 <_Heap_Free+0x10c>
<== NEVER TAKEN
4000dd6c: 84 10 20 00 clr %g2
4000dd70: 80 a7 40 1b cmp %i5, %i3
4000dd74: 38 bf ff f5 bgu,a 4000dd48 <_Heap_Free+0x110>
<== NEVER TAKEN
4000dd78: b0 08 a0 ff and %g2, 0xff, %i0
<== NOT EXECUTED
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000dd7c: c6 07 60 04 ld [ %i5 + 4 ], %g3
if ( !_Heap_Is_prev_used ( prev_block) ) {
4000dd80: 80 88 e0 01 btst 1, %g3
4000dd84: 02 bf ff f0 be 4000dd44 <_Heap_Free+0x10c>
<== NEVER TAKEN
4000dd88: 80 a3 e0 00 cmp %o7, 0
if ( next_is_free ) { /* coalesce both */
4000dd8c: 02 80 00 22 be 4000de14 <_Heap_Free+0x1dc>
4000dd90: b2 06 40 1c add %i1, %i4, %i1
4000dd94: c4 01 20 08 ld [ %g4 + 8 ], %g2
4000dd98: c6 01 20 0c ld [ %g4 + 0xc ], %g3
prev->next = next;
4000dd9c: c4 20 e0 08 st %g2, [ %g3 + 8 ]
uintptr_t const size = block_size + prev_size + next_block_size;
4000dda0: b4 06 80 19 add %i2, %i1, %i2
stats->free_blocks -= 1;
4000dda4: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
next->prev = prev;
4000dda8: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
4000ddac: 82 00 7f ff add %g1, -1, %g1
4000ddb0: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000ddb4: 82 16 a0 01 or %i2, 1, %g1
4000ddb8: c2 27 60 04 st %g1, [ %i5 + 4 ]
4000ddbc: 10 bf ff d4 b 4000dd0c <_Heap_Free+0xd4>
4000ddc0: f4 27 40 1a st %i2, [ %i5 + %i2 ]
Heap_Block *next = block_before->next;
4000ddc4: c6 06 20 08 ld [ %i0 + 8 ], %g3
new_block->next = next;
4000ddc8: c6 20 60 08 st %g3, [ %g1 + 8 ]
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
4000ddcc: 84 17 20 01 or %i4, 1, %g2
new_block->prev = block_before;
4000ddd0: f0 20 60 0c st %i0, [ %g1 + 0xc ]
block_before->next = new_block;
4000ddd4: c2 26 20 08 st %g1, [ %i0 + 8 ]
next->prev = new_block;
4000ddd8: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
4000dddc: c4 20 60 04 st %g2, [ %g1 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000dde0: c4 01 20 04 ld [ %g4 + 4 ], %g2
4000dde4: 84 08 bf fe and %g2, -2, %g2
4000dde8: c4 21 20 04 st %g2, [ %g4 + 4 ]
++stats->free_blocks;
4000ddec: c4 06 20 44 ld [ %i0 + 0x44 ], %g2
next_block->prev_size = block_size;
4000ddf0: f8 20 40 1c st %i4, [ %g1 + %i4 ]
++stats->free_blocks;
4000ddf4: 82 00 a0 01 add %g2, 1, %g1
4000ddf8: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
if ( stats->max_free_blocks < stats->free_blocks ) {
4000ddfc: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
4000de00: 80 a0 40 02 cmp %g1, %g2
4000de04: 38 bf ff c2 bgu,a 4000dd0c <_Heap_Free+0xd4>
4000de08: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
return( true );
4000de0c: 10 bf ff c1 b 4000dd10 <_Heap_Free+0xd8>
4000de10: 84 10 20 01 mov 1, %g2
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000de14: 84 16 60 01 or %i1, 1, %g2
4000de18: c4 27 60 04 st %g2, [ %i5 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000de1c: c4 01 20 04 ld [ %g4 + 4 ], %g2
4000de20: 84 08 bf fe and %g2, -2, %g2
4000de24: c4 21 20 04 st %g2, [ %g4 + 4 ]
next_block->prev_size = size;
4000de28: 10 bf ff b9 b 4000dd0c <_Heap_Free+0xd4>
4000de2c: f2 20 40 1c st %i1, [ %g1 + %i4 ]
40044ac8 <_Heap_Get_free_information>:
)
{
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
40044ac8: c0 22 40 00 clr [ %o1 ]
<== NOT EXECUTED
info->largest = 0;
40044acc: c0 22 60 04 clr [ %o1 + 4 ]
<== NOT EXECUTED
info->total = 0;
40044ad0: c0 22 60 08 clr [ %o1 + 8 ]
<== NOT EXECUTED
return _Heap_Free_list_head(heap)->next;
40044ad4: c4 02 20 08 ld [ %o0 + 8 ], %g2
<== NOT EXECUTED
for(the_block = _Heap_Free_list_first(the_heap);
40044ad8: 80 a2 00 02 cmp %o0, %g2
<== NOT EXECUTED
40044adc: 02 80 00 12 be 40044b24 <_Heap_Get_free_information+0x5c>
<== NOT EXECUTED
40044ae0: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
40044ae4: 9a 10 20 00 clr %o5
<== NOT EXECUTED
40044ae8: 10 80 00 03 b 40044af4 <_Heap_Get_free_information+0x2c>
<== NOT EXECUTED
40044aec: 86 10 20 00 clr %g3
<== NOT EXECUTED
40044af0: da 02 60 04 ld [ %o1 + 4 ], %o5
<== NOT EXECUTED
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40044af4: c2 00 a0 04 ld [ %g2 + 4 ], %g1
<== NOT EXECUTED
40044af8: 82 08 7f fe and %g1, -2, %g1
<== NOT EXECUTED
uint32_t const the_size = _Heap_Block_size(the_block);
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
40044afc: c8 22 40 00 st %g4, [ %o1 ]
<== NOT EXECUTED
info->total += the_size;
40044b00: 86 00 c0 01 add %g3, %g1, %g3
<== NOT EXECUTED
if ( info->largest < the_size )
40044b04: 80 a0 40 0d cmp %g1, %o5
<== NOT EXECUTED
40044b08: 08 80 00 03 bleu 40044b14 <_Heap_Get_free_information+0x4c>
<== NOT EXECUTED
40044b0c: c6 22 60 08 st %g3, [ %o1 + 8 ]
<== NOT EXECUTED
info->largest = the_size;
40044b10: c2 22 60 04 st %g1, [ %o1 + 4 ]
<== NOT EXECUTED
the_block = the_block->next)
40044b14: c4 00 a0 08 ld [ %g2 + 8 ], %g2
<== NOT EXECUTED
for(the_block = _Heap_Free_list_first(the_heap);
40044b18: 80 a2 00 02 cmp %o0, %g2
<== NOT EXECUTED
40044b1c: 12 bf ff f5 bne 40044af0 <_Heap_Get_free_information+0x28>
<== NOT EXECUTED
40044b20: 88 01 20 01 inc %g4
<== NOT EXECUTED
}
}
40044b24: 81 c3 e0 08 retl
<== NOT EXECUTED
40044b28: 01 00 00 00 nop
<== NOT EXECUTED
40058e94 <_Heap_Get_information>:
void _Heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
40058e94: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
memset( the_info, 0, sizeof(*the_info) );
40058e98: 92 10 20 00 clr %o1
<== NOT EXECUTED
40058e9c: 94 10 20 58 mov 0x58, %o2
<== NOT EXECUTED
40058ea0: 40 00 20 d6 call 400611f8 <memset>
<== NOT EXECUTED
40058ea4: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
_Heap_Protection_free_all_delayed_blocks( the_heap );
_Heap_Iterate( the_heap, _Heap_Get_information_visitor, the_info );
40058ea8: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
40058eac: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40058eb0: 13 10 01 63 sethi %hi(0x40058c00), %o1
<== NOT EXECUTED
40058eb4: 40 00 00 08 call 40058ed4 <_Heap_Iterate>
<== NOT EXECUTED
40058eb8: 92 12 62 58 or %o1, 0x258, %o1 ! 40058e58 <_Heap_Get_information_visitor>
<== NOT EXECUTED
the_info->Stats = the_heap->stats;
40058ebc: 94 10 20 40 mov 0x40, %o2
<== NOT EXECUTED
40058ec0: 92 06 20 28 add %i0, 0x28, %o1
<== NOT EXECUTED
40058ec4: 40 00 20 43 call 40060fd0 <memcpy>
<== NOT EXECUTED
40058ec8: 90 06 60 18 add %i1, 0x18, %o0
<== NOT EXECUTED
}
40058ecc: 81 c7 e0 08 ret
<== NOT EXECUTED
40058ed0: 81 e8 00 00 restore
<== NOT EXECUTED
40006fc8 <_Heap_Initialize>:
{
40006fc8: 9d e3 bf a0 save %sp, -96, %sp
40006fcc: a2 86 40 1a addcc %i1, %i2, %l1
40006fd0: 84 40 20 00 addx %g0, 0, %g2
if ( page_size == 0 ) {
40006fd4: 80 a6 e0 00 cmp %i3, 0
40006fd8: 22 80 00 33 be,a 400070a4 <_Heap_Initialize+0xdc>
<== NEVER TAKEN
40006fdc: b6 10 20 08 mov 8, %i3
<== NOT EXECUTED
if ( remainder != 0 ) {
40006fe0: 82 8e e0 07 andcc %i3, 7, %g1
40006fe4: 02 80 00 05 be 40006ff8 <_Heap_Initialize+0x30>
<== ALWAYS TAKEN
40006fe8: 80 a6 e0 07 cmp %i3, 7
return value - remainder + alignment;
40006fec: b6 06 e0 08 add %i3, 8, %i3
<== NOT EXECUTED
40006ff0: b6 26 c0 01 sub %i3, %g1, %i3
<== NOT EXECUTED
if ( page_size < CPU_ALIGNMENT ) {
40006ff4: 80 a6 e0 07 cmp %i3, 7
<== NOT EXECUTED
40006ff8: 08 80 00 29 bleu 4000709c <_Heap_Initialize+0xd4>
<== NEVER TAKEN
40006ffc: ba 10 20 00 clr %i5
uintptr_t remainder = value % alignment;
40007000: 82 10 20 10 mov 0x10, %g1
40007004: 81 80 20 00 wr %g0, %y
40007008: 01 00 00 00 nop
4000700c: 01 00 00 00 nop
40007010: 01 00 00 00 nop
40007014: 86 70 40 1b udiv %g1, %i3, %g3
40007018: 86 58 c0 1b smul %g3, %i3, %g3
if ( remainder != 0 ) {
4000701c: 82 a0 40 03 subcc %g1, %g3, %g1
40007020: 02 80 00 22 be 400070a8 <_Heap_Initialize+0xe0>
<== ALWAYS TAKEN
40007024: a0 10 20 10 mov 0x10, %l0
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
40007028: b8 06 60 08 add %i1, 8, %i4
<== NOT EXECUTED
return value - remainder + alignment;
4000702c: a0 06 e0 10 add %i3, 0x10, %l0
<== NOT EXECUTED
40007030: a0 24 00 01 sub %l0, %g1, %l0
<== NOT EXECUTED
uintptr_t remainder = value % alignment;
40007034: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40007038: 01 00 00 00 nop
<== NOT EXECUTED
4000703c: 01 00 00 00 nop
<== NOT EXECUTED
40007040: 01 00 00 00 nop
<== NOT EXECUTED
40007044: 82 77 00 1b udiv %i4, %i3, %g1
<== NOT EXECUTED
40007048: 82 58 40 1b smul %g1, %i3, %g1
<== NOT EXECUTED
if ( remainder != 0 ) {
4000704c: 82 a7 00 01 subcc %i4, %g1, %g1
<== NOT EXECUTED
40007050: 12 80 00 21 bne 400070d4 <_Heap_Initialize+0x10c>
<== NOT EXECUTED
40007054: b8 06 40 1b add %i1, %i3, %i4
<== NOT EXECUTED
uintptr_t const heap_area_begin = (uintptr_t) heap_area_begin_ptr;
40007058: b8 10 00 19 mov %i1, %i4
<== NOT EXECUTED
4000705c: 82 10 20 08 mov 8, %g1
|| heap_area_size <= overhead
40007060: 80 a0 40 1a cmp %g1, %i2
_Heap_Align_down( heap_area_size - overhead, page_size );
40007064: b4 26 80 01 sub %i2, %g1, %i2
|| heap_area_size <= overhead
40007068: 82 60 3f ff subx %g0, -1, %g1
return value - (value % alignment);
4000706c: 81 80 20 00 wr %g0, %y
40007070: 01 00 00 00 nop
40007074: 01 00 00 00 nop
40007078: 01 00 00 00 nop
4000707c: ba 76 80 1b udiv %i2, %i3, %i5
|| first_block_size < min_block_size
40007080: 80 90 80 01 orcc %g2, %g1, %g0
40007084: 12 80 00 05 bne 40007098 <_Heap_Initialize+0xd0>
<== NEVER TAKEN
40007088: ba 5f 40 1b smul %i5, %i3, %i5
4000708c: 80 a7 40 10 cmp %i5, %l0
40007090: 1a 80 00 15 bcc 400070e4 <_Heap_Initialize+0x11c>
<== ALWAYS TAKEN
40007094: 94 10 20 68 mov 0x68, %o2
return 0;
40007098: ba 10 20 00 clr %i5
<== NOT EXECUTED
}
4000709c: 81 c7 e0 08 ret
<== NOT EXECUTED
400070a0: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
} else {
return value;
400070a4: a0 10 20 10 mov 0x10, %l0
<== NOT EXECUTED
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
400070a8: b8 06 60 08 add %i1, 8, %i4
uintptr_t remainder = value % alignment;
400070ac: 81 80 20 00 wr %g0, %y
400070b0: 01 00 00 00 nop
400070b4: 01 00 00 00 nop
400070b8: 01 00 00 00 nop
400070bc: 82 77 00 1b udiv %i4, %i3, %g1
400070c0: 82 58 40 1b smul %g1, %i3, %g1
if ( remainder != 0 ) {
400070c4: 82 a7 00 01 subcc %i4, %g1, %g1
400070c8: 22 bf ff e5 be,a 4000705c <_Heap_Initialize+0x94>
400070cc: b8 10 00 19 mov %i1, %i4
400070d0: b8 06 40 1b add %i1, %i3, %i4
400070d4: b8 27 00 01 sub %i4, %g1, %i4
400070d8: 82 27 00 19 sub %i4, %i1, %g1
400070dc: 10 bf ff e1 b 40007060 <_Heap_Initialize+0x98>
400070e0: 82 00 60 08 add %g1, 8, %g1
memset(heap, 0, sizeof(*heap));
400070e4: 92 10 20 00 clr %o1
400070e8: 40 00 1e 15 call 4000e93c <memset>
400070ec: 90 10 00 18 mov %i0, %o0
first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED;
400070f0: 82 17 60 01 or %i5, 1, %g1
first_block->next = _Heap_Free_list_tail( heap );
400070f4: f0 27 20 08 st %i0, [ %i4 + 8 ]
return (Heap_Block *) ((uintptr_t) block + offset);
400070f8: 86 07 40 1c add %i5, %i4, %g3
first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED;
400070fc: c2 27 20 04 st %g1, [ %i4 + 4 ]
_Heap_Block_set_size(
40007100: 82 20 00 1d neg %i5, %g1
first_block->prev = _Heap_Free_list_head( heap );
40007104: f0 27 20 0c st %i0, [ %i4 + 0xc ]
stats->free_blocks = 1;
40007108: 84 10 20 01 mov 1, %g2
first_block->prev_size = heap_area_end;
4000710c: e2 27 00 00 st %l1, [ %i4 ]
heap->page_size = page_size;
40007110: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
heap->min_block_size = min_block_size;
40007114: e0 26 20 14 st %l0, [ %i0 + 0x14 ]
heap->area_begin = heap_area_begin;
40007118: f2 26 20 18 st %i1, [ %i0 + 0x18 ]
heap->area_end = heap_area_end;
4000711c: e2 26 20 1c st %l1, [ %i0 + 0x1c ]
heap->first_block = first_block;
40007120: f8 26 20 20 st %i4, [ %i0 + 0x20 ]
heap->last_block = last_block;
40007124: c6 26 20 24 st %g3, [ %i0 + 0x24 ]
_Heap_Free_list_head( heap )->next = first_block;
40007128: f8 26 20 08 st %i4, [ %i0 + 8 ]
_Heap_Free_list_tail( heap )->prev = first_block;
4000712c: f8 26 20 0c st %i4, [ %i0 + 0xc ]
last_block->prev_size = first_block_size;
40007130: fa 27 40 1c st %i5, [ %i5 + %i4 ]
block->size_and_flag = size | flag;
40007134: c2 20 e0 04 st %g1, [ %g3 + 4 ]
stats->size = first_block_size;
40007138: fa 26 20 38 st %i5, [ %i0 + 0x38 ]
stats->free_size = first_block_size;
4000713c: fa 26 20 3c st %i5, [ %i0 + 0x3c ]
stats->min_free_size = first_block_size;
40007140: fa 26 20 40 st %i5, [ %i0 + 0x40 ]
stats->free_blocks = 1;
40007144: c4 26 20 44 st %g2, [ %i0 + 0x44 ]
stats->max_free_blocks = 1;
40007148: c4 26 20 48 st %g2, [ %i0 + 0x48 ]
}
4000714c: 81 c7 e0 08 ret
40007150: 91 e8 00 1d restore %g0, %i5, %o0
40058ed4 <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
40058ed4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Heap_Block *current = heap->first_block;
40058ed8: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
<== NOT EXECUTED
Heap_Block *end = heap->last_block;
40058edc: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
<== NOT EXECUTED
bool stop = false;
while ( !stop && current != end ) {
40058ee0: 80 a0 40 1c cmp %g1, %i4
<== NOT EXECUTED
40058ee4: 32 80 00 07 bne,a 40058f00 <_Heap_Iterate+0x2c>
<== NOT EXECUTED
40058ee8: d2 00 60 04 ld [ %g1 + 4 ], %o1
<== NOT EXECUTED
40058eec: 30 80 00 10 b,a 40058f2c <_Heap_Iterate+0x58>
<== NOT EXECUTED
40058ef0: 80 a7 00 1d cmp %i4, %i5
<== NOT EXECUTED
40058ef4: 02 80 00 0e be 40058f2c <_Heap_Iterate+0x58>
<== NOT EXECUTED
40058ef8: 01 00 00 00 nop
<== NOT EXECUTED
40058efc: d2 00 60 04 ld [ %g1 + 4 ], %o1
<== NOT EXECUTED
40058f00: 92 0a 7f fe and %o1, -2, %o1
<== NOT EXECUTED
return (Heap_Block *) ((uintptr_t) block + offset);
40058f04: ba 00 40 09 add %g1, %o1, %i5
<== NOT EXECUTED
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40058f08: d4 07 60 04 ld [ %i5 + 4 ], %o2
<== NOT EXECUTED
uintptr_t size = _Heap_Block_size( current );
Heap_Block *next = _Heap_Block_at( current, size );
bool used = _Heap_Is_prev_used( next );
stop = (*visitor)( current, size, used, visitor_arg );
40058f0c: 90 10 00 01 mov %g1, %o0
<== NOT EXECUTED
40058f10: 96 10 00 1a mov %i2, %o3
<== NOT EXECUTED
40058f14: 9f c6 40 00 call %i1
<== NOT EXECUTED
40058f18: 94 0a a0 01 and %o2, 1, %o2
<== NOT EXECUTED
while ( !stop && current != end ) {
40058f1c: 90 1a 20 01 xor %o0, 1, %o0
<== NOT EXECUTED
40058f20: 80 8a 20 ff btst 0xff, %o0
<== NOT EXECUTED
40058f24: 12 bf ff f3 bne 40058ef0 <_Heap_Iterate+0x1c>
<== NOT EXECUTED
40058f28: 82 10 00 1d mov %i5, %g1
<== NOT EXECUTED
current = next;
}
}
40058f2c: 81 c7 e0 08 ret
<== NOT EXECUTED
40058f30: 81 e8 00 00 restore
<== NOT EXECUTED
4000fd6c <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
4000fd6c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
return value - (value % alignment);
4000fd70: 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;
4000fd74: c0 26 c0 00 clr [ %i3 ]
<== NOT EXECUTED
4000fd78: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
4000fd7c: 01 00 00 00 nop
<== NOT EXECUTED
4000fd80: 01 00 00 00 nop
<== NOT EXECUTED
4000fd84: 01 00 00 00 nop
<== NOT EXECUTED
4000fd88: 92 76 40 01 udiv %i1, %g1, %o1
<== NOT EXECUTED
*new_size = 0;
4000fd8c: c0 27 00 00 clr [ %i4 ]
<== NOT EXECUTED
4000fd90: 92 5a 40 01 smul %o1, %g1, %o1
<== NOT EXECUTED
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000fd94: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
<== NOT EXECUTED
{
4000fd98: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
4000fd9c: 92 02 7f f8 add %o1, -8, %o1
<== NOT EXECUTED
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000fda0: 80 a0 40 09 cmp %g1, %o1
<== NOT EXECUTED
4000fda4: 18 80 00 3a bgu 4000fe8c <_Heap_Resize_block+0x120>
<== NOT EXECUTED
4000fda8: b0 10 20 02 mov 2, %i0
<== NOT EXECUTED
4000fdac: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
<== NOT EXECUTED
4000fdb0: 80 a0 40 09 cmp %g1, %o1
<== NOT EXECUTED
4000fdb4: 0a 80 00 36 bcs 4000fe8c <_Heap_Resize_block+0x120>
<== NOT EXECUTED
4000fdb8: 90 10 20 04 mov 4, %o0
<== NOT EXECUTED
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000fdbc: c2 02 60 04 ld [ %o1 + 4 ], %g1
<== NOT EXECUTED
4000fdc0: 82 08 7f fe and %g1, -2, %g1
<== NOT EXECUTED
uintptr_t block_end = block_begin + block_size;
4000fdc4: 86 02 40 01 add %o1, %g1, %g3
<== NOT EXECUTED
4000fdc8: c4 00 e0 04 ld [ %g3 + 4 ], %g2
<== NOT EXECUTED
4000fdcc: 84 08 bf fe and %g2, -2, %g2
<== NOT EXECUTED
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000fdd0: b0 00 c0 02 add %g3, %g2, %i0
<== NOT EXECUTED
4000fdd4: a0 22 00 19 sub %o0, %i1, %l0
<== NOT EXECUTED
4000fdd8: f0 06 20 04 ld [ %i0 + 4 ], %i0
<== NOT EXECUTED
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
4000fddc: 88 00 c0 10 add %g3, %l0, %g4
<== NOT EXECUTED
if ( next_block_is_free ) {
4000fde0: 80 8e 20 01 btst 1, %i0
<== NOT EXECUTED
4000fde4: 12 80 00 27 bne 4000fe80 <_Heap_Resize_block+0x114>
<== NOT EXECUTED
4000fde8: c8 26 c0 00 st %g4, [ %i3 ]
<== NOT EXECUTED
alloc_size += next_block_size;
4000fdec: 88 01 00 02 add %g4, %g2, %g4
<== NOT EXECUTED
if ( new_alloc_size > alloc_size ) {
4000fdf0: 80 a6 80 04 cmp %i2, %g4
<== NOT EXECUTED
4000fdf4: 18 80 00 26 bgu 4000fe8c <_Heap_Resize_block+0x120>
<== NOT EXECUTED
4000fdf8: b0 10 20 01 mov 1, %i0
<== NOT EXECUTED
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000fdfc: c8 02 60 04 ld [ %o1 + 4 ], %g4
<== NOT EXECUTED
4000fe00: f6 00 e0 08 ld [ %g3 + 8 ], %i3
<== NOT EXECUTED
4000fe04: f0 00 e0 0c ld [ %g3 + 0xc ], %i0
<== NOT EXECUTED
block_size += next_block_size;
4000fe08: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000fe0c: 86 09 20 01 and %g4, 1, %g3
<== NOT EXECUTED
block->size_and_flag = size | flag;
4000fe10: 86 10 c0 01 or %g3, %g1, %g3
<== NOT EXECUTED
4000fe14: c6 22 60 04 st %g3, [ %o1 + 4 ]
<== NOT EXECUTED
return (Heap_Block *) ((uintptr_t) block + offset);
4000fe18: 82 02 40 01 add %o1, %g1, %g1
<== NOT EXECUTED
prev->next = next;
4000fe1c: f6 26 20 08 st %i3, [ %i0 + 8 ]
<== NOT EXECUTED
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
4000fe20: c8 00 60 04 ld [ %g1 + 4 ], %g4
<== NOT EXECUTED
next->prev = prev;
4000fe24: f0 26 e0 0c st %i0, [ %i3 + 0xc ]
<== NOT EXECUTED
4000fe28: 88 11 20 01 or %g4, 1, %g4
<== NOT EXECUTED
--stats->free_blocks;
4000fe2c: c6 07 60 44 ld [ %i5 + 0x44 ], %g3
<== NOT EXECUTED
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
4000fe30: c8 20 60 04 st %g4, [ %g1 + 4 ]
<== NOT EXECUTED
--stats->free_blocks;
4000fe34: 86 00 ff ff add %g3, -1, %g3
<== NOT EXECUTED
stats->free_size -= next_block_size;
4000fe38: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
<== NOT EXECUTED
4000fe3c: 84 20 40 02 sub %g1, %g2, %g2
<== NOT EXECUTED
--stats->free_blocks;
4000fe40: c6 27 60 44 st %g3, [ %i5 + 0x44 ]
<== NOT EXECUTED
stats->free_size -= next_block_size;
4000fe44: c4 27 60 3c st %g2, [ %i5 + 0x3c ]
<== NOT EXECUTED
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
4000fe48: 96 10 00 1a mov %i2, %o3
<== NOT EXECUTED
4000fe4c: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
4000fe50: 7f ff ff 74 call 4000fc20 <_Heap_Block_allocate>
<== NOT EXECUTED
4000fe54: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000fe58: c2 02 20 04 ld [ %o0 + 4 ], %g1
<== NOT EXECUTED
++stats->resizes;
4000fe5c: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
<== NOT EXECUTED
4000fe60: 82 08 7f fe and %g1, -2, %g1
<== NOT EXECUTED
*new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS;
4000fe64: 90 02 00 10 add %o0, %l0, %o0
<== NOT EXECUTED
4000fe68: 90 00 40 08 add %g1, %o0, %o0
<== NOT EXECUTED
4000fe6c: d0 27 00 00 st %o0, [ %i4 ]
<== NOT EXECUTED
++stats->resizes;
4000fe70: 82 00 a0 01 add %g2, 1, %g1
<== NOT EXECUTED
4000fe74: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
<== NOT EXECUTED
return HEAP_RESIZE_SUCCESSFUL;
4000fe78: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fe7c: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
if ( new_alloc_size > alloc_size ) {
4000fe80: 80 a6 80 04 cmp %i2, %g4
<== NOT EXECUTED
4000fe84: 08 bf ff f1 bleu 4000fe48 <_Heap_Resize_block+0xdc>
<== NOT EXECUTED
4000fe88: b0 10 20 01 mov 1, %i0
<== NOT EXECUTED
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
}
4000fe8c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000fe90: 81 e8 00 00 restore
<== NOT EXECUTED
40058fa0 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
40058fa0: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
40058fa4: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40058fa8: 02 80 00 0b be 40058fd4 <_Heap_Walk+0x34>
<== NOT EXECUTED
40058fac: 03 10 02 43 sethi %hi(0x40090c00), %g1
<== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
40058fb0: c2 00 62 34 ld [ %g1 + 0x234 ], %g1 ! 40090e34 <_System_state_Current>
<== NOT EXECUTED
_Heap_Walk_print : _Heap_Walk_print_nothing;
40058fb4: 21 10 01 63 sethi %hi(0x40058c00), %l0
<== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
40058fb8: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
40058fbc: 02 80 00 0b be 40058fe8 <_Heap_Walk+0x48>
<== NOT EXECUTED
40058fc0: a0 14 23 3c or %l0, 0x33c, %l0
<== NOT EXECUTED
return true;
40058fc4: b4 10 20 01 mov 1, %i2
<== NOT EXECUTED
40058fc8: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
40058fcc: 81 c7 e0 08 ret
<== NOT EXECUTED
40058fd0: 81 e8 00 00 restore
<== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
40058fd4: c2 00 62 34 ld [ %g1 + 0x234 ], %g1
<== NOT EXECUTED
_Heap_Walk_print : _Heap_Walk_print_nothing;
40058fd8: 21 10 01 63 sethi %hi(0x40058c00), %l0
<== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
40058fdc: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
40058fe0: 12 bf ff f9 bne 40058fc4 <_Heap_Walk+0x24>
<== NOT EXECUTED
40058fe4: a0 14 23 34 or %l0, 0x334, %l0
<== NOT EXECUTED
Heap_Block *const first_block = heap->first_block;
40058fe8: e4 06 20 20 ld [ %i0 + 0x20 ], %l2
<== NOT EXECUTED
Heap_Block *const last_block = heap->last_block;
40058fec: e2 06 20 24 ld [ %i0 + 0x24 ], %l1
<== NOT EXECUTED
(*printer)(
40058ff0: c6 06 20 0c ld [ %i0 + 0xc ], %g3
<== NOT EXECUTED
40058ff4: c4 06 20 08 ld [ %i0 + 8 ], %g2
<== NOT EXECUTED
40058ff8: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
<== NOT EXECUTED
40058ffc: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
<== NOT EXECUTED
40059000: 15 10 02 21 sethi %hi(0x40088400), %o2
<== NOT EXECUTED
40059004: c6 23 a0 6c st %g3, [ %sp + 0x6c ]
<== NOT EXECUTED
40059008: 94 12 a2 40 or %o2, 0x240, %o2
<== NOT EXECUTED
4005900c: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
<== NOT EXECUTED
40059010: 92 10 20 00 clr %o1
<== NOT EXECUTED
40059014: e2 23 a0 64 st %l1, [ %sp + 0x64 ]
<== NOT EXECUTED
40059018: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
4005901c: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
<== NOT EXECUTED
uintptr_t const page_size = heap->page_size;
40059020: ec 06 20 10 ld [ %i0 + 0x10 ], %l6
<== NOT EXECUTED
uintptr_t const min_block_size = heap->min_block_size;
40059024: e6 06 20 14 ld [ %i0 + 0x14 ], %l3
<== NOT EXECUTED
(*printer)(
40059028: da 06 20 18 ld [ %i0 + 0x18 ], %o5
<== NOT EXECUTED
4005902c: 98 10 00 13 mov %l3, %o4
<== NOT EXECUTED
40059030: 9f c4 00 00 call %l0
<== NOT EXECUTED
40059034: 96 10 00 16 mov %l6, %o3
<== NOT EXECUTED
if ( page_size == 0 ) {
40059038: 80 a5 a0 00 cmp %l6, 0
<== NOT EXECUTED
4005903c: 12 80 00 0a bne 40059064 <_Heap_Walk+0xc4>
<== NOT EXECUTED
40059040: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
(*printer)( source, true, "page size is zero\n" );
40059044: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
return false;
40059048: b4 10 20 00 clr %i2
<== NOT EXECUTED
(*printer)( source, true, "page size is zero\n" );
4005904c: 15 10 02 21 sethi %hi(0x40088400), %o2
<== NOT EXECUTED
40059050: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
40059054: 9f c4 00 00 call %l0
<== NOT EXECUTED
40059058: 94 12 a2 d8 or %o2, 0x2d8, %o2
<== NOT EXECUTED
}
4005905c: 81 c7 e0 08 ret
<== NOT EXECUTED
40059060: 81 e8 00 00 restore
<== NOT EXECUTED
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
40059064: 80 8d a0 07 btst 7, %l6
<== NOT EXECUTED
40059068: 02 80 00 0b be 40059094 <_Heap_Walk+0xf4>
<== NOT EXECUTED
4005906c: 96 10 00 16 mov %l6, %o3
<== NOT EXECUTED
(*printer)(
40059070: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
40059074: 15 10 02 21 sethi %hi(0x40088400), %o2
<== NOT EXECUTED
40059078: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
4005907c: 94 12 a2 f0 or %o2, 0x2f0, %o2
<== NOT EXECUTED
40059080: 9f c4 00 00 call %l0
<== NOT EXECUTED
40059084: b4 10 20 00 clr %i2
<== NOT EXECUTED
40059088: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
4005908c: 81 c7 e0 08 ret
<== NOT EXECUTED
40059090: 81 e8 00 00 restore
<== NOT EXECUTED
return (value % alignment) == 0;
40059094: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40059098: 01 00 00 00 nop
<== NOT EXECUTED
4005909c: 01 00 00 00 nop
<== NOT EXECUTED
400590a0: 01 00 00 00 nop
<== NOT EXECUTED
400590a4: 82 74 c0 16 udiv %l3, %l6, %g1
<== NOT EXECUTED
400590a8: 82 58 40 16 smul %g1, %l6, %g1
<== NOT EXECUTED
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
400590ac: 80 a4 c0 01 cmp %l3, %g1
<== NOT EXECUTED
400590b0: 02 80 00 0b be 400590dc <_Heap_Walk+0x13c>
<== NOT EXECUTED
400590b4: 96 10 00 13 mov %l3, %o3
<== NOT EXECUTED
(*printer)(
400590b8: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
400590bc: 15 10 02 21 sethi %hi(0x40088400), %o2
<== NOT EXECUTED
400590c0: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
400590c4: 94 12 a3 10 or %o2, 0x310, %o2
<== NOT EXECUTED
400590c8: 9f c4 00 00 call %l0
<== NOT EXECUTED
400590cc: b4 10 20 00 clr %i2
<== NOT EXECUTED
400590d0: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
400590d4: 81 c7 e0 08 ret
<== NOT EXECUTED
400590d8: 81 e8 00 00 restore
<== NOT EXECUTED
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
400590dc: 86 04 a0 08 add %l2, 8, %g3
<== NOT EXECUTED
return (value % alignment) == 0;
400590e0: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
400590e4: 01 00 00 00 nop
<== NOT EXECUTED
400590e8: 01 00 00 00 nop
<== NOT EXECUTED
400590ec: 01 00 00 00 nop
<== NOT EXECUTED
400590f0: 82 70 c0 16 udiv %g3, %l6, %g1
<== NOT EXECUTED
400590f4: 82 58 40 16 smul %g1, %l6, %g1
<== NOT EXECUTED
if (
400590f8: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
400590fc: 02 80 00 0b be 40059128 <_Heap_Walk+0x188>
<== NOT EXECUTED
40059100: 96 10 00 12 mov %l2, %o3
<== NOT EXECUTED
(*printer)(
40059104: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
40059108: 15 10 02 21 sethi %hi(0x40088400), %o2
<== NOT EXECUTED
4005910c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40059110: 94 12 a3 38 or %o2, 0x338, %o2
<== NOT EXECUTED
40059114: 9f c4 00 00 call %l0
<== NOT EXECUTED
40059118: b4 10 20 00 clr %i2
<== NOT EXECUTED
4005911c: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
40059120: 81 c7 e0 08 ret
<== NOT EXECUTED
40059124: 81 e8 00 00 restore
<== NOT EXECUTED
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40059128: c2 04 a0 04 ld [ %l2 + 4 ], %g1
<== NOT EXECUTED
if ( !_Heap_Is_prev_used( first_block ) ) {
4005912c: 80 88 60 01 btst 1, %g1
<== NOT EXECUTED
40059130: 12 80 00 0a bne 40059158 <_Heap_Walk+0x1b8>
<== NOT EXECUTED
40059134: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
(*printer)(
40059138: 15 10 02 21 sethi %hi(0x40088400), %o2
<== NOT EXECUTED
4005913c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40059140: 94 12 a3 70 or %o2, 0x370, %o2
<== NOT EXECUTED
40059144: 9f c4 00 00 call %l0
<== NOT EXECUTED
40059148: b4 10 20 00 clr %i2
<== NOT EXECUTED
4005914c: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
40059150: 81 c7 e0 08 ret
<== NOT EXECUTED
40059154: 81 e8 00 00 restore
<== NOT EXECUTED
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40059158: c2 04 60 04 ld [ %l1 + 4 ], %g1
<== NOT EXECUTED
4005915c: 82 08 7f fe and %g1, -2, %g1
<== NOT EXECUTED
return (Heap_Block *) ((uintptr_t) block + offset);
40059160: 82 04 40 01 add %l1, %g1, %g1
<== NOT EXECUTED
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40059164: c6 00 60 04 ld [ %g1 + 4 ], %g3
<== NOT EXECUTED
if ( _Heap_Is_free( last_block ) ) {
40059168: 80 88 e0 01 btst 1, %g3
<== NOT EXECUTED
4005916c: 12 80 00 09 bne 40059190 <_Heap_Walk+0x1f0>
<== NOT EXECUTED
40059170: 15 10 02 21 sethi %hi(0x40088400), %o2
<== NOT EXECUTED
(*printer)(
40059174: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40059178: 94 12 a3 a0 or %o2, 0x3a0, %o2
<== NOT EXECUTED
4005917c: 9f c4 00 00 call %l0
<== NOT EXECUTED
40059180: b4 10 20 00 clr %i2
<== NOT EXECUTED
40059184: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
40059188: 81 c7 e0 08 ret
<== NOT EXECUTED
4005918c: 81 e8 00 00 restore
<== NOT EXECUTED
if (
40059190: 80 a4 80 01 cmp %l2, %g1
<== NOT EXECUTED
40059194: 02 80 00 0a be 400591bc <_Heap_Walk+0x21c>
<== NOT EXECUTED
40059198: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
(*printer)(
4005919c: 15 10 02 21 sethi %hi(0x40088400), %o2
<== NOT EXECUTED
400591a0: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
400591a4: 94 12 a3 b8 or %o2, 0x3b8, %o2
<== NOT EXECUTED
400591a8: 9f c4 00 00 call %l0
<== NOT EXECUTED
400591ac: b4 10 20 00 clr %i2
<== NOT EXECUTED
400591b0: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
400591b4: 81 c7 e0 08 ret
<== NOT EXECUTED
400591b8: 81 e8 00 00 restore
<== NOT EXECUTED
uintptr_t const page_size = heap->page_size;
400591bc: fa 06 20 10 ld [ %i0 + 0x10 ], %i5
<== NOT EXECUTED
return _Heap_Free_list_head(heap)->next;
400591c0: e8 06 20 08 ld [ %i0 + 8 ], %l4
<== NOT EXECUTED
400591c4: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
<== NOT EXECUTED
const Heap_Block *prev_block = free_list_tail;
400591c8: 88 10 00 18 mov %i0, %g4
<== NOT EXECUTED
while ( free_block != free_list_tail ) {
400591cc: 80 a6 00 14 cmp %i0, %l4
<== NOT EXECUTED
400591d0: 02 80 00 1f be 4005924c <_Heap_Walk+0x2ac>
<== NOT EXECUTED
400591d4: 80 a5 00 03 cmp %l4, %g3
<== NOT EXECUTED
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
400591d8: 0a 80 00 f9 bcs 400595bc <_Heap_Walk+0x61c>
<== NOT EXECUTED
400591dc: 96 10 00 14 mov %l4, %o3
<== NOT EXECUTED
400591e0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
<== NOT EXECUTED
400591e4: 80 a0 40 14 cmp %g1, %l4
<== NOT EXECUTED
400591e8: 0a 80 00 f6 bcs 400595c0 <_Heap_Walk+0x620>
<== NOT EXECUTED
400591ec: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
400591f0: b8 05 20 08 add %l4, 8, %i4
<== NOT EXECUTED
return (value % alignment) == 0;
400591f4: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
400591f8: 01 00 00 00 nop
<== NOT EXECUTED
400591fc: 01 00 00 00 nop
<== NOT EXECUTED
40059200: 01 00 00 00 nop
<== NOT EXECUTED
40059204: 82 77 00 1d udiv %i4, %i5, %g1
<== NOT EXECUTED
40059208: 82 58 40 1d smul %g1, %i5, %g1
<== NOT EXECUTED
if (
4005920c: 80 a7 00 01 cmp %i4, %g1
<== NOT EXECUTED
40059210: 12 80 00 e4 bne 400595a0 <_Heap_Walk+0x600>
<== NOT EXECUTED
40059214: 15 10 02 21 sethi %hi(0x40088400), %o2
<== NOT EXECUTED
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40059218: c2 05 20 04 ld [ %l4 + 4 ], %g1
<== NOT EXECUTED
4005921c: 82 08 7f fe and %g1, -2, %g1
<== NOT EXECUTED
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40059220: 82 05 00 01 add %l4, %g1, %g1
<== NOT EXECUTED
40059224: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
if ( _Heap_Is_used( free_block ) ) {
40059228: 80 88 60 01 btst 1, %g1
<== NOT EXECUTED
4005922c: 12 80 00 d6 bne 40059584 <_Heap_Walk+0x5e4>
<== NOT EXECUTED
40059230: 15 10 02 22 sethi %hi(0x40088800), %o2
<== NOT EXECUTED
if ( free_block->prev != prev_block ) {
40059234: d8 05 20 0c ld [ %l4 + 0xc ], %o4
<== NOT EXECUTED
40059238: 80 a3 00 04 cmp %o4, %g4
<== NOT EXECUTED
4005923c: 12 80 00 c9 bne 40059560 <_Heap_Walk+0x5c0>
<== NOT EXECUTED
40059240: 88 10 00 14 mov %l4, %g4
<== NOT EXECUTED
free_block = free_block->next;
40059244: 10 bf ff e2 b 400591cc <_Heap_Walk+0x22c>
<== NOT EXECUTED
40059248: e8 05 20 08 ld [ %l4 + 8 ], %l4
<== NOT EXECUTED
(*printer)(
4005924c: 2f 10 02 21 sethi %hi(0x40088400), %l7
<== NOT EXECUTED
40059250: 82 15 e2 20 or %l7, 0x220, %g1 ! 40088620 <_Status_Object_name_errors_to_status+0x58>
<== NOT EXECUTED
40059254: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
: (block->next == free_list_tail ? " (= tail)" : "")
40059258: 03 10 02 21 sethi %hi(0x40088400), %g1
<== NOT EXECUTED
4005925c: 82 10 62 30 or %g1, 0x230, %g1 ! 40088630 <_Status_Object_name_errors_to_status+0x68>
<== NOT EXECUTED
40059260: c2 27 bf f4 st %g1, [ %fp + -12 ]
<== NOT EXECUTED
(*printer)(
40059264: 03 10 02 21 sethi %hi(0x40088400), %g1
<== NOT EXECUTED
40059268: 82 10 62 00 or %g1, 0x200, %g1 ! 40088600 <_Status_Object_name_errors_to_status+0x38>
<== NOT EXECUTED
4005926c: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
: (block->prev == free_list_head ? " (= head)" : ""),
40059270: 03 10 02 21 sethi %hi(0x40088400), %g1
<== NOT EXECUTED
40059274: 82 10 62 10 or %g1, 0x210, %g1 ! 40088610 <_Status_Object_name_errors_to_status+0x48>
<== NOT EXECUTED
40059278: c2 27 bf f0 st %g1, [ %fp + -16 ]
<== NOT EXECUTED
: (block->next == free_list_tail ? " (= tail)" : "")
4005927c: 2b 10 01 fa sethi %hi(0x4007e800), %l5
<== NOT EXECUTED
while ( free_block != free_list_tail ) {
40059280: ba 10 00 12 mov %l2, %i5
<== NOT EXECUTED
: (block->next == free_list_tail ? " (= tail)" : "")
40059284: aa 15 61 10 or %l5, 0x110, %l5
<== NOT EXECUTED
40059288: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4005928c: b6 08 7f fe and %g1, -2, %i3
<== NOT EXECUTED
return (Heap_Block *) ((uintptr_t) block + offset);
40059290: b8 07 40 1b add %i5, %i3, %i4
<== NOT EXECUTED
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40059294: 80 a0 c0 1c cmp %g3, %i4
<== NOT EXECUTED
40059298: 18 80 00 06 bgu 400592b0 <_Heap_Walk+0x310>
<== NOT EXECUTED
4005929c: ae 08 60 01 and %g1, 1, %l7
<== NOT EXECUTED
400592a0: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
<== NOT EXECUTED
400592a4: 80 a0 c0 1c cmp %g3, %i4
<== NOT EXECUTED
400592a8: 1a 80 00 0d bcc 400592dc <_Heap_Walk+0x33c>
<== NOT EXECUTED
400592ac: 01 00 00 00 nop
<== NOT EXECUTED
(*printer)(
400592b0: 98 10 00 1c mov %i4, %o4
<== NOT EXECUTED
400592b4: 96 10 00 1d mov %i5, %o3
<== NOT EXECUTED
400592b8: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
400592bc: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
return false;
400592c0: b4 10 20 00 clr %i2
<== NOT EXECUTED
(*printer)(
400592c4: 15 10 02 22 sethi %hi(0x40088800), %o2
<== NOT EXECUTED
400592c8: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
400592cc: 9f c4 00 00 call %l0
<== NOT EXECUTED
400592d0: 94 12 a2 10 or %o2, 0x210, %o2
<== NOT EXECUTED
}
400592d4: 81 c7 e0 08 ret
<== NOT EXECUTED
400592d8: 81 e8 00 00 restore
<== NOT EXECUTED
return (value % alignment) == 0;
400592dc: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
400592e0: 01 00 00 00 nop
<== NOT EXECUTED
400592e4: 01 00 00 00 nop
<== NOT EXECUTED
400592e8: 01 00 00 00 nop
<== NOT EXECUTED
400592ec: 86 76 c0 16 udiv %i3, %l6, %g3
<== NOT EXECUTED
400592f0: 86 58 c0 16 smul %g3, %l6, %g3
<== NOT EXECUTED
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
400592f4: 80 a6 c0 03 cmp %i3, %g3
<== NOT EXECUTED
400592f8: 02 80 00 17 be 40059354 <_Heap_Walk+0x3b4>
<== NOT EXECUTED
400592fc: 86 1f 40 11 xor %i5, %l1, %g3
<== NOT EXECUTED
40059300: 80 a7 40 11 cmp %i5, %l1
<== NOT EXECUTED
40059304: 12 80 00 79 bne 400594e8 <_Heap_Walk+0x548>
<== NOT EXECUTED
40059308: 98 10 00 1b mov %i3, %o4
<== NOT EXECUTED
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4005930c: c6 07 20 04 ld [ %i4 + 4 ], %g3
<== NOT EXECUTED
if ( !_Heap_Is_prev_used( next_block ) ) {
40059310: 80 88 e0 01 btst 1, %g3
<== NOT EXECUTED
40059314: 02 80 00 30 be 400593d4 <_Heap_Walk+0x434>
<== NOT EXECUTED
40059318: 80 a5 e0 00 cmp %l7, 0
<== NOT EXECUTED
} else if (prev_used) {
4005931c: 22 80 00 25 be,a 400593b0 <_Heap_Walk+0x410>
<== NOT EXECUTED
40059320: da 07 40 00 ld [ %i5 ], %o5
<== NOT EXECUTED
(*printer)(
40059324: 15 10 02 22 sethi %hi(0x40088800), %o2
<== NOT EXECUTED
40059328: 98 10 00 1b mov %i3, %o4
<== NOT EXECUTED
4005932c: 96 10 00 1d mov %i5, %o3
<== NOT EXECUTED
40059330: 94 12 a1 b0 or %o2, 0x1b0, %o2
<== NOT EXECUTED
40059334: 92 10 20 00 clr %o1
<== NOT EXECUTED
40059338: 9f c4 00 00 call %l0
<== NOT EXECUTED
4005933c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
} while ( block != first_block );
40059340: 80 a4 80 1c cmp %l2, %i4
<== NOT EXECUTED
40059344: 02 bf ff 20 be 40058fc4 <_Heap_Walk+0x24>
<== NOT EXECUTED
40059348: ba 10 00 1c mov %i4, %i5
<== NOT EXECUTED
4005934c: 10 bf ff cf b 40059288 <_Heap_Walk+0x2e8>
<== NOT EXECUTED
40059350: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
<== NOT EXECUTED
bool const is_not_last_block = block != last_block;
40059354: 80 a0 00 03 cmp %g0, %g3
<== NOT EXECUTED
40059358: 88 40 20 00 addx %g0, 0, %g4
<== NOT EXECUTED
if ( block_size < min_block_size && is_not_last_block ) {
4005935c: 80 a6 c0 13 cmp %i3, %l3
<== NOT EXECUTED
40059360: 86 40 20 00 addx %g0, 0, %g3
<== NOT EXECUTED
40059364: 86 09 00 03 and %g4, %g3, %g3
<== NOT EXECUTED
40059368: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
4005936c: 12 80 00 53 bne 400594b8 <_Heap_Walk+0x518>
<== NOT EXECUTED
40059370: b4 10 00 03 mov %g3, %i2
<== NOT EXECUTED
if ( next_block_begin <= block_begin && is_not_last_block ) {
40059374: 80 a7 40 1c cmp %i5, %i4
<== NOT EXECUTED
40059378: 0a bf ff e5 bcs 4005930c <_Heap_Walk+0x36c>
<== NOT EXECUTED
4005937c: 80 a1 20 00 cmp %g4, 0
<== NOT EXECUTED
40059380: 22 bf ff e4 be,a 40059310 <_Heap_Walk+0x370>
<== NOT EXECUTED
40059384: c6 07 20 04 ld [ %i4 + 4 ], %g3
<== NOT EXECUTED
(*printer)(
40059388: 98 10 00 1c mov %i4, %o4
<== NOT EXECUTED
4005938c: 96 10 00 1d mov %i5, %o3
<== NOT EXECUTED
40059390: 15 10 02 22 sethi %hi(0x40088800), %o2
<== NOT EXECUTED
40059394: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
40059398: 94 12 a0 d0 or %o2, 0xd0, %o2
<== NOT EXECUTED
4005939c: 9f c4 00 00 call %l0
<== NOT EXECUTED
400593a0: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
400593a4: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
400593a8: 81 c7 e0 08 ret
<== NOT EXECUTED
400593ac: 81 e8 00 00 restore
<== NOT EXECUTED
(*printer)(
400593b0: 98 10 00 1b mov %i3, %o4
<== NOT EXECUTED
400593b4: 96 10 00 1d mov %i5, %o3
<== NOT EXECUTED
400593b8: 15 10 02 22 sethi %hi(0x40088800), %o2
<== NOT EXECUTED
400593bc: 92 10 20 00 clr %o1
<== NOT EXECUTED
400593c0: 94 12 a1 c8 or %o2, 0x1c8, %o2
<== NOT EXECUTED
400593c4: 9f c4 00 00 call %l0
<== NOT EXECUTED
400593c8: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
} while ( block != first_block );
400593cc: 10 bf ff de b 40059344 <_Heap_Walk+0x3a4>
<== NOT EXECUTED
400593d0: 80 a4 80 1c cmp %l2, %i4
<== NOT EXECUTED
(*printer)(
400593d4: da 07 60 0c ld [ %i5 + 0xc ], %o5
<== NOT EXECUTED
400593d8: c6 06 20 08 ld [ %i0 + 8 ], %g3
<== NOT EXECUTED
return _Heap_Free_list_tail(heap)->prev;
400593dc: de 06 20 0c ld [ %i0 + 0xc ], %o7
<== NOT EXECUTED
400593e0: 80 a0 c0 0d cmp %g3, %o5
<== NOT EXECUTED
400593e4: 02 80 00 05 be 400593f8 <_Heap_Walk+0x458>
<== NOT EXECUTED
400593e8: c8 07 bf f8 ld [ %fp + -8 ], %g4
<== NOT EXECUTED
: (block->prev == free_list_head ? " (= head)" : ""),
400593ec: 80 a5 00 0d cmp %l4, %o5
<== NOT EXECUTED
400593f0: 02 80 00 22 be 40059478 <_Heap_Walk+0x4d8>
<== NOT EXECUTED
400593f4: 88 10 00 15 mov %l5, %g4
<== NOT EXECUTED
(*printer)(
400593f8: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
400593fc: 80 a3 c0 03 cmp %o7, %g3
<== NOT EXECUTED
40059400: 02 80 00 05 be 40059414 <_Heap_Walk+0x474>
<== NOT EXECUTED
40059404: f4 07 bf fc ld [ %fp + -4 ], %i2
<== NOT EXECUTED
: (block->next == free_list_tail ? " (= tail)" : "")
40059408: 80 a5 00 03 cmp %l4, %g3
<== NOT EXECUTED
4005940c: 02 80 00 1d be 40059480 <_Heap_Walk+0x4e0>
<== NOT EXECUTED
40059410: b4 10 00 15 mov %l5, %i2
<== NOT EXECUTED
(*printer)(
40059414: f4 23 a0 64 st %i2, [ %sp + 0x64 ]
<== NOT EXECUTED
40059418: 98 10 00 1b mov %i3, %o4
<== NOT EXECUTED
4005941c: c6 23 a0 60 st %g3, [ %sp + 0x60 ]
<== NOT EXECUTED
40059420: 96 10 00 1d mov %i5, %o3
<== NOT EXECUTED
40059424: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
<== NOT EXECUTED
40059428: 92 10 20 00 clr %o1
<== NOT EXECUTED
4005942c: 15 10 02 22 sethi %hi(0x40088800), %o2
<== NOT EXECUTED
40059430: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40059434: 9f c4 00 00 call %l0
<== NOT EXECUTED
40059438: 94 12 a1 08 or %o2, 0x108, %o2
<== NOT EXECUTED
if ( block_size != next_block->prev_size ) {
4005943c: da 07 00 00 ld [ %i4 ], %o5
<== NOT EXECUTED
40059440: 80 a6 c0 0d cmp %i3, %o5
<== NOT EXECUTED
40059444: 02 80 00 11 be 40059488 <_Heap_Walk+0x4e8>
<== NOT EXECUTED
40059448: 98 10 00 1b mov %i3, %o4
<== NOT EXECUTED
(*printer)(
4005944c: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
<== NOT EXECUTED
40059450: 96 10 00 1d mov %i5, %o3
<== NOT EXECUTED
40059454: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
40059458: 15 10 02 22 sethi %hi(0x40088800), %o2
<== NOT EXECUTED
4005945c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40059460: 94 12 a1 40 or %o2, 0x140, %o2
<== NOT EXECUTED
40059464: 9f c4 00 00 call %l0
<== NOT EXECUTED
40059468: b4 10 20 00 clr %i2
<== NOT EXECUTED
4005946c: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
40059470: 81 c7 e0 08 ret
<== NOT EXECUTED
40059474: 81 e8 00 00 restore
<== NOT EXECUTED
: (block->prev == free_list_head ? " (= head)" : ""),
40059478: 10 bf ff e0 b 400593f8 <_Heap_Walk+0x458>
<== NOT EXECUTED
4005947c: c8 07 bf f0 ld [ %fp + -16 ], %g4
<== NOT EXECUTED
: (block->next == free_list_tail ? " (= tail)" : "")
40059480: 10 bf ff e5 b 40059414 <_Heap_Walk+0x474>
<== NOT EXECUTED
40059484: f4 07 bf f4 ld [ %fp + -12 ], %i2
<== NOT EXECUTED
if ( !prev_used ) {
40059488: 80 a5 e0 00 cmp %l7, 0
<== NOT EXECUTED
4005948c: 12 80 00 21 bne 40059510 <_Heap_Walk+0x570>
<== NOT EXECUTED
40059490: 96 10 00 1d mov %i5, %o3
<== NOT EXECUTED
(*printer)(
40059494: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
40059498: 15 10 02 22 sethi %hi(0x40088800), %o2
<== NOT EXECUTED
4005949c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
400594a0: 94 12 a1 80 or %o2, 0x180, %o2
<== NOT EXECUTED
400594a4: 9f c4 00 00 call %l0
<== NOT EXECUTED
400594a8: b4 10 20 00 clr %i2
<== NOT EXECUTED
400594ac: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
400594b0: 81 c7 e0 08 ret
<== NOT EXECUTED
400594b4: 81 e8 00 00 restore
<== NOT EXECUTED
(*printer)(
400594b8: 9a 10 00 13 mov %l3, %o5
<== NOT EXECUTED
400594bc: 98 10 00 1b mov %i3, %o4
<== NOT EXECUTED
400594c0: 96 10 00 1d mov %i5, %o3
<== NOT EXECUTED
400594c4: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
400594c8: 15 10 02 22 sethi %hi(0x40088800), %o2
<== NOT EXECUTED
400594cc: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
400594d0: 94 12 a0 a0 or %o2, 0xa0, %o2
<== NOT EXECUTED
400594d4: 9f c4 00 00 call %l0
<== NOT EXECUTED
400594d8: b4 10 20 00 clr %i2
<== NOT EXECUTED
400594dc: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
400594e0: 81 c7 e0 08 ret
<== NOT EXECUTED
400594e4: 81 e8 00 00 restore
<== NOT EXECUTED
(*printer)(
400594e8: 96 10 00 1d mov %i5, %o3
<== NOT EXECUTED
400594ec: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
400594f0: 15 10 02 22 sethi %hi(0x40088800), %o2
<== NOT EXECUTED
400594f4: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
400594f8: 94 12 a0 70 or %o2, 0x70, %o2
<== NOT EXECUTED
400594fc: 9f c4 00 00 call %l0
<== NOT EXECUTED
40059500: b4 10 20 00 clr %i2
<== NOT EXECUTED
40059504: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
40059508: 81 c7 e0 08 ret
<== NOT EXECUTED
4005950c: 81 e8 00 00 restore
<== NOT EXECUTED
return _Heap_Free_list_head(heap)->next;
40059510: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
while ( free_block != free_list_tail ) {
40059514: 80 a5 00 01 cmp %l4, %g1
<== NOT EXECUTED
40059518: 02 80 00 09 be 4005953c <_Heap_Walk+0x59c>
<== NOT EXECUTED
4005951c: 80 a7 40 01 cmp %i5, %g1
<== NOT EXECUTED
if ( free_block == block ) {
40059520: 02 bf ff 89 be 40059344 <_Heap_Walk+0x3a4>
<== NOT EXECUTED
40059524: 80 a4 80 1c cmp %l2, %i4
<== NOT EXECUTED
free_block = free_block->next;
40059528: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
while ( free_block != free_list_tail ) {
4005952c: 80 a5 00 01 cmp %l4, %g1
<== NOT EXECUTED
40059530: 12 bf ff fc bne 40059520 <_Heap_Walk+0x580>
<== NOT EXECUTED
40059534: 80 a7 40 01 cmp %i5, %g1
<== NOT EXECUTED
(*printer)(
40059538: 96 10 00 1d mov %i5, %o3
<== NOT EXECUTED
4005953c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
40059540: 15 10 02 22 sethi %hi(0x40088800), %o2
<== NOT EXECUTED
40059544: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40059548: 94 12 a2 40 or %o2, 0x240, %o2
<== NOT EXECUTED
4005954c: 9f c4 00 00 call %l0
<== NOT EXECUTED
40059550: b4 10 20 00 clr %i2
<== NOT EXECUTED
40059554: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
40059558: 81 c7 e0 08 ret
<== NOT EXECUTED
4005955c: 81 e8 00 00 restore
<== NOT EXECUTED
(*printer)(
40059560: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
40059564: 15 10 02 22 sethi %hi(0x40088800), %o2
<== NOT EXECUTED
40059568: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
4005956c: 94 12 a0 38 or %o2, 0x38, %o2
<== NOT EXECUTED
40059570: 9f c4 00 00 call %l0
<== NOT EXECUTED
40059574: b4 10 20 00 clr %i2
<== NOT EXECUTED
40059578: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
4005957c: 81 c7 e0 08 ret
<== NOT EXECUTED
40059580: 81 e8 00 00 restore
<== NOT EXECUTED
(*printer)(
40059584: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40059588: 94 12 a0 18 or %o2, 0x18, %o2
<== NOT EXECUTED
4005958c: 9f c4 00 00 call %l0
<== NOT EXECUTED
40059590: b4 10 20 00 clr %i2
<== NOT EXECUTED
40059594: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
40059598: 81 c7 e0 08 ret
<== NOT EXECUTED
4005959c: 81 e8 00 00 restore
<== NOT EXECUTED
(*printer)(
400595a0: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
400595a4: 94 12 a3 e8 or %o2, 0x3e8, %o2
<== NOT EXECUTED
400595a8: 9f c4 00 00 call %l0
<== NOT EXECUTED
400595ac: b4 10 20 00 clr %i2
<== NOT EXECUTED
400595b0: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
400595b4: 81 c7 e0 08 ret
<== NOT EXECUTED
400595b8: 81 e8 00 00 restore
<== NOT EXECUTED
(*printer)(
400595bc: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
400595c0: 15 10 02 22 sethi %hi(0x40088800), %o2
<== NOT EXECUTED
400595c4: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
400595c8: 94 12 a1 f0 or %o2, 0x1f0, %o2
<== NOT EXECUTED
400595cc: 9f c4 00 00 call %l0
<== NOT EXECUTED
400595d0: b4 10 20 00 clr %i2
<== NOT EXECUTED
400595d4: b0 0e a0 ff and %i2, 0xff, %i0
<== NOT EXECUTED
400595d8: 81 c7 e0 08 ret
<== NOT EXECUTED
400595dc: 81 e8 00 00 restore
<== NOT EXECUTED
40007460 <_IO_Vprintf>:
return (p);
}
int
_IO_Vprintf(IO_Put_char put_char, void *arg, char const *fmt, va_list ap)
{
40007460: 9d e3 bf 50 save %sp, -176, %sp
char padc;
int stop = 0, retval = 0;
num = 0;
if (fmt == NULL)
40007464: 80 a6 a0 00 cmp %i2, 0
40007468: 02 80 00 3e be 40007560 <_IO_Vprintf+0x100>
<== NEVER TAKEN
4000746c: 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++) {
40007470: 31 10 00 1c sethi %hi(0x40007000), %i0
40007474: 03 10 00 41 sethi %hi(0x40010400), %g1
40007478: a8 10 20 00 clr %l4
4000747c: a4 10 20 00 clr %l2
40007480: b0 16 23 00 or %i0, 0x300, %i0
40007484: ae 10 63 ff or %g1, 0x3ff, %l7
while ((ch = (u_char)*fmt++) != '%' || stop) {
40007488: c2 0e 80 00 ldub [ %i2 ], %g1
4000748c: a4 0c a0 01 and %l2, 1, %l2
40007490: ba 06 a0 01 add %i2, 1, %i5
40007494: 90 10 00 01 mov %g1, %o0
40007498: 80 a0 60 25 cmp %g1, 0x25
4000749c: 12 80 00 05 bne 400074b0 <_IO_Vprintf+0x50>
400074a0: a0 10 00 12 mov %l2, %l0
400074a4: 80 a4 a0 00 cmp %l2, 0
400074a8: 22 80 00 16 be,a 40007500 <_IO_Vprintf+0xa0>
<== ALWAYS TAKEN
400074ac: 82 10 00 1d mov %i5, %g1
if (ch == '\0')
400074b0: 80 a0 60 00 cmp %g1, 0
400074b4: 02 80 00 32 be 4000757c <_IO_Vprintf+0x11c>
400074b8: b4 25 00 1a sub %l4, %i2, %i2
while ((ch = (u_char)*fmt++) != '%' || stop) {
400074bc: a0 0c 20 ff and %l0, 0xff, %l0
PCHAR(ch);
400074c0: 9f c7 00 00 call %i4
400074c4: 92 10 00 19 mov %i1, %o1
while ((ch = (u_char)*fmt++) != '%' || stop) {
400074c8: 82 07 60 01 add %i5, 1, %g1
400074cc: d0 08 7f ff ldub [ %g1 + -1 ], %o0
400074d0: 80 a2 20 25 cmp %o0, 0x25
400074d4: 12 80 00 05 bne 400074e8 <_IO_Vprintf+0x88>
400074d8: aa 07 40 1a add %i5, %i2, %l5
400074dc: 80 a4 20 00 cmp %l0, 0
400074e0: 02 80 00 0b be 4000750c <_IO_Vprintf+0xac>
<== ALWAYS TAKEN
400074e4: 84 10 20 20 mov 0x20, %g2
if (ch == '\0')
400074e8: 80 a2 20 00 cmp %o0, 0
400074ec: 12 bf ff f5 bne 400074c0 <_IO_Vprintf+0x60>
400074f0: ba 10 00 01 mov %g1, %i5
400074f4: ac 10 00 15 mov %l5, %l6
stop = 1;
break;
}
}
#undef PCHAR
}
400074f8: 81 c7 e0 08 ret
400074fc: 91 e8 00 16 restore %g0, %l6, %o0
while ((ch = (u_char)*fmt++) != '%' || stop) {
40007500: aa 10 00 14 mov %l4, %l5
40007504: ba 10 00 1a mov %i2, %i5
padc = ' ';
40007508: 84 10 20 20 mov 0x20, %g2
sign = 0; dot = 0; dwidth = 0; upper = 0;
4000750c: c0 27 bf d0 clr [ %fp + -48 ]
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
40007510: a8 10 20 00 clr %l4
padc = ' ';
40007514: c4 2f bf c3 stb %g2, [ %fp + -61 ]
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
40007518: 9e 10 20 00 clr %o7
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
4000751c: c0 27 bf c4 clr [ %fp + -60 ]
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
40007520: 9a 10 20 00 clr %o5
width = 0;
40007524: c0 27 bf d4 clr [ %fp + -44 ]
sign = 0; dot = 0; dwidth = 0; upper = 0;
40007528: 96 10 20 00 clr %o3
4000752c: d8 08 40 00 ldub [ %g1 ], %o4
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
40007530: a4 10 20 00 clr %l2
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
40007534: 88 10 20 00 clr %g4
reswitch: switch (ch = (u_char)*fmt++) {
40007538: 84 03 3f dd add %o4, -35, %g2
4000753c: b4 00 60 01 add %g1, 1, %i2
40007540: 84 08 a0 ff and %g2, 0xff, %g2
40007544: 80 a0 a0 57 cmp %g2, 0x57
40007548: 18 80 01 d9 bgu 40007cac <_IO_Vprintf+0x84c>
<== NEVER TAKEN
4000754c: 90 0b 20 ff and %o4, 0xff, %o0
40007550: 85 28 a0 02 sll %g2, 2, %g2
40007554: c4 06 00 02 ld [ %i0 + %g2 ], %g2
40007558: 81 c0 80 00 jmp %g2
4000755c: 01 00 00 00 nop
fmt = "(fmt null)\n";
40007560: 35 10 00 41 sethi %hi(0x40010400), %i2
<== NOT EXECUTED
40007564: 10 bf ff c3 b 40007470 <_IO_Vprintf+0x10>
<== NOT EXECUTED
40007568: b4 16 a3 e8 or %i2, 0x3e8, %i2 ! 400107e8 <_Objects_Information_table+0x24>
<== NOT EXECUTED
4000756c: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
zflag = 1;
40007570: 88 10 20 01 mov 1, %g4
goto reswitch;
40007574: 10 bf ff f1 b 40007538 <_IO_Vprintf+0xd8>
40007578: 82 10 00 1a mov %i2, %g1
return (retval);
4000757c: 10 bf ff df b 400074f8 <_IO_Vprintf+0x98>
40007580: ac 10 00 14 mov %l4, %l6
if (!dot) {
40007584: 80 a2 e0 00 cmp %o3, 0
40007588: 32 80 02 5b bne,a 40007ef4 <_IO_Vprintf+0xa94>
<== NEVER TAKEN
4000758c: c6 48 60 01 ldsb [ %g1 + 1 ], %g3
<== NOT EXECUTED
padc = '0';
40007590: d8 2f bf c3 stb %o4, [ %fp + -61 ]
if (!dot) {
40007594: d8 08 60 01 ldub [ %g1 + 1 ], %o4
reswitch: switch (ch = (u_char)*fmt++) {
40007598: 10 bf ff e8 b 40007538 <_IO_Vprintf+0xd8>
4000759c: 82 10 00 1a mov %i2, %g1
400075a0: 84 10 20 00 clr %g2
400075a4: 86 10 20 10 mov 0x10, %g3
base = 16;
400075a8: 82 10 20 10 mov 0x10, %g1
reswitch: switch (ch = (u_char)*fmt++) {
400075ac: c4 3f bf b0 std %g2, [ %fp + -80 ]
sign = 0; dot = 0; dwidth = 0; upper = 0;
400075b0: ba 10 20 00 clr %i5
base = 16;
400075b4: c2 27 bf bc st %g1, [ %fp + -68 ]
if (jflag)
400075b8: 80 a5 20 00 cmp %l4, 0
400075bc: 02 80 01 dc be 40007d2c <_IO_Vprintf+0x8cc>
<== ALWAYS TAKEN
400075c0: 80 a1 20 00 cmp %g4, 0
num = va_arg(ap, uintmax_t);
400075c4: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
400075c8: 94 10 20 08 mov 8, %o2
<== NOT EXECUTED
400075cc: 40 00 1c a0 call 4000e84c <memcpy>
<== NOT EXECUTED
400075d0: 90 07 bf d8 add %fp, -40, %o0
<== NOT EXECUTED
400075d4: c4 1f bf d8 ldd [ %fp + -40 ], %g2
<== NOT EXECUTED
400075d8: c4 3f bf c8 std %g2, [ %fp + -56 ]
<== NOT EXECUTED
400075dc: b6 06 e0 08 add %i3, 8, %i3
<== NOT EXECUTED
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
400075e0: a8 10 20 00 clr %l4
<== NOT EXECUTED
400075e4: bb 2f 60 04 sll %i5, 4, %i5
*p = '\0';
400075e8: c0 2f bf e8 clrb [ %fp + -24 ]
*++p = hex2ascii_data[upper][num % base];
400075ec: a2 05 c0 1d add %l7, %i5, %l1
400075f0: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
400075f4: ac 10 00 1c mov %i4, %l6
*p = '\0';
400075f8: c4 1f bf c8 ldd [ %fp + -56 ], %g2
*++p = hex2ascii_data[upper][num % base];
400075fc: f8 1f bf b0 ldd [ %fp + -80 ], %i4
40007600: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
*p = '\0';
40007604: a6 10 00 02 mov %g2, %l3
p = nbuf;
40007608: a0 07 bf e8 add %fp, -24, %l0
*++p = hex2ascii_data[upper][num % base];
4000760c: b6 10 00 03 mov %g3, %i3
40007610: 94 10 00 1c mov %i4, %o2
40007614: 96 10 00 1d mov %i5, %o3
40007618: 90 10 00 13 mov %l3, %o0
4000761c: 40 00 20 56 call 4000f774 <__umoddi3>
40007620: 92 10 00 1b mov %i3, %o1
40007624: f4 0c 40 09 ldub [ %l1 + %o1 ], %i2
40007628: a0 04 20 01 inc %l0
4000762c: f4 2c 00 00 stb %i2, [ %l0 ]
} while (num /= base);
40007630: 90 10 00 13 mov %l3, %o0
40007634: 92 10 00 1b mov %i3, %o1
40007638: 94 10 00 1c mov %i4, %o2
4000763c: 40 00 1f d5 call 4000f590 <__udivdi3>
40007640: 96 10 00 1d mov %i5, %o3
40007644: a6 10 00 08 mov %o0, %l3
40007648: 80 92 40 13 orcc %o1, %l3, %g0
4000764c: 12 bf ff f1 bne 40007610 <_IO_Vprintf+0x1b0>
40007650: b6 10 00 09 mov %o1, %i3
if (sharpflag && num != 0) {
40007654: c4 1f bf c8 ldd [ %fp + -56 ], %g2
40007658: 82 10 00 02 mov %g2, %g1
4000765c: c4 07 bf c4 ld [ %fp + -60 ], %g2
40007660: 82 10 40 03 or %g1, %g3, %g1
40007664: 80 a0 00 01 cmp %g0, %g1
40007668: 86 40 20 00 addx %g0, 0, %g3
4000766c: 84 88 c0 02 andcc %g3, %g2, %g2
40007670: c4 27 bf c4 st %g2, [ %fp + -60 ]
*lenp = p - nbuf;
40007674: 82 07 bf e8 add %fp, -24, %g1
40007678: ba 10 00 1a mov %i2, %i5
4000767c: a2 24 00 01 sub %l0, %g1, %l1
40007680: b8 10 00 16 mov %l6, %i4
40007684: f4 07 a0 4c ld [ %fp + 0x4c ], %i2
40007688: f6 07 a0 50 ld [ %fp + 0x50 ], %i3
if (sharpflag && num != 0) {
4000768c: 02 80 00 0a be 400076b4 <_IO_Vprintf+0x254>
40007690: 82 10 20 00 clr %g1
if (base == 8)
40007694: c4 07 bf bc ld [ %fp + -68 ], %g2
40007698: 80 a0 a0 08 cmp %g2, 8
4000769c: 02 80 00 06 be 400076b4 <_IO_Vprintf+0x254>
<== NEVER TAKEN
400076a0: 82 10 20 01 mov 1, %g1
tmp = 0;
400076a4: 82 18 a0 10 xor %g2, 0x10, %g1
400076a8: 80 a0 00 01 cmp %g0, %g1
400076ac: 82 60 3f ff subx %g0, -1, %g1
400076b0: 83 28 60 01 sll %g1, 1, %g1
tmp++;
400076b4: 80 a0 00 14 cmp %g0, %l4
400076b8: 82 40 00 01 addx %g0, %g1, %g1
if (!ladjust && padc == '0')
400076bc: 80 8c a0 01 btst 1, %l2
400076c0: 12 80 01 8d bne 40007cf4 <_IO_Vprintf+0x894>
<== NEVER TAKEN
400076c4: c4 0f bf c3 ldub [ %fp + -61 ], %g2
400076c8: 87 28 a0 18 sll %g2, 0x18, %g3
400076cc: 87 38 e0 18 sra %g3, 0x18, %g3
400076d0: 80 a0 e0 30 cmp %g3, 0x30
400076d4: 12 80 01 88 bne 40007cf4 <_IO_Vprintf+0x894>
400076d8: c4 07 bf d4 ld [ %fp + -44 ], %g2
dwidth = width - tmp;
400076dc: ac 20 80 01 sub %g2, %g1, %l6
static inline int imax(int a, int b) { return (a > b ? a : b); }
400076e0: 80 a5 80 11 cmp %l6, %l1
400076e4: 16 80 00 04 bge 400076f4 <_IO_Vprintf+0x294>
<== ALWAYS TAKEN
400076e8: 86 10 00 16 mov %l6, %g3
400076ec: 86 10 00 11 mov %l1, %g3
<== NOT EXECUTED
width -= tmp + imax(dwidth, n);
400076f0: c4 07 bf d4 ld [ %fp + -44 ], %g2
<== NOT EXECUTED
400076f4: 82 00 c0 01 add %g3, %g1, %g1
dwidth -= n;
400076f8: a2 25 80 11 sub %l6, %l1, %l1
width -= tmp + imax(dwidth, n);
400076fc: a6 20 80 01 sub %g2, %g1, %l3
while (width-- > 0)
40007700: ac 04 ff ff add %l3, -1, %l6
40007704: 80 a4 e0 00 cmp %l3, 0
40007708: 04 80 00 0b ble 40007734 <_IO_Vprintf+0x2d4>
4000770c: a6 10 00 16 mov %l6, %l3
PCHAR(' ');
40007710: 92 10 00 19 mov %i1, %o1
40007714: 9f c7 00 00 call %i4
40007718: 90 10 20 20 mov 0x20, %o0
while (width-- > 0)
4000771c: a6 04 ff ff add %l3, -1, %l3
40007720: 80 a4 ff ff cmp %l3, -1
40007724: 12 bf ff fc bne 40007714 <_IO_Vprintf+0x2b4>
40007728: 92 10 00 19 mov %i1, %o1
4000772c: 84 05 60 01 add %l5, 1, %g2
40007730: aa 05 80 02 add %l6, %g2, %l5
if (neg)
40007734: 80 a5 20 00 cmp %l4, 0
40007738: 02 80 01 8e be 40007d70 <_IO_Vprintf+0x910>
<== ALWAYS TAKEN
4000773c: 92 10 00 19 mov %i1, %o1
PCHAR('-');
40007740: 90 10 20 2d mov 0x2d, %o0
<== NOT EXECUTED
40007744: 9f c7 00 00 call %i4
<== NOT EXECUTED
40007748: a8 05 60 01 add %l5, 1, %l4
<== NOT EXECUTED
if (sharpflag && num != 0) {
4000774c: c2 07 bf c4 ld [ %fp + -60 ], %g1
40007750: 80 a0 60 00 cmp %g1, 0
40007754: 02 80 00 0a be 4000777c <_IO_Vprintf+0x31c>
40007758: 80 a4 60 00 cmp %l1, 0
if (base == 8) {
4000775c: c2 07 bf bc ld [ %fp + -68 ], %g1
40007760: 80 a0 60 08 cmp %g1, 8
40007764: 12 80 01 92 bne 40007dac <_IO_Vprintf+0x94c>
<== ALWAYS TAKEN
40007768: 92 10 00 19 mov %i1, %o1
PCHAR('0');
4000776c: 90 10 20 30 mov 0x30, %o0
<== NOT EXECUTED
40007770: 9f c7 00 00 call %i4
<== NOT EXECUTED
40007774: a8 05 20 01 inc %l4
<== NOT EXECUTED
while (dwidth-- > 0)
40007778: 80 a4 60 00 cmp %l1, 0
<== NOT EXECUTED
4000777c: 04 80 00 0c ble 400077ac <_IO_Vprintf+0x34c>
40007780: aa 04 7f ff add %l1, -1, %l5
40007784: a2 10 00 15 mov %l5, %l1
PCHAR('0');
40007788: 92 10 00 19 mov %i1, %o1
4000778c: 9f c7 00 00 call %i4
40007790: 90 10 20 30 mov 0x30, %o0
while (dwidth-- > 0)
40007794: a2 04 7f ff add %l1, -1, %l1
40007798: 80 a4 7f ff cmp %l1, -1
4000779c: 12 bf ff fc bne 4000778c <_IO_Vprintf+0x32c>
<== NEVER TAKEN
400077a0: 92 10 00 19 mov %i1, %o1
400077a4: a8 05 20 01 inc %l4
400077a8: a8 05 00 15 add %l4, %l5, %l4
while (*p)
400077ac: bb 2f 60 18 sll %i5, 0x18, %i5
400077b0: 80 a7 60 00 cmp %i5, 0
400077b4: 02 80 00 0c be 400077e4 <_IO_Vprintf+0x384>
<== NEVER TAKEN
400077b8: 80 a4 a0 00 cmp %l2, 0
PCHAR(*p--);
400077bc: 91 3f 60 18 sra %i5, 0x18, %o0
400077c0: a0 04 3f ff add %l0, -1, %l0
400077c4: 9f c7 00 00 call %i4
400077c8: 92 10 00 19 mov %i1, %o1
while (*p)
400077cc: fa 0c 00 00 ldub [ %l0 ], %i5
400077d0: bb 2f 60 18 sll %i5, 0x18, %i5
400077d4: 80 a7 60 00 cmp %i5, 0
400077d8: 12 bf ff f9 bne 400077bc <_IO_Vprintf+0x35c>
400077dc: a8 05 20 01 inc %l4
if (ladjust)
400077e0: 80 a4 a0 00 cmp %l2, 0
400077e4: 22 bf ff 2a be,a 4000748c <_IO_Vprintf+0x2c>
<== ALWAYS TAKEN
400077e8: c2 0e 80 00 ldub [ %i2 ], %g1
while (width-- > 0)
400077ec: 80 a4 e0 00 cmp %l3, 0
<== NOT EXECUTED
400077f0: 04 80 01 59 ble 40007d54 <_IO_Vprintf+0x8f4>
<== NOT EXECUTED
400077f4: a0 04 ff ff add %l3, -1, %l0
<== NOT EXECUTED
400077f8: ba 10 00 10 mov %l0, %i5
<== NOT EXECUTED
PCHAR(' ');
400077fc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40007800: 9f c7 00 00 call %i4
<== NOT EXECUTED
40007804: 90 10 20 20 mov 0x20, %o0
<== NOT EXECUTED
while (width-- > 0)
40007808: ba 07 7f ff add %i5, -1, %i5
<== NOT EXECUTED
4000780c: 80 a7 7f ff cmp %i5, -1
<== NOT EXECUTED
40007810: 12 bf ff fc bne 40007800 <_IO_Vprintf+0x3a0>
<== NOT EXECUTED
40007814: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40007818: a8 05 20 01 inc %l4
<== NOT EXECUTED
4000781c: a4 10 20 00 clr %l2
<== NOT EXECUTED
40007820: 10 bf ff 1a b 40007488 <_IO_Vprintf+0x28>
<== NOT EXECUTED
40007824: a8 04 00 14 add %l0, %l4, %l4
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
40007828: 84 10 20 00 clr %g2
<== NOT EXECUTED
4000782c: 86 10 20 10 mov 0x10, %g3
<== NOT EXECUTED
base = 16;
40007830: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
40007834: c4 3f bf b0 std %g2, [ %fp + -80 ]
<== NOT EXECUTED
base = 16;
40007838: c2 27 bf bc st %g1, [ %fp + -68 ]
<== NOT EXECUTED
if (jflag)
4000783c: 80 a5 20 00 cmp %l4, 0
40007840: 02 80 01 4e be 40007d78 <_IO_Vprintf+0x918>
40007844: 82 06 e0 04 add %i3, 4, %g1
num = va_arg(ap, intmax_t);
40007848: 92 10 00 1b mov %i3, %o1
4000784c: 94 10 20 08 mov 8, %o2
40007850: 40 00 1b ff call 4000e84c <memcpy>
40007854: 90 07 bf e0 add %fp, -32, %o0
40007858: c4 1f bf e0 ldd [ %fp + -32 ], %g2
4000785c: c4 3f bf c8 std %g2, [ %fp + -56 ]
40007860: b6 06 e0 08 add %i3, 8, %i3
if (sign && (intmax_t)num < 0) {
40007864: c4 1f bf c8 ldd [ %fp + -56 ], %g2
40007868: 82 90 a0 00 orcc %g2, 0, %g1
4000786c: 16 80 01 c8 bge 40007f8c <_IO_Vprintf+0xb2c>
<== ALWAYS TAKEN
40007870: 9a a0 00 03 subcc %g0, %g3, %o5
num = -(intmax_t)num;
40007874: ba 10 20 00 clr %i5
<== NOT EXECUTED
40007878: 98 60 00 02 subx %g0, %g2, %o4
<== NOT EXECUTED
neg = 1;
4000787c: a8 10 20 01 mov 1, %l4
<== NOT EXECUTED
num = -(intmax_t)num;
40007880: 10 bf ff 59 b 400075e4 <_IO_Vprintf+0x184>
<== NOT EXECUTED
40007884: d8 3f bf c8 std %o4, [ %fp + -56 ]
<== NOT EXECUTED
if (!ladjust && width > 0)
40007888: c2 07 bf d4 ld [ %fp + -44 ], %g1
4000788c: 80 a0 60 01 cmp %g1, 1
40007890: 14 80 00 03 bg 4000789c <_IO_Vprintf+0x43c>
<== NEVER TAKEN
40007894: ba 10 20 01 mov 1, %i5
40007898: ba 10 20 00 clr %i5
4000789c: a8 05 60 01 add %l5, 1, %l4
400078a0: 80 8c a0 01 btst 1, %l2
400078a4: 12 80 01 52 bne 40007dec <_IO_Vprintf+0x98c>
<== NEVER TAKEN
400078a8: a0 06 e0 04 add %i3, 4, %l0
400078ac: 80 8f 60 ff btst 0xff, %i5
400078b0: 02 80 01 4f be 40007dec <_IO_Vprintf+0x98c>
<== ALWAYS TAKEN
400078b4: c2 07 bf d4 ld [ %fp + -44 ], %g1
while (width--)
400078b8: a6 00 7f fe add %g1, -2, %l3
<== NOT EXECUTED
400078bc: c2 0f bf c3 ldub [ %fp + -61 ], %g1
<== NOT EXECUTED
400078c0: a3 28 60 18 sll %g1, 0x18, %l1
<== NOT EXECUTED
400078c4: ba 10 00 13 mov %l3, %i5
<== NOT EXECUTED
400078c8: a3 3c 60 18 sra %l1, 0x18, %l1
<== NOT EXECUTED
PCHAR(padc);
400078cc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400078d0: 9f c7 00 00 call %i4
<== NOT EXECUTED
400078d4: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
while (width--)
400078d8: ba 07 7f ff add %i5, -1, %i5
<== NOT EXECUTED
400078dc: 80 a7 7f ff cmp %i5, -1
<== NOT EXECUTED
400078e0: 12 bf ff fc bne 400078d0 <_IO_Vprintf+0x470>
<== NOT EXECUTED
400078e4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
PCHAR(va_arg(ap, int));
400078e8: d0 06 c0 00 ld [ %i3 ], %o0
<== NOT EXECUTED
400078ec: a6 05 00 13 add %l4, %l3, %l3
<== NOT EXECUTED
400078f0: a8 04 e0 01 add %l3, 1, %l4
<== NOT EXECUTED
400078f4: 9f c7 00 00 call %i4
<== NOT EXECUTED
400078f8: b6 10 00 10 mov %l0, %i3
<== NOT EXECUTED
400078fc: 10 bf fe e3 b 40007488 <_IO_Vprintf+0x28>
<== NOT EXECUTED
40007900: a4 10 20 00 clr %l2
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
40007904: 84 10 20 00 clr %g2
40007908: 86 10 20 0a mov 0xa, %g3
base = 10;
4000790c: 82 10 20 0a mov 0xa, %g1
reswitch: switch (ch = (u_char)*fmt++) {
40007910: c4 3f bf b0 std %g2, [ %fp + -80 ]
base = 10;
40007914: 10 bf ff ca b 4000783c <_IO_Vprintf+0x3dc>
40007918: c2 27 bf bc st %g1, [ %fp + -68 ]
if (hflag) {
4000791c: 80 a3 e0 00 cmp %o7, 0
<== NOT EXECUTED
40007920: 12 80 01 55 bne 40007e74 <_IO_Vprintf+0xa14>
<== NOT EXECUTED
40007924: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
hflag = 1;
40007928: 9e 10 20 01 mov 1, %o7
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
4000792c: 10 bf ff 03 b 40007538 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
40007930: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
40007934: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
jflag = 1;
40007938: a8 10 20 01 mov 1, %l4
<== NOT EXECUTED
goto reswitch;
4000793c: 10 bf fe ff b 40007538 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
40007940: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
40007944: 84 10 20 00 clr %g2
40007948: 86 10 20 10 mov 0x10, %g3
base = 16;
4000794c: 82 10 20 10 mov 0x10, %g1
reswitch: switch (ch = (u_char)*fmt++) {
40007950: c4 3f bf b0 std %g2, [ %fp + -80 ]
upper = 1;
40007954: ba 10 20 01 mov 1, %i5
base = 16;
40007958: 10 bf ff 18 b 400075b8 <_IO_Vprintf+0x158>
4000795c: c2 27 bf bc st %g1, [ %fp + -68 ]
reswitch: switch (ch = (u_char)*fmt++) {
40007960: 84 10 20 00 clr %g2
40007964: 86 10 20 0a mov 0xa, %g3
base = 10;
40007968: 82 10 20 0a mov 0xa, %g1
reswitch: switch (ch = (u_char)*fmt++) {
4000796c: c4 3f bf b0 std %g2, [ %fp + -80 ]
sign = 0; dot = 0; dwidth = 0; upper = 0;
40007970: ba 10 20 00 clr %i5
base = 10;
40007974: 10 bf ff 11 b 400075b8 <_IO_Vprintf+0x158>
40007978: c2 27 bf bc st %g1, [ %fp + -68 ]
4000797c: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
dot = 1;
40007980: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
40007984: 10 bf fe ed b 40007538 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
40007988: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
ch = *fmt;
4000798c: c6 48 60 01 ldsb [ %g1 + 1 ], %g3
if (ch < '0' || ch > '9')
40007990: 84 00 ff d0 add %g3, -48, %g2
n = n * 10 + ch - '0';
40007994: 90 02 3f d0 add %o0, -48, %o0
if (ch < '0' || ch > '9')
40007998: 80 a0 a0 09 cmp %g2, 9
4000799c: 18 80 00 d4 bgu 40007cec <_IO_Vprintf+0x88c>
<== ALWAYS TAKEN
400079a0: d8 08 60 01 ldub [ %g1 + 1 ], %o4
reswitch: switch (ch = (u_char)*fmt++) {
400079a4: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
for (n = 0;; ++fmt) {
400079a8: 82 00 60 01 inc %g1
<== NOT EXECUTED
n = n * 10 + ch - '0';
400079ac: 85 2a 20 02 sll %o0, 2, %g2
<== NOT EXECUTED
400079b0: 84 00 80 08 add %g2, %o0, %g2
<== NOT EXECUTED
400079b4: 85 28 a0 01 sll %g2, 1, %g2
<== NOT EXECUTED
400079b8: 84 00 80 03 add %g2, %g3, %g2
<== NOT EXECUTED
ch = *fmt;
400079bc: c6 48 40 00 ldsb [ %g1 ], %g3
<== NOT EXECUTED
if (ch < '0' || ch > '9')
400079c0: b4 00 ff d0 add %g3, -48, %i2
<== NOT EXECUTED
n = n * 10 + ch - '0';
400079c4: 90 00 bf d0 add %g2, -48, %o0
<== NOT EXECUTED
if (ch < '0' || ch > '9')
400079c8: 80 a6 a0 09 cmp %i2, 9
<== NOT EXECUTED
400079cc: 08 bf ff f7 bleu 400079a8 <_IO_Vprintf+0x548>
<== NOT EXECUTED
400079d0: d8 08 40 00 ldub [ %g1 ], %o4
<== NOT EXECUTED
if (dot)
400079d4: 80 a2 e0 00 cmp %o3, 0
400079d8: 22 bf fe d8 be,a 40007538 <_IO_Vprintf+0xd8>
<== ALWAYS TAKEN
400079dc: d0 27 bf d4 st %o0, [ %fp + -44 ]
400079e0: 10 bf fe d6 b 40007538 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
400079e4: d0 27 bf d0 st %o0, [ %fp + -48 ]
<== NOT EXECUTED
if (!width)
400079e8: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
up = va_arg(ap, u_char *);
400079ec: e0 06 c0 00 ld [ %i3 ], %l0
<== NOT EXECUTED
p = va_arg(ap, char *);
400079f0: e2 06 e0 04 ld [ %i3 + 4 ], %l1
<== NOT EXECUTED
if (!width)
400079f4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400079f8: 12 80 00 04 bne 40007a08 <_IO_Vprintf+0x5a8>
<== NOT EXECUTED
400079fc: b6 06 e0 08 add %i3, 8, %i3
<== NOT EXECUTED
width = 16;
40007a00: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
40007a04: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
40007a08: 82 04 3f ff add %l0, -1, %g1
<== NOT EXECUTED
40007a0c: c4 07 bf d4 ld [ %fp + -44 ], %g2
<== NOT EXECUTED
for (q=p;*q;q++)
40007a10: a8 10 00 15 mov %l5, %l4
<== NOT EXECUTED
40007a14: a4 04 00 02 add %l0, %g2, %l2
<== NOT EXECUTED
40007a18: a6 00 40 02 add %g1, %g2, %l3
<== NOT EXECUTED
while(width--) {
40007a1c: 80 a4 80 10 cmp %l2, %l0
<== NOT EXECUTED
40007a20: 22 bf fe 9a be,a 40007488 <_IO_Vprintf+0x28>
<== NOT EXECUTED
40007a24: a4 10 20 00 clr %l2
<== NOT EXECUTED
PCHAR(hex2ascii(*up >> 4));
40007a28: c2 0c 00 00 ldub [ %l0 ], %g1
<== NOT EXECUTED
40007a2c: 83 30 60 04 srl %g1, 4, %g1
<== NOT EXECUTED
40007a30: d0 4d c0 01 ldsb [ %l7 + %g1 ], %o0
<== NOT EXECUTED
40007a34: 9f c7 00 00 call %i4
<== NOT EXECUTED
40007a38: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
PCHAR(hex2ascii(*up & 0x0f));
40007a3c: c2 0c 00 00 ldub [ %l0 ], %g1
<== NOT EXECUTED
40007a40: 82 08 60 0f and %g1, 0xf, %g1
<== NOT EXECUTED
40007a44: d0 4d c0 01 ldsb [ %l7 + %g1 ], %o0
<== NOT EXECUTED
40007a48: 9f c7 00 00 call %i4
<== NOT EXECUTED
40007a4c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
if (width)
40007a50: 80 a4 c0 10 cmp %l3, %l0
<== NOT EXECUTED
40007a54: 02 80 00 c0 be 40007d54 <_IO_Vprintf+0x8f4>
<== NOT EXECUTED
40007a58: a8 05 20 02 add %l4, 2, %l4
<== NOT EXECUTED
for (q=p;*q;q++)
40007a5c: d0 0c 40 00 ldub [ %l1 ], %o0
<== NOT EXECUTED
40007a60: 91 2a 20 18 sll %o0, 0x18, %o0
<== NOT EXECUTED
40007a64: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40007a68: 22 bf ff ed be,a 40007a1c <_IO_Vprintf+0x5bc>
<== NOT EXECUTED
40007a6c: a0 04 20 01 inc %l0
<== NOT EXECUTED
40007a70: ba 10 00 11 mov %l1, %i5
<== NOT EXECUTED
PCHAR(*q);
40007a74: 91 3a 20 18 sra %o0, 0x18, %o0
<== NOT EXECUTED
40007a78: 9f c7 00 00 call %i4
<== NOT EXECUTED
40007a7c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
for (q=p;*q;q++)
40007a80: ba 07 60 01 inc %i5
<== NOT EXECUTED
40007a84: d0 0f 40 00 ldub [ %i5 ], %o0
<== NOT EXECUTED
40007a88: 91 2a 20 18 sll %o0, 0x18, %o0
<== NOT EXECUTED
40007a8c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40007a90: 12 bf ff f9 bne 40007a74 <_IO_Vprintf+0x614>
<== NOT EXECUTED
40007a94: a8 05 20 01 inc %l4
<== NOT EXECUTED
40007a98: 10 bf ff e1 b 40007a1c <_IO_Vprintf+0x5bc>
<== NOT EXECUTED
40007a9c: a0 04 20 01 inc %l0
<== NOT EXECUTED
if (lflag) {
40007aa0: 80 a1 20 00 cmp %g4, 0
40007aa4: 02 bf fe b3 be 40007570 <_IO_Vprintf+0x110>
40007aa8: d8 08 60 01 ldub [ %g1 + 1 ], %o4
jflag = 1;
40007aac: a8 10 00 04 mov %g4, %l4
reswitch: switch (ch = (u_char)*fmt++) {
40007ab0: 10 bf fe a2 b 40007538 <_IO_Vprintf+0xd8>
40007ab4: 82 10 00 1a mov %i2, %g1
40007ab8: 84 10 20 00 clr %g2
<== NOT EXECUTED
40007abc: 86 10 20 08 mov 8, %g3
<== NOT EXECUTED
base = 8;
40007ac0: 82 10 20 08 mov 8, %g1
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
40007ac4: c4 3f bf b0 std %g2, [ %fp + -80 ]
<== NOT EXECUTED
sign = 0; dot = 0; dwidth = 0; upper = 0;
40007ac8: ba 10 20 00 clr %i5
<== NOT EXECUTED
base = 8;
40007acc: 10 bf fe bb b 400075b8 <_IO_Vprintf+0x158>
<== NOT EXECUTED
40007ad0: c2 27 bf bc st %g1, [ %fp + -68 ]
<== NOT EXECUTED
sharpflag = (width == 0);
40007ad4: c4 07 bf d4 ld [ %fp + -44 ], %g2
num = (uintptr_t)va_arg(ap, void *);
40007ad8: c2 06 c0 00 ld [ %i3 ], %g1
sharpflag = (width == 0);
40007adc: 80 a0 00 02 cmp %g0, %g2
40007ae0: 84 60 3f ff subx %g0, -1, %g2
num = (uintptr_t)va_arg(ap, void *);
40007ae4: 86 10 00 01 mov %g1, %g3
sharpflag = (width == 0);
40007ae8: c4 27 bf c4 st %g2, [ %fp + -60 ]
num = (uintptr_t)va_arg(ap, void *);
40007aec: 84 10 20 00 clr %g2
base = 16;
40007af0: 82 10 20 10 mov 0x10, %g1
num = (uintptr_t)va_arg(ap, void *);
40007af4: c4 3f bf c8 std %g2, [ %fp + -56 ]
40007af8: b6 06 e0 04 add %i3, 4, %i3
goto number;
40007afc: 84 10 20 00 clr %g2
40007b00: 86 10 20 10 mov 0x10, %g3
sign = 0; dot = 0; dwidth = 0; upper = 0;
40007b04: ba 10 20 00 clr %i5
goto number;
40007b08: c4 3f bf b0 std %g2, [ %fp + -80 ]
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
40007b0c: a8 10 20 00 clr %l4
goto number;
40007b10: 10 bf fe b5 b 400075e4 <_IO_Vprintf+0x184>
40007b14: c2 27 bf bc st %g1, [ %fp + -68 ]
p = va_arg(ap, char *);
40007b18: fa 06 c0 00 ld [ %i3 ], %i5
if (p == NULL)
40007b1c: 80 a7 60 00 cmp %i5, 0
40007b20: 02 80 00 fd be 40007f14 <_IO_Vprintf+0xab4>
<== NEVER TAKEN
40007b24: b6 06 e0 04 add %i3, 4, %i3
if (!dot)
40007b28: 80 a2 e0 00 cmp %o3, 0
40007b2c: 12 80 00 db bne 40007e98 <_IO_Vprintf+0xa38>
<== NEVER TAKEN
40007b30: c2 07 bf d0 ld [ %fp + -48 ], %g1
n = strlen (p);
40007b34: 40 00 1c 68 call 4000ecd4 <strlen>
40007b38: 90 10 00 1d mov %i5, %o0
40007b3c: a2 10 00 08 mov %o0, %l1
width -= n;
40007b40: c2 07 bf d4 ld [ %fp + -44 ], %g1
40007b44: 84 20 40 11 sub %g1, %l1, %g2
40007b48: c4 27 bf d4 st %g2, [ %fp + -44 ]
if (!ladjust && width > 0)
40007b4c: a1 38 a0 1f sra %g2, 0x1f, %l0
40007b50: 82 0c a0 01 and %l2, 1, %g1
40007b54: a0 24 00 02 sub %l0, %g2, %l0
40007b58: a8 04 7f ff add %l1, -1, %l4
40007b5c: 80 8c a0 01 btst 1, %l2
40007b60: 12 80 00 c9 bne 40007e84 <_IO_Vprintf+0xa24>
<== NEVER TAKEN
40007b64: a1 34 20 1f srl %l0, 0x1f, %l0
40007b68: 80 a4 20 00 cmp %l0, 0
40007b6c: 02 80 00 c7 be 40007e88 <_IO_Vprintf+0xa28>
<== ALWAYS TAKEN
40007b70: 80 a4 60 00 cmp %l1, 0
while (width--)
40007b74: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
40007b78: a6 00 7f ff add %g1, -1, %l3
<== NOT EXECUTED
40007b7c: c2 0f bf c3 ldub [ %fp + -61 ], %g1
<== NOT EXECUTED
40007b80: a5 28 60 18 sll %g1, 0x18, %l2
<== NOT EXECUTED
40007b84: a0 10 00 13 mov %l3, %l0
<== NOT EXECUTED
40007b88: a5 3c a0 18 sra %l2, 0x18, %l2
<== NOT EXECUTED
PCHAR(padc);
40007b8c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40007b90: 9f c7 00 00 call %i4
<== NOT EXECUTED
40007b94: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
while (width--)
40007b98: a0 04 3f ff add %l0, -1, %l0
<== NOT EXECUTED
40007b9c: 80 a4 3f ff cmp %l0, -1
<== NOT EXECUTED
40007ba0: 12 bf ff fc bne 40007b90 <_IO_Vprintf+0x730>
<== NOT EXECUTED
40007ba4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40007ba8: 84 05 60 01 add %l5, 1, %g2
<== NOT EXECUTED
while (n--)
40007bac: 80 a4 60 00 cmp %l1, 0
<== NOT EXECUTED
40007bb0: 02 80 00 fa be 40007f98 <_IO_Vprintf+0xb38>
<== NOT EXECUTED
40007bb4: aa 00 80 13 add %g2, %l3, %l5
<== NOT EXECUTED
40007bb8: 82 10 3f ff mov -1, %g1
<== NOT EXECUTED
40007bbc: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
40007bc0: a0 10 20 00 clr %l0
<== NOT EXECUTED
40007bc4: a2 05 20 01 add %l4, 1, %l1
40007bc8: a2 07 40 11 add %i5, %l1, %l1
PCHAR(*p++);
40007bcc: ba 07 60 01 inc %i5
40007bd0: d0 4f 7f ff ldsb [ %i5 + -1 ], %o0
40007bd4: 9f c7 00 00 call %i4
40007bd8: 92 10 00 19 mov %i1, %o1
while (n--)
40007bdc: 80 a7 40 11 cmp %i5, %l1
40007be0: 32 bf ff fc bne,a 40007bd0 <_IO_Vprintf+0x770>
40007be4: ba 07 60 01 inc %i5
40007be8: 84 05 60 01 add %l5, 1, %g2
40007bec: a8 05 00 02 add %l4, %g2, %l4
if (ladjust && width > 0)
40007bf0: 80 8c 20 ff btst 0xff, %l0
40007bf4: 02 bf fe 25 be 40007488 <_IO_Vprintf+0x28>
<== ALWAYS TAKEN
40007bf8: a4 10 20 00 clr %l2
while (width--)
40007bfc: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
40007c00: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40007c04: 02 bf fe 21 be 40007488 <_IO_Vprintf+0x28>
<== NOT EXECUTED
40007c08: a2 00 7f ff add %g1, -1, %l1
<== NOT EXECUTED
40007c0c: c2 0f bf c3 ldub [ %fp + -61 ], %g1
<== NOT EXECUTED
40007c10: a1 28 60 18 sll %g1, 0x18, %l0
<== NOT EXECUTED
40007c14: ba 10 00 11 mov %l1, %i5
<== NOT EXECUTED
40007c18: a1 3c 20 18 sra %l0, 0x18, %l0
<== NOT EXECUTED
PCHAR(padc);
40007c1c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40007c20: 9f c7 00 00 call %i4
<== NOT EXECUTED
40007c24: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
while (width--)
40007c28: ba 07 7f ff add %i5, -1, %i5
<== NOT EXECUTED
40007c2c: 80 a7 7f ff cmp %i5, -1
<== NOT EXECUTED
40007c30: 12 bf ff fc bne 40007c20 <_IO_Vprintf+0x7c0>
<== NOT EXECUTED
40007c34: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40007c38: a8 05 20 01 inc %l4
<== NOT EXECUTED
40007c3c: a4 10 20 00 clr %l2
<== NOT EXECUTED
40007c40: 10 bf fe 12 b 40007488 <_IO_Vprintf+0x28>
<== NOT EXECUTED
40007c44: a8 04 40 14 add %l1, %l4, %l4
<== NOT EXECUTED
40007c48: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
sharpflag = 1;
40007c4c: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
40007c50: c2 27 bf c4 st %g1, [ %fp + -60 ]
<== NOT EXECUTED
goto reswitch;
40007c54: 10 bf fe 39 b 40007538 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
40007c58: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
PCHAR(ch);
40007c5c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40007c60: 9f c7 00 00 call %i4
<== NOT EXECUTED
40007c64: a8 05 60 01 add %l5, 1, %l4
<== NOT EXECUTED
break;
40007c68: 10 bf fe 08 b 40007488 <_IO_Vprintf+0x28>
<== NOT EXECUTED
40007c6c: a4 10 20 00 clr %l2
<== NOT EXECUTED
40007c70: 84 06 e0 04 add %i3, 4, %g2
<== NOT EXECUTED
if (!dot) {
40007c74: 80 a2 e0 00 cmp %o3, 0
<== NOT EXECUTED
40007c78: 12 80 00 76 bne 40007e50 <_IO_Vprintf+0x9f0>
<== NOT EXECUTED
40007c7c: c6 06 c0 00 ld [ %i3 ], %g3
<== NOT EXECUTED
if (width < 0) {
40007c80: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40007c84: 06 80 00 af bl 40007f40 <_IO_Vprintf+0xae0>
<== NOT EXECUTED
40007c88: c6 27 bf d4 st %g3, [ %fp + -44 ]
<== NOT EXECUTED
40007c8c: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
dwidth = va_arg(ap, int);
40007c90: b6 10 00 02 mov %g2, %i3
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
40007c94: 10 bf fe 29 b 40007538 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
40007c98: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
40007c9c: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
ladjust = 1;
40007ca0: a4 10 20 01 mov 1, %l2
<== NOT EXECUTED
goto reswitch;
40007ca4: 10 bf fe 25 b 40007538 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
40007ca8: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
while (percent < fmt)
40007cac: a0 10 00 1d mov %i5, %l0
<== NOT EXECUTED
40007cb0: a8 10 00 15 mov %l5, %l4
<== NOT EXECUTED
40007cb4: 80 a6 80 1d cmp %i2, %i5
<== NOT EXECUTED
40007cb8: 08 bf fd f4 bleu 40007488 <_IO_Vprintf+0x28>
<== NOT EXECUTED
40007cbc: a4 10 20 01 mov 1, %l2
<== NOT EXECUTED
PCHAR(*percent++);
40007cc0: a0 04 20 01 inc %l0
<== NOT EXECUTED
40007cc4: d0 4c 3f ff ldsb [ %l0 + -1 ], %o0
<== NOT EXECUTED
40007cc8: 9f c7 00 00 call %i4
<== NOT EXECUTED
40007ccc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
while (percent < fmt)
40007cd0: 80 a6 80 10 cmp %i2, %l0
<== NOT EXECUTED
40007cd4: 32 bf ff fc bne,a 40007cc4 <_IO_Vprintf+0x864>
<== NOT EXECUTED
40007cd8: a0 04 20 01 inc %l0
<== NOT EXECUTED
40007cdc: 84 25 40 1d sub %l5, %i5, %g2
<== NOT EXECUTED
stop = 1;
40007ce0: a4 10 20 01 mov 1, %l2
<== NOT EXECUTED
40007ce4: 10 bf fd e9 b 40007488 <_IO_Vprintf+0x28>
<== NOT EXECUTED
40007ce8: a8 06 80 02 add %i2, %g2, %l4
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
40007cec: 10 bf ff 3a b 400079d4 <_IO_Vprintf+0x574>
40007cf0: 82 10 00 1a mov %i2, %g1
static inline int imax(int a, int b) { return (a > b ? a : b); }
40007cf4: c4 07 bf d0 ld [ %fp + -48 ], %g2
40007cf8: 80 a0 80 11 cmp %g2, %l1
40007cfc: 16 80 00 04 bge 40007d0c <_IO_Vprintf+0x8ac>
<== NEVER TAKEN
40007d00: 86 10 00 02 mov %g2, %g3
40007d04: 86 10 00 11 mov %l1, %g3
dwidth -= n;
40007d08: c4 07 bf d0 ld [ %fp + -48 ], %g2
40007d0c: a2 20 80 11 sub %g2, %l1, %l1
width -= tmp + imax(dwidth, n);
40007d10: c4 07 bf d4 ld [ %fp + -44 ], %g2
40007d14: 82 00 c0 01 add %g3, %g1, %g1
if (!ladjust)
40007d18: 80 a4 a0 00 cmp %l2, 0
40007d1c: 12 bf fe 86 bne 40007734 <_IO_Vprintf+0x2d4>
<== NEVER TAKEN
40007d20: a6 20 80 01 sub %g2, %g1, %l3
while (width-- > 0)
40007d24: 10 bf fe 78 b 40007704 <_IO_Vprintf+0x2a4>
40007d28: ac 04 ff ff add %l3, -1, %l6
else if (lflag)
40007d2c: 12 80 00 0c bne 40007d5c <_IO_Vprintf+0x8fc>
40007d30: 82 06 e0 04 add %i3, 4, %g1
else if (hflag)
40007d34: 80 a3 e0 00 cmp %o7, 0
40007d38: 02 80 00 48 be 40007e58 <_IO_Vprintf+0x9f8>
<== ALWAYS TAKEN
40007d3c: 80 a3 60 00 cmp %o5, 0
num = (u_short)va_arg(ap, int);
40007d40: c6 16 e0 02 lduh [ %i3 + 2 ], %g3
<== NOT EXECUTED
40007d44: 84 10 20 00 clr %g2
<== NOT EXECUTED
40007d48: b6 10 00 01 mov %g1, %i3
<== NOT EXECUTED
40007d4c: 10 bf fe 26 b 400075e4 <_IO_Vprintf+0x184>
<== NOT EXECUTED
40007d50: c4 3f bf c8 std %g2, [ %fp + -56 ]
<== NOT EXECUTED
while (width-- > 0)
40007d54: 10 bf fd cd b 40007488 <_IO_Vprintf+0x28>
<== NOT EXECUTED
40007d58: a4 10 20 00 clr %l2
<== NOT EXECUTED
num = va_arg(ap, u_int);
40007d5c: c6 06 c0 00 ld [ %i3 ], %g3
40007d60: 84 10 20 00 clr %g2
40007d64: b6 10 00 01 mov %g1, %i3
40007d68: 10 bf fe 1f b 400075e4 <_IO_Vprintf+0x184>
40007d6c: c4 3f bf c8 std %g2, [ %fp + -56 ]
40007d70: 10 bf fe 77 b 4000774c <_IO_Vprintf+0x2ec>
40007d74: a8 10 00 15 mov %l5, %l4
else if (tflag)
40007d78: 80 a1 20 00 cmp %g4, 0
40007d7c: 12 80 00 17 bne 40007dd8 <_IO_Vprintf+0x978>
40007d80: c6 06 c0 00 ld [ %i3 ], %g3
else if (hflag)
40007d84: 80 a3 e0 00 cmp %o7, 0
40007d88: 02 80 00 66 be 40007f20 <_IO_Vprintf+0xac0>
<== ALWAYS TAKEN
40007d8c: 80 a3 60 00 cmp %o5, 0
num = (short)va_arg(ap, int);
40007d90: 87 28 e0 10 sll %g3, 0x10, %g3
<== NOT EXECUTED
40007d94: b6 10 00 01 mov %g1, %i3
<== NOT EXECUTED
40007d98: 83 38 e0 10 sra %g3, 0x10, %g1
<== NOT EXECUTED
40007d9c: c2 27 bf cc st %g1, [ %fp + -52 ]
<== NOT EXECUTED
40007da0: 83 38 e0 1f sra %g3, 0x1f, %g1
<== NOT EXECUTED
40007da4: 10 bf fe b0 b 40007864 <_IO_Vprintf+0x404>
<== NOT EXECUTED
40007da8: c2 27 bf c8 st %g1, [ %fp + -56 ]
<== NOT EXECUTED
} else if (base == 16) {
40007dac: 80 a0 60 10 cmp %g1, 0x10
40007db0: 32 bf fe 73 bne,a 4000777c <_IO_Vprintf+0x31c>
<== NEVER TAKEN
40007db4: 80 a4 60 00 cmp %l1, 0
<== NOT EXECUTED
PCHAR('0');
40007db8: 9f c7 00 00 call %i4
40007dbc: 90 10 20 30 mov 0x30, %o0
PCHAR('x');
40007dc0: 92 10 00 19 mov %i1, %o1
40007dc4: 90 10 20 78 mov 0x78, %o0
40007dc8: 9f c7 00 00 call %i4
40007dcc: a8 05 20 02 add %l4, 2, %l4
while (dwidth-- > 0)
40007dd0: 10 bf fe 6b b 4000777c <_IO_Vprintf+0x31c>
40007dd4: 80 a4 60 00 cmp %l1, 0
num = va_arg(ap, int);
40007dd8: b6 10 00 01 mov %g1, %i3
40007ddc: c6 27 bf cc st %g3, [ %fp + -52 ]
40007de0: 83 38 e0 1f sra %g3, 0x1f, %g1
40007de4: 10 bf fe a0 b 40007864 <_IO_Vprintf+0x404>
40007de8: c2 27 bf c8 st %g1, [ %fp + -56 ]
PCHAR(va_arg(ap, int));
40007dec: d0 06 c0 00 ld [ %i3 ], %o0
40007df0: 9f c7 00 00 call %i4
40007df4: 92 10 00 19 mov %i1, %o1
if (ladjust && width > 0)
40007df8: 80 8c a0 01 btst 1, %l2
40007dfc: 02 80 00 3b be 40007ee8 <_IO_Vprintf+0xa88>
<== ALWAYS TAKEN
40007e00: 80 8f 60 ff btst 0xff, %i5
40007e04: 02 80 00 39 be 40007ee8 <_IO_Vprintf+0xa88>
<== NOT EXECUTED
40007e08: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
while (width--)
40007e0c: a8 00 7f fe add %g1, -2, %l4
<== NOT EXECUTED
40007e10: c2 0f bf c3 ldub [ %fp + -61 ], %g1
<== NOT EXECUTED
40007e14: b7 28 60 18 sll %g1, 0x18, %i3
<== NOT EXECUTED
40007e18: ba 10 00 14 mov %l4, %i5
<== NOT EXECUTED
40007e1c: b7 3e e0 18 sra %i3, 0x18, %i3
<== NOT EXECUTED
PCHAR(padc);
40007e20: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40007e24: 9f c7 00 00 call %i4
<== NOT EXECUTED
40007e28: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
while (width--)
40007e2c: ba 07 7f ff add %i5, -1, %i5
<== NOT EXECUTED
40007e30: 80 a7 7f ff cmp %i5, -1
<== NOT EXECUTED
40007e34: 12 bf ff fc bne 40007e24 <_IO_Vprintf+0x9c4>
<== NOT EXECUTED
40007e38: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40007e3c: 84 05 60 02 add %l5, 2, %g2
<== NOT EXECUTED
PCHAR(va_arg(ap, int));
40007e40: b6 10 00 10 mov %l0, %i3
<== NOT EXECUTED
40007e44: a8 05 00 02 add %l4, %g2, %l4
<== NOT EXECUTED
while (width--)
40007e48: 10 bf fd 90 b 40007488 <_IO_Vprintf+0x28>
<== NOT EXECUTED
40007e4c: a4 10 20 00 clr %l2
<== NOT EXECUTED
dwidth = va_arg(ap, int);
40007e50: 10 bf ff 8f b 40007c8c <_IO_Vprintf+0x82c>
<== NOT EXECUTED
40007e54: c6 27 bf d0 st %g3, [ %fp + -48 ]
<== NOT EXECUTED
else if (cflag)
40007e58: 22 bf ff c2 be,a 40007d60 <_IO_Vprintf+0x900>
<== ALWAYS TAKEN
40007e5c: c6 06 c0 00 ld [ %i3 ], %g3
num = (u_char)va_arg(ap, int);
40007e60: c6 0e e0 03 ldub [ %i3 + 3 ], %g3
<== NOT EXECUTED
40007e64: 84 10 20 00 clr %g2
<== NOT EXECUTED
40007e68: b6 10 00 01 mov %g1, %i3
<== NOT EXECUTED
40007e6c: 10 bf fd de b 400075e4 <_IO_Vprintf+0x184>
<== NOT EXECUTED
40007e70: c4 3f bf c8 std %g2, [ %fp + -56 ]
<== NOT EXECUTED
cflag = 1;
40007e74: 9a 10 00 0f mov %o7, %o5
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
40007e78: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
hflag = 0;
40007e7c: 10 bf fd af b 40007538 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
40007e80: 9e 10 20 00 clr %o7
<== NOT EXECUTED
while (n--)
40007e84: 80 a4 60 00 cmp %l1, 0
<== NOT EXECUTED
40007e88: 12 bf ff 4f bne 40007bc4 <_IO_Vprintf+0x764>
<== ALWAYS TAKEN
40007e8c: a0 0c 00 01 and %l0, %g1, %l0
40007e90: 10 bf ff 58 b 40007bf0 <_IO_Vprintf+0x790>
<== NOT EXECUTED
40007e94: a8 10 00 15 mov %l5, %l4
<== NOT EXECUTED
for (n = 0; n < dwidth && p[n]; n++)
40007e98: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40007e9c: 04 80 00 06 ble 40007eb4 <_IO_Vprintf+0xa54>
<== NOT EXECUTED
40007ea0: c4 07 bf d4 ld [ %fp + -44 ], %g2
<== NOT EXECUTED
40007ea4: c2 4f 40 00 ldsb [ %i5 ], %g1
<== NOT EXECUTED
40007ea8: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40007eac: 12 80 00 2d bne 40007f60 <_IO_Vprintf+0xb00>
<== NOT EXECUTED
40007eb0: a2 10 20 00 clr %l1
<== NOT EXECUTED
if (!ladjust && width > 0)
40007eb4: a1 38 a0 1f sra %g2, 0x1f, %l0
<== NOT EXECUTED
40007eb8: 82 0c a0 01 and %l2, 1, %g1
<== NOT EXECUTED
40007ebc: a0 24 00 02 sub %l0, %g2, %l0
<== NOT EXECUTED
40007ec0: 80 8c a0 01 btst 1, %l2
<== NOT EXECUTED
40007ec4: 12 80 00 06 bne 40007edc <_IO_Vprintf+0xa7c>
<== NOT EXECUTED
40007ec8: a1 34 20 1f srl %l0, 0x1f, %l0
<== NOT EXECUTED
40007ecc: a8 10 3f ff mov -1, %l4
<== NOT EXECUTED
40007ed0: 80 a4 20 00 cmp %l0, 0
<== NOT EXECUTED
40007ed4: 12 bf ff 28 bne 40007b74 <_IO_Vprintf+0x714>
<== NOT EXECUTED
40007ed8: a2 10 20 00 clr %l1
<== NOT EXECUTED
40007edc: a0 0c 00 01 and %l0, %g1, %l0
<== NOT EXECUTED
40007ee0: 10 bf ff 44 b 40007bf0 <_IO_Vprintf+0x790>
<== NOT EXECUTED
40007ee4: a8 10 00 15 mov %l5, %l4
<== NOT EXECUTED
PCHAR(va_arg(ap, int));
40007ee8: b6 10 00 10 mov %l0, %i3
40007eec: 10 bf fd 67 b 40007488 <_IO_Vprintf+0x28>
40007ef0: a4 10 20 00 clr %l2
if (ch < '0' || ch > '9')
40007ef4: 84 00 ff d0 add %g3, -48, %g2
<== NOT EXECUTED
n = n * 10 + ch - '0';
40007ef8: 90 02 3f d0 add %o0, -48, %o0
<== NOT EXECUTED
if (ch < '0' || ch > '9')
40007efc: 80 a0 a0 09 cmp %g2, 9
<== NOT EXECUTED
40007f00: 08 bf fe a9 bleu 400079a4 <_IO_Vprintf+0x544>
<== NOT EXECUTED
40007f04: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
n = n * 10 + ch - '0';
40007f08: d0 27 bf d0 st %o0, [ %fp + -48 ]
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
40007f0c: 10 bf fd 8b b 40007538 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
40007f10: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
p = "(null)";
40007f14: 3b 10 00 41 sethi %hi(0x40010400), %i5
<== NOT EXECUTED
40007f18: 10 bf ff 04 b 40007b28 <_IO_Vprintf+0x6c8>
<== NOT EXECUTED
40007f1c: ba 17 63 f8 or %i5, 0x3f8, %i5 ! 400107f8 <_Objects_Information_table+0x34>
<== NOT EXECUTED
else if (cflag)
40007f20: 02 bf ff af be 40007ddc <_IO_Vprintf+0x97c>
<== ALWAYS TAKEN
40007f24: b6 10 00 01 mov %g1, %i3
num = (char)va_arg(ap, int);
40007f28: 87 28 e0 18 sll %g3, 0x18, %g3
<== NOT EXECUTED
40007f2c: 83 38 e0 18 sra %g3, 0x18, %g1
<== NOT EXECUTED
40007f30: c2 27 bf cc st %g1, [ %fp + -52 ]
<== NOT EXECUTED
40007f34: 83 38 e0 1f sra %g3, 0x1f, %g1
<== NOT EXECUTED
40007f38: 10 bf fe 4b b 40007864 <_IO_Vprintf+0x404>
<== NOT EXECUTED
40007f3c: c2 27 bf c8 st %g1, [ %fp + -56 ]
<== NOT EXECUTED
40007f40: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
width = -width;
40007f44: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
40007f48: 82 20 00 01 neg %g1
<== NOT EXECUTED
40007f4c: a4 1c a0 01 xor %l2, 1, %l2
<== NOT EXECUTED
40007f50: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
width = va_arg(ap, int);
40007f54: b6 10 00 02 mov %g2, %i3
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
40007f58: 10 bf fd 78 b 40007538 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
40007f5c: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
for (n = 0; n < dwidth && p[n]; n++)
40007f60: c2 07 bf d0 ld [ %fp + -48 ], %g1
<== NOT EXECUTED
40007f64: a2 04 60 01 inc %l1
<== NOT EXECUTED
40007f68: 80 a4 40 01 cmp %l1, %g1
<== NOT EXECUTED
40007f6c: 02 bf fe f6 be 40007b44 <_IO_Vprintf+0x6e4>
<== NOT EXECUTED
40007f70: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
40007f74: c2 4f 40 11 ldsb [ %i5 + %l1 ], %g1
<== NOT EXECUTED
40007f78: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40007f7c: 22 bf fe f2 be,a 40007b44 <_IO_Vprintf+0x6e4>
<== NOT EXECUTED
40007f80: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
40007f84: 10 bf ff f8 b 40007f64 <_IO_Vprintf+0xb04>
<== NOT EXECUTED
40007f88: c2 07 bf d0 ld [ %fp + -48 ], %g1
<== NOT EXECUTED
40007f8c: ba 10 20 00 clr %i5
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
40007f90: 10 bf fd 95 b 400075e4 <_IO_Vprintf+0x184>
40007f94: a8 10 20 00 clr %l4
while (n--)
40007f98: a8 10 00 15 mov %l5, %l4
<== NOT EXECUTED
40007f9c: 10 bf fd 3b b 40007488 <_IO_Vprintf+0x28>
<== NOT EXECUTED
40007fa0: a4 10 20 00 clr %l2
<== NOT EXECUTED
40007fb4 <_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 )
{
40007fb4: 9d e3 bf a0 save %sp, -96, %sp
uint32_t cpu_max;
uint32_t cpu_index;
size_t stack_size;
char *stack_low;
_ISR_Nest_level = 0;
40007fb8: 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;
40007fbc: 03 10 00 47 sethi %hi(0x40011c00), %g1
_CPU_Initialize_vectors();
#endif
stack_size = rtems_configuration_get_interrupt_stack_size();
if ( !_Stack_Is_enough( stack_size ) )
40007fc0: c4 00 61 80 ld [ %g1 + 0x180 ], %g2 ! 40011d80 <_data_load_start>
stack_size = rtems_configuration_get_interrupt_stack_size();
40007fc4: 03 00 00 04 sethi %hi(0x1000), %g1
40007fc8: 82 10 60 00 mov %g1, %g1 ! 1000 <_Configuration_Interrupt_stack_size>
if ( !_Stack_Is_enough( stack_size ) )
40007fcc: 80 a0 40 02 cmp %g1, %g2
40007fd0: 0a 80 00 0a bcs 40007ff8 <_ISR_Handler_initialization+0x44>
<== NEVER TAKEN
40007fd4: 05 10 00 4e sethi %hi(0x40013800), %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;
40007fd8: 07 10 00 43 sethi %hi(0x40010c00), %g3
40007fdc: 84 10 a1 80 or %g2, 0x180, %g2
40007fe0: 86 10 e1 80 or %g3, 0x180, %g3
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
40007fe4: 82 00 40 03 add %g1, %g3, %g1
40007fe8: c6 20 a0 08 st %g3, [ %g2 + 8 ]
cpu->interrupt_stack_high = stack_high;
40007fec: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
);
#endif
stack_low = stack_high;
}
}
40007ff0: 81 c7 e0 08 ret
40007ff4: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL );
40007ff8: 7f ff fc bd call 400072ec <_Internal_error>
<== NOT EXECUTED
40007ffc: 90 10 20 04 mov 4, %o0
<== NOT EXECUTED
40008000: 01 00 00 00 nop
<== NOT EXECUTED
400072ec <_Internal_error>:
/* will not return from this routine */
while (true);
}
void _Internal_error( Internal_errors_Core_list core_error )
{
400072ec: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_Terminate( INTERNAL_ERROR_CORE, core_error );
400072f0: 90 10 20 00 clr %o0
<== NOT EXECUTED
400072f4: 7f ff ff eb call 400072a0 <_Terminate>
<== NOT EXECUTED
400072f8: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
400072fc: 01 00 00 00 nop
<== NOT EXECUTED
40011398 <_Mutex_Acquire>:
);
}
}
void _Mutex_Acquire( struct _Mutex_Control *_mutex )
{
40011398: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001139c: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
400113a0: 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 ) ) {
400113a4: c4 06 20 0c ld [ %i0 + 0xc ], %g2
400113a8: 80 a0 a0 00 cmp %g2, 0
400113ac: 12 80 00 07 bne 400113c8 <_Mutex_Acquire+0x30>
<== NEVER TAKEN
400113b0: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
<== NOT EXECUTED
mutex->Queue.Queue.owner = executing;
400113b4: d4 26 20 0c st %o2, [ %i0 + 0xc ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400113b8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400113bc: 01 00 00 00 nop
400113c0: 81 c7 e0 08 ret
400113c4: 81 e8 00 00 restore
queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;
400113c8: 03 10 00 4f sethi %hi(0x40013c00), %g1
<== NOT EXECUTED
400113cc: 82 10 60 d4 or %g1, 0xd4, %g1 ! 40013cd4 <_Thread_queue_Enqueue_do_nothing_extra>
<== NOT EXECUTED
400113d0: c2 27 bf e4 st %g1, [ %fp + -28 ]
<== NOT EXECUTED
queue_context->thread_state = thread_state;
400113d4: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
400113d8: c2 27 bf e0 st %g1, [ %fp + -32 ]
<== NOT EXECUTED
queue_context->deadlock_callout = deadlock_callout;
400113dc: 03 10 00 4f sethi %hi(0x40013c00), %g1
<== NOT EXECUTED
400113e0: 82 10 60 ec or %g1, 0xec, %g1 ! 40013cec <_Thread_queue_Deadlock_fatal>
<== NOT EXECUTED
_Thread_queue_Enqueue(
400113e4: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
400113e8: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
400113ec: 13 10 00 bb sethi %hi(0x4002ec00), %o1
<== NOT EXECUTED
)
{
#if defined( RTEMS_SMP )
context->Lock_context.isr_level = level;
#else
context->isr_level = level;
400113f0: c6 27 bf dc st %g3, [ %fp + -36 ]
<== NOT EXECUTED
400113f4: 92 12 63 5c or %o1, 0x35c, %o1
<== NOT EXECUTED
400113f8: 40 00 0a 41 call 40013cfc <_Thread_queue_Enqueue>
<== NOT EXECUTED
400113fc: 90 06 20 08 add %i0, 8, %o0
<== NOT EXECUTED
_Mutex_Queue_release( mutex, level, &queue_context );
} else {
_Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context );
_Mutex_Acquire_slow( mutex, owner, executing, level, &queue_context );
}
}
40011400: 81 c7 e0 08 ret
<== NOT EXECUTED
40011404: 81 e8 00 00 restore
<== NOT EXECUTED
40011408 <_Mutex_Release>:
return eno;
}
void _Mutex_Release( struct _Mutex_Control *_mutex )
{
40011408: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001140c: 91 d0 20 09 ta 9
<== NOT EXECUTED
executing = _Thread_Executing;
40011410: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
mutex->Queue.Queue.owner = NULL;
40011414: c0 26 20 0c clr [ %i0 + 0xc ]
heads = mutex->Queue.Queue.heads;
40011418: d2 06 20 08 ld [ %i0 + 8 ], %o1
if ( __predict_true( heads == NULL ) ) {
4001141c: 80 a2 60 00 cmp %o1, 0
40011420: 32 80 00 06 bne,a 40011438 <_Mutex_Release+0x30>
<== NEVER TAKEN
40011424: c2 27 bf dc st %g1, [ %fp + -36 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40011428: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001142c: 01 00 00 00 nop
40011430: 81 c7 e0 08 ret
40011434: 81 e8 00 00 restore
_Thread_queue_Surrender(
40011438: 19 10 00 bb sethi %hi(0x4002ec00), %o4
<== NOT EXECUTED
4001143c: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
40011440: 98 13 23 5c or %o4, 0x35c, %o4
<== NOT EXECUTED
40011444: 40 00 0a e5 call 40013fd8 <_Thread_queue_Surrender>
<== NOT EXECUTED
40011448: 90 06 20 08 add %i0, 8, %o0
<== NOT EXECUTED
executing = _Mutex_Queue_acquire_critical( mutex, &queue_context );
_Assert( mutex->Queue.Queue.owner == executing );
_Mutex_Release_critical( mutex, executing, level, &queue_context );
}
4001144c: 81 c7 e0 08 ret
<== NOT EXECUTED
40011450: 81 e8 00 00 restore
<== NOT EXECUTED
400086b8 <_Mutex_recursive_Acquire>:
{
return (Mutex_recursive_Control *) _mutex;
}
void _Mutex_recursive_Acquire( struct _Mutex_recursive_Control *_mutex )
{
400086b8: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400086bc: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
400086c0: 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;
400086c4: c4 06 20 0c ld [ %i0 + 0xc ], %g2
if ( __predict_true( owner == NULL ) ) {
400086c8: 80 a0 a0 00 cmp %g2, 0
400086cc: 12 80 00 07 bne 400086e8 <_Mutex_recursive_Acquire+0x30>
400086d0: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
mutex->Mutex.Queue.Queue.owner = executing;
400086d4: d4 26 20 0c st %o2, [ %i0 + 0xc ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400086d8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400086dc: 01 00 00 00 nop
400086e0: 81 c7 e0 08 ret
400086e4: 81 e8 00 00 restore
_Thread_Resource_count_increment( executing );
_Mutex_Queue_release( &mutex->Mutex, level, &queue_context );
} else if ( owner == executing ) {
400086e8: 80 a2 80 02 cmp %o2, %g2
400086ec: 02 80 00 11 be 40008730 <_Mutex_recursive_Acquire+0x78>
400086f0: 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;
400086f4: 03 10 00 29 sethi %hi(0x4000a400), %g1
400086f8: 82 10 63 ac or %g1, 0x3ac, %g1 ! 4000a7ac <_Thread_queue_Enqueue_do_nothing_extra>
400086fc: c2 27 bf e4 st %g1, [ %fp + -28 ]
queue_context->thread_state = thread_state;
40008700: 82 10 20 01 mov 1, %g1
40008704: 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;
40008708: 03 10 00 29 sethi %hi(0x4000a400), %g1
4000870c: 82 10 63 b4 or %g1, 0x3b4, %g1 ! 4000a7b4 <_Thread_queue_Deadlock_fatal>
40008710: c2 27 bf fc st %g1, [ %fp + -4 ]
_Thread_queue_Enqueue(
40008714: 13 10 00 42 sethi %hi(0x40010800), %o1
)
{
#if defined( RTEMS_SMP )
context->Lock_context.isr_level = level;
#else
context->isr_level = level;
40008718: c6 27 bf dc st %g3, [ %fp + -36 ]
4000871c: 92 12 60 28 or %o1, 0x28, %o1
40008720: 40 00 08 29 call 4000a7c4 <_Thread_queue_Enqueue>
40008724: 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 );
}
}
40008728: 81 c7 e0 08 ret
4000872c: 81 e8 00 00 restore
++mutex->nest_level;
40008730: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
40008734: 84 00 a0 01 inc %g2
<== NOT EXECUTED
40008738: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
<== NOT EXECUTED
4000873c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008740: 01 00 00 00 nop
40008744: 81 c7 e0 08 ret
40008748: 81 e8 00 00 restore
4000874c <_Mutex_recursive_Release>:
return eno;
}
void _Mutex_recursive_Release( struct _Mutex_recursive_Control *_mutex )
{
4000874c: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008750: 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;
40008754: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
if ( __predict_true( nest_level == 0 ) ) {
40008758: 80 a0 a0 00 cmp %g2, 0
4000875c: 12 80 00 0b bne 40008788 <_Mutex_recursive_Release+0x3c>
40008760: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
mutex->Queue.Queue.owner = NULL;
40008764: c0 26 20 0c clr [ %i0 + 0xc ]
heads = mutex->Queue.Queue.heads;
40008768: d2 06 20 08 ld [ %i0 + 8 ], %o1
if ( __predict_true( heads == NULL ) ) {
4000876c: 80 a2 60 00 cmp %o1, 0
40008770: 32 80 00 0c bne,a 400087a0 <_Mutex_recursive_Release+0x54>
40008774: c2 27 bf dc st %g1, [ %fp + -36 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008778: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000877c: 01 00 00 00 nop
} else {
mutex->nest_level = nest_level - 1;
_Mutex_Queue_release( &mutex->Mutex, level, &queue_context );
}
}
40008780: 81 c7 e0 08 ret
40008784: 81 e8 00 00 restore
mutex->nest_level = nest_level - 1;
40008788: 84 00 bf ff add %g2, -1, %g2
<== NOT EXECUTED
4000878c: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
<== NOT EXECUTED
40008790: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008794: 01 00 00 00 nop
}
40008798: 81 c7 e0 08 ret
4000879c: 81 e8 00 00 restore
_Thread_queue_Surrender(
400087a0: 19 10 00 42 sethi %hi(0x40010800), %o4
400087a4: 96 07 bf dc add %fp, -36, %o3
400087a8: 98 13 20 28 or %o4, 0x28, %o4
400087ac: 40 00 08 a3 call 4000aa38 <_Thread_queue_Surrender>
400087b0: 90 06 20 08 add %i0, 8, %o0
400087b4: 81 c7 e0 08 ret
400087b8: 81 e8 00 00 restore
4000de30 <_Objects_API_maximum_class>:
#include <rtems/score/objectimpl.h>
unsigned int _Objects_API_maximum_class(
uint32_t api
)
{
4000de30: 82 02 3f ff add %o0, -1, %g1
4000de34: 80 a0 60 02 cmp %g1, 2
4000de38: 18 80 00 06 bgu 4000de50 <_Objects_API_maximum_class+0x20>
<== NEVER TAKEN
4000de3c: 90 10 20 00 clr %o0
4000de40: 83 28 60 02 sll %g1, 2, %g1
4000de44: 05 10 00 42 sethi %hi(0x40010800), %g2
4000de48: 84 10 a3 80 or %g2, 0x380, %g2 ! 40010b80 <CSWTCH.1>
4000de4c: d0 00 80 01 ld [ %g2 + %g1 ], %o0
case OBJECTS_NO_API:
default:
break;
}
return 0;
}
4000de50: 81 c3 e0 08 retl
4000de54: 01 00 00 00 nop
400087bc <_Objects_Allocate_unprotected>:
}
Objects_Control *_Objects_Allocate_unprotected(
Objects_Information *information
)
{
400087bc: 9d e3 bf a0 save %sp, -96, %sp
* If the application is using the optional manager stubs and
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
400087c0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
400087c4: 80 a0 60 00 cmp %g1, 0
400087c8: 02 80 00 31 be 4000888c <_Objects_Allocate_unprotected+0xd0>
<== NEVER TAKEN
400087cc: ba 10 00 18 mov %i0, %i5
return _Chain_Immutable_head( the_chain )->next;
400087d0: f0 06 20 20 ld [ %i0 + 0x20 ], %i0
return &the_chain->Tail.Node;
400087d4: b8 07 60 24 add %i5, 0x24, %i4
400087d8: b6 07 60 20 add %i5, 0x20, %i3
if ( !_Chain_Is_empty(the_chain))
400087dc: 80 a7 00 18 cmp %i4, %i0
400087e0: 02 80 00 1e be 40008858 <_Objects_Allocate_unprotected+0x9c>
400087e4: c4 0f 60 12 ldub [ %i5 + 0x12 ], %g2
new_first = old_first->next;
400087e8: c2 06 00 00 ld [ %i0 ], %g1
head->next = new_first;
400087ec: 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 ) {
400087f0: 80 88 a0 ff btst 0xff, %g2
400087f4: 02 80 00 17 be 40008850 <_Objects_Allocate_unprotected+0x94>
400087f8: f6 20 60 04 st %i3, [ %g1 + 4 ]
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
400087fc: c2 06 20 08 ld [ %i0 + 8 ], %g1
40008800: c6 07 60 08 ld [ %i5 + 8 ], %g3
40008804: 05 00 00 3f sethi %hi(0xfc00), %g2
40008808: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <_Configuration_Interrupt_stack_size+0xefff>
4000880c: 82 08 40 02 and %g1, %g2, %g1
40008810: 84 08 c0 02 and %g3, %g2, %g2
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
40008814: c8 07 60 30 ld [ %i5 + 0x30 ], %g4
block = (uint32_t) _Objects_Get_index( the_object->id ) -
40008818: 82 20 40 02 sub %g1, %g2, %g1
block /= information->allocation_size;
4000881c: c4 17 60 14 lduh [ %i5 + 0x14 ], %g2
40008820: 81 80 20 00 wr %g0, %y
40008824: 01 00 00 00 nop
40008828: 01 00 00 00 nop
4000882c: 01 00 00 00 nop
40008830: 84 70 40 02 udiv %g1, %g2, %g2
information->inactive_per_block[ block ]--;
40008834: 83 28 a0 02 sll %g2, 2, %g1
40008838: c6 01 00 01 ld [ %g4 + %g1 ], %g3
information->inactive--;
4000883c: c4 17 60 2c lduh [ %i5 + 0x2c ], %g2
information->inactive_per_block[ block ]--;
40008840: 86 00 ff ff add %g3, -1, %g3
40008844: c6 21 00 01 st %g3, [ %g4 + %g1 ]
information->inactive--;
40008848: 82 00 bf ff add %g2, -1, %g1
4000884c: c2 37 60 2c sth %g1, [ %i5 + 0x2c ]
);
}
#endif
return the_object;
}
40008850: 81 c7 e0 08 ret
40008854: 81 e8 00 00 restore
if ( information->auto_extend ) {
40008858: 80 88 a0 ff btst 0xff, %g2
4000885c: 02 80 00 0c be 4000888c <_Objects_Allocate_unprotected+0xd0>
40008860: 01 00 00 00 nop
_Objects_Extend_information( information );
40008864: 40 00 00 11 call 400088a8 <_Objects_Extend_information>
40008868: 90 10 00 1d mov %i5, %o0
return _Chain_Immutable_head( the_chain )->next;
4000886c: f0 07 60 20 ld [ %i5 + 0x20 ], %i0
if ( !_Chain_Is_empty(the_chain))
40008870: 80 a7 00 18 cmp %i4, %i0
40008874: 02 80 00 06 be 4000888c <_Objects_Allocate_unprotected+0xd0>
<== NEVER TAKEN
40008878: 01 00 00 00 nop
new_first = old_first->next;
4000887c: c2 06 00 00 ld [ %i0 ], %g1
head->next = new_first;
40008880: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
new_first->previous = head;
40008884: 10 bf ff de b 400087fc <_Objects_Allocate_unprotected+0x40>
40008888: f6 20 60 04 st %i3, [ %g1 + 4 ]
return NULL;
4000888c: 81 c7 e0 08 ret
40008890: 91 e8 20 00 restore %g0, 0, %o0
40008d2c <_Objects_Do_initialize_information>:
#if defined(RTEMS_MULTIPROCESSING)
,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
40008d2c: 9d e3 bf a0 save %sp, -96, %sp
information->maximum = 0;
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
40008d30: 05 10 00 41 sethi %hi(0x40010400), %g2
information->size = size;
40008d34: f8 26 20 18 st %i4, [ %i0 + 0x18 ]
_Objects_Information_table[ the_api ][ the_class ] = information;
40008d38: 84 10 a3 c4 or %g2, 0x3c4, %g2
information->the_api = the_api;
40008d3c: f2 26 00 00 st %i1, [ %i0 ]
_Objects_Information_table[ the_api ][ the_class ] = information;
40008d40: b9 2e 60 02 sll %i1, 2, %i4
information->the_class = the_class;
40008d44: f4 36 20 04 sth %i2, [ %i0 + 4 ]
_Objects_Information_table[ the_api ][ the_class ] = information;
40008d48: 89 2e a0 02 sll %i2, 2, %g4
information->local_table = 0;
40008d4c: 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;
40008d50: 87 36 e0 1f srl %i3, 0x1f, %g3
information->inactive_per_block = 0;
40008d54: 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) {
40008d58: 83 2e e0 10 sll %i3, 0x10, %g1
information->object_blocks = 0;
40008d5c: c0 26 20 34 clr [ %i0 + 0x34 ]
if ( information->auto_extend && maximum_per_allocation == 0) {
40008d60: 80 a0 60 00 cmp %g1, 0
information->inactive = 0;
40008d64: c0 36 20 2c clrh [ %i0 + 0x2c ]
information->is_string = is_string;
40008d68: fa 2e 20 38 stb %i5, [ %i0 + 0x38 ]
information->maximum = 0;
40008d6c: c0 36 20 10 clrh [ %i0 + 0x10 ]
_Objects_Information_table[ the_api ][ the_class ] = information;
40008d70: c4 00 80 1c ld [ %g2 + %i4 ], %g2
40008d74: f0 20 80 04 st %i0, [ %g2 + %g4 ]
information->auto_extend = _Objects_Is_unlimited( maximum );
40008d78: c6 2e 20 12 stb %g3, [ %i0 + 0x12 ]
if ( information->auto_extend && maximum_per_allocation == 0) {
40008d7c: 12 80 00 05 bne 40008d90 <_Objects_Do_initialize_information+0x64>
40008d80: c8 07 a0 5c ld [ %fp + 0x5c ], %g4
40008d84: 80 a0 e0 00 cmp %g3, 0
40008d88: 12 80 00 1c bne 40008df8 <_Objects_Do_initialize_information+0xcc>
<== NEVER TAKEN
40008d8c: 01 00 00 00 nop
(( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) |
40008d90: 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;
40008d94: 87 30 60 10 srl %g1, 0x10, %g3
40008d98: 80 a0 00 03 cmp %g0, %g3
40008d9c: 82 40 20 00 addx %g0, 0, %g1
40008da0: 82 10 40 02 or %g1, %g2, %g1
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40008da4: 85 2e a0 1b sll %i2, 0x1b, %g2
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
40008da8: b3 2e 60 18 sll %i1, 0x18, %i1
return &the_chain->Tail.Node;
40008dac: ba 06 20 20 add %i0, 0x20, %i5
(( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) |
40008db0: b4 10 40 19 or %g1, %i1, %i2
information->allocation_size = maximum_per_allocation;
40008db4: f6 36 20 14 sth %i3, [ %i0 + 0x14 ]
40008db8: b4 16 80 02 or %i2, %g2, %i2
information->local_table = &null_local_table;
40008dbc: 03 10 00 4b sethi %hi(0x40012c00), %g1
40008dc0: 84 06 20 24 add %i0, 0x24, %g2
40008dc4: 82 10 63 8c or %g1, 0x38c, %g1
information->minimum_id =
40008dc8: f4 26 20 08 st %i2, [ %i0 + 8 ]
_Chain_Initialize_empty( &information->Inactive );
/*
* Initialize objects .. if there are any
*/
if ( maximum_per_allocation ) {
40008dcc: 80 a0 e0 00 cmp %g3, 0
information->local_table = &null_local_table;
40008dd0: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
information->name_length = maximum_name_length;
40008dd4: c8 36 20 3a sth %g4, [ %i0 + 0x3a ]
head->next = tail;
40008dd8: c4 26 20 20 st %g2, [ %i0 + 0x20 ]
head->previous = NULL;
40008ddc: c0 26 20 24 clr [ %i0 + 0x24 ]
if ( maximum_per_allocation ) {
40008de0: 12 80 00 04 bne 40008df0 <_Objects_Do_initialize_information+0xc4>
40008de4: 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
}
40008de8: 81 c7 e0 08 ret
40008dec: 81 e8 00 00 restore
_Objects_Extend_information( information );
40008df0: 7f ff fe ae call 400088a8 <_Objects_Extend_information>
40008df4: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_UNLIMITED_AND_MAXIMUM_IS_0 );
40008df8: 7f ff f9 3d call 400072ec <_Internal_error>
<== NOT EXECUTED
40008dfc: 90 10 20 13 mov 0x13, %o0
<== NOT EXECUTED
40008e00: 01 00 00 00 nop
<== NOT EXECUTED
400088a8 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
400088a8: 9d e3 bf a0 save %sp, -96, %sp
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
400088ac: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
400088b0: e2 16 20 14 lduh [ %i0 + 0x14 ], %l1
400088b4: e4 16 20 0a lduh [ %i0 + 0xa ], %l2
400088b8: e0 16 20 10 lduh [ %i0 + 0x10 ], %l0
400088bc: 80 a0 a0 00 cmp %g2, 0
400088c0: 02 80 00 95 be 40008b14 <_Objects_Extend_information+0x26c>
400088c4: b6 10 00 11 mov %l1, %i3
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
400088c8: 81 80 20 00 wr %g0, %y
400088cc: 01 00 00 00 nop
400088d0: 01 00 00 00 nop
400088d4: 01 00 00 00 nop
400088d8: b2 f4 00 11 udivcc %l0, %l1, %i1
400088dc: 02 80 00 b1 be 40008ba0 <_Objects_Extend_information+0x2f8>
<== NEVER TAKEN
400088e0: b5 2c 20 10 sll %l0, 0x10, %i2
if ( information->object_blocks[ block ] == NULL ) {
400088e4: c2 00 80 00 ld [ %g2 ], %g1
400088e8: 80 a0 60 00 cmp %g1, 0
400088ec: 02 80 00 b1 be 40008bb0 <_Objects_Extend_information+0x308>
<== NEVER TAKEN
400088f0: ba 10 00 12 mov %l2, %i5
block = 0;
400088f4: 10 80 00 06 b 4000890c <_Objects_Extend_information+0x64>
400088f8: b8 10 20 00 clr %i4
if ( information->object_blocks[ block ] == NULL ) {
400088fc: c2 00 80 01 ld [ %g2 + %g1 ], %g1
40008900: 80 a0 60 00 cmp %g1, 0
40008904: 02 80 00 08 be 40008924 <_Objects_Extend_information+0x7c>
40008908: a8 10 20 00 clr %l4
for ( ; block < block_count; block++ ) {
4000890c: b8 07 20 01 inc %i4
do_extend = false;
break;
} else
index_base += information->allocation_size;
40008910: ba 07 40 1b add %i5, %i3, %i5
for ( ; block < block_count; block++ ) {
40008914: 80 a6 40 1c cmp %i1, %i4
40008918: 12 bf ff f9 bne 400088fc <_Objects_Extend_information+0x54>
4000891c: 83 2f 20 02 sll %i4, 2, %g1
do_extend = true;
40008920: a8 10 20 01 mov 1, %l4
}
}
index_end = index_base + information->allocation_size;
maximum = (uint32_t) information->maximum + information->allocation_size;
40008924: 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 ) {
40008928: 03 00 00 3f sethi %hi(0xfc00), %g1
maximum = (uint32_t) information->maximum + information->allocation_size;
4000892c: b4 06 80 1b add %i2, %i3, %i2
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
40008930: 82 10 63 ff or %g1, 0x3ff, %g1
40008934: 80 a6 80 01 cmp %i2, %g1
40008938: 18 80 00 88 bgu 40008b58 <_Objects_Extend_information+0x2b0>
<== NEVER TAKEN
4000893c: 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;
40008940: d0 06 20 18 ld [ %i0 + 0x18 ], %o0
if ( information->auto_extend ) {
40008944: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
40008948: 80 a0 60 00 cmp %g1, 0
4000894c: 02 80 00 78 be 40008b2c <_Objects_Extend_information+0x284>
40008950: 90 5e c0 08 smul %i3, %o0, %o0
new_object_block = _Workspace_Allocate( block_size );
40008954: 40 00 0e e3 call 4000c4e0 <_Workspace_Allocate>
40008958: 01 00 00 00 nop
if ( !new_object_block )
4000895c: a6 92 20 00 orcc %o0, 0, %l3
40008960: 02 80 00 6b be 40008b0c <_Objects_Extend_information+0x264>
<== NEVER TAKEN
40008964: b6 07 40 1b add %i5, %i3, %i3
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
40008968: 80 8d 20 ff btst 0xff, %l4
4000896c: 22 80 00 45 be,a 40008a80 <_Objects_Extend_information+0x1d8>
40008970: 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 ) {
40008974: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
block_count++;
40008978: b2 06 60 01 inc %i1
((maximum + minimum_index) * sizeof(Objects_Control *));
4000897c: 90 04 80 1a add %l2, %i2, %o0
if ( information->auto_extend ) {
40008980: 80 a0 60 00 cmp %g1, 0
(void*)(block_count * sizeof(void*)),
40008984: b5 2e 60 02 sll %i1, 2, %i2
((maximum + minimum_index) * sizeof(Objects_Control *));
40008988: 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);
4000898c: b2 06 a0 07 add %i2, 7, %i1
40008990: b2 0e 7f f8 and %i1, -8, %i1
block_size = object_blocks_size + inactive_per_block_size +
40008994: 83 2e 60 01 sll %i1, 1, %g1
if ( information->auto_extend ) {
40008998: 12 80 00 69 bne 40008b3c <_Objects_Extend_information+0x294>
4000899c: 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 );
400089a0: 40 00 0e e6 call 4000c538 <_Workspace_Allocate_or_fatal_error>
400089a4: 01 00 00 00 nop
400089a8: 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 ) {
400089ac: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
return (void *)((uintptr_t)base + offset);
400089b0: a8 05 40 19 add %l5, %i1, %l4
400089b4: b4 06 bf fc add %i2, -4, %i2
400089b8: 80 a0 40 12 cmp %g1, %l2
400089bc: 18 80 00 69 bgu 40008b60 <_Objects_Extend_information+0x2b8>
400089c0: 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++ ) {
400089c4: 80 a4 a0 00 cmp %l2, 0
400089c8: 22 80 00 0b be,a 400089f4 <_Objects_Extend_information+0x14c>
<== NEVER TAKEN
400089cc: c0 25 40 1a clr [ %l5 + %i2 ]
<== NOT EXECUTED
400089d0: a5 2c a0 02 sll %l2, 2, %l2
400089d4: 82 10 00 19 mov %i1, %g1
400089d8: a4 04 80 19 add %l2, %i1, %l2
local_table[ index ] = NULL;
400089dc: c0 20 40 00 clr [ %g1 ]
400089e0: 82 00 60 04 add %g1, 4, %g1
for ( index = 0; index < minimum_index; index++ ) {
400089e4: 80 a4 80 01 cmp %l2, %g1
400089e8: 32 bf ff fe bne,a 400089e0 <_Objects_Extend_information+0x138>
<== NEVER TAKEN
400089ec: c0 20 40 00 clr [ %g1 ]
<== NOT EXECUTED
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
400089f0: c0 25 40 1a clr [ %l5 + %i2 ]
inactive_per_block[block_count] = 0;
for ( index = index_base ; index < index_end ; ++index ) {
400089f4: 80 a7 40 1b cmp %i5, %i3
400089f8: 1a 80 00 0b bcc 40008a24 <_Objects_Extend_information+0x17c>
<== NEVER TAKEN
400089fc: c0 25 00 1a clr [ %l4 + %i2 ]
40008a00: 83 2f 60 02 sll %i5, 2, %g1
40008a04: 85 2e e0 02 sll %i3, 2, %g2
40008a08: 82 00 40 19 add %g1, %i1, %g1
40008a0c: 84 00 80 19 add %g2, %i1, %g2
local_table[ index ] = NULL;
40008a10: c0 20 40 00 clr [ %g1 ]
40008a14: 82 00 60 04 add %g1, 4, %g1
for ( index = index_base ; index < index_end ; ++index ) {
40008a18: 80 a0 80 01 cmp %g2, %g1
40008a1c: 32 bf ff fe bne,a 40008a14 <_Objects_Extend_information+0x16c>
40008a20: c0 20 40 00 clr [ %g1 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008a24: 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) |
40008a28: 07 00 00 40 sethi %hi(0x10000), %g3
<== NOT EXECUTED
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
40008a2c: c4 06 00 00 ld [ %i0 ], %g2
<== NOT EXECUTED
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40008a30: c8 16 20 04 lduh [ %i0 + 4 ], %g4
<== NOT EXECUTED
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
40008a34: a0 04 00 11 add %l0, %l1, %l0
<== NOT EXECUTED
old_tables = information->object_blocks;
40008a38: d0 06 20 34 ld [ %i0 + 0x34 ], %o0
<== NOT EXECUTED
40008a3c: 89 29 20 1b sll %g4, 0x1b, %g4
<== NOT EXECUTED
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
40008a40: 85 28 a0 18 sll %g2, 0x18, %g2
<== NOT EXECUTED
information->object_blocks = object_blocks;
40008a44: ea 26 20 34 st %l5, [ %i0 + 0x34 ]
<== NOT EXECUTED
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40008a48: 84 10 80 03 or %g2, %g3, %g2
<== NOT EXECUTED
information->inactive_per_block = inactive_per_block;
40008a4c: e8 26 20 30 st %l4, [ %i0 + 0x30 ]
<== NOT EXECUTED
#if !defined(RTEMS_USE_16_BIT_OBJECT)
(( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) |
40008a50: 87 2c 20 10 sll %l0, 0x10, %g3
<== NOT EXECUTED
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40008a54: 84 10 80 04 or %g2, %g4, %g2
<== NOT EXECUTED
(( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) |
40008a58: 87 30 e0 10 srl %g3, 0x10, %g3
<== NOT EXECUTED
information->local_table = local_table;
40008a5c: f2 26 20 1c st %i1, [ %i0 + 0x1c ]
<== NOT EXECUTED
40008a60: 84 10 80 03 or %g2, %g3, %g2
<== NOT EXECUTED
information->maximum = (Objects_Maximum) maximum;
40008a64: e0 36 20 10 sth %l0, [ %i0 + 0x10 ]
<== NOT EXECUTED
information->maximum_id = _Objects_Build_id(
40008a68: c4 26 20 0c st %g2, [ %i0 + 0xc ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008a6c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008a70: 01 00 00 00 nop
information->maximum
);
_ISR_lock_ISR_enable( &lock_context );
_Workspace_Free( old_tables );
40008a74: 40 00 0e ab call 4000c520 <_Workspace_Free>
40008a78: 01 00 00 00 nop
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
40008a7c: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
40008a80: b9 2f 20 02 sll %i4, 2, %i4
40008a84: 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 ) {
40008a88: 80 a7 40 1b cmp %i5, %i3
the_object = information->object_blocks[ block ];
40008a8c: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
for ( index = index_base ; index < index_end ; ++index ) {
40008a90: 1a 80 00 19 bcc 40008af4 <_Objects_Extend_information+0x24c>
<== NEVER TAKEN
40008a94: c2 00 40 1c ld [ %g1 + %i4 ], %g1
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
40008a98: c8 06 00 00 ld [ %i0 ], %g4
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40008a9c: 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 );
40008aa0: de 06 20 18 ld [ %i0 + 0x18 ], %o7
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
40008aa4: 89 29 20 18 sll %g4, 0x18, %g4
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40008aa8: 85 28 a0 1b sll %g2, 0x1b, %g2
40008aac: 07 00 00 40 sethi %hi(0x10000), %g3
(( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) |
40008ab0: 35 00 00 3f sethi %hi(0xfc00), %i2
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40008ab4: 88 11 00 03 or %g4, %g3, %g4
40008ab8: b2 06 20 24 add %i0, 0x24, %i1
40008abc: 88 11 00 02 or %g4, %g2, %g4
(( (Objects_Id) node ) << OBJECTS_NODE_START_BIT) |
40008ac0: b4 16 a3 ff or %i2, 0x3ff, %i2
old_last = tail->previous;
40008ac4: c6 06 20 28 ld [ %i0 + 0x28 ], %g3
40008ac8: 84 0f 40 1a and %i5, %i2, %g2
the_node->next = tail;
40008acc: f2 20 40 00 st %i1, [ %g1 ]
40008ad0: 84 10 80 04 or %g2, %g4, %g2
the_object->id = _Objects_Build_id(
40008ad4: c4 20 60 08 st %g2, [ %g1 + 8 ]
for ( index = index_base ; index < index_end ; ++index ) {
40008ad8: ba 07 60 01 inc %i5
tail->previous = the_node;
40008adc: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
40008ae0: 80 a6 c0 1d cmp %i3, %i5
old_last->next = the_node;
40008ae4: c2 20 c0 00 st %g1, [ %g3 ]
the_node->previous = old_last;
40008ae8: c6 20 60 04 st %g3, [ %g1 + 4 ]
40008aec: 12 bf ff f6 bne 40008ac4 <_Objects_Extend_information+0x21c>
40008af0: 82 00 40 0f add %g1, %o7, %g1
}
information->inactive_per_block[ block ] = information->allocation_size;
40008af4: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2
40008af8: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
40008afc: c2 16 20 2c lduh [ %i0 + 0x2c ], %g1
information->inactive_per_block[ block ] = information->allocation_size;
40008b00: c4 20 c0 1c st %g2, [ %g3 + %i4 ]
(Objects_Maximum)(information->inactive + information->allocation_size);
40008b04: 82 00 40 02 add %g1, %g2, %g1
information->inactive =
40008b08: c2 36 20 2c sth %g1, [ %i0 + 0x2c ]
}
40008b0c: 81 c7 e0 08 ret
40008b10: 81 e8 00 00 restore
40008b14: ba 10 00 12 mov %l2, %i5
do_extend = true;
40008b18: a8 10 20 01 mov 1, %l4
block = 0;
40008b1c: b8 10 20 00 clr %i4
block_count = 0;
40008b20: b2 10 20 00 clr %i1
40008b24: 10 bf ff 80 b 40008924 <_Objects_Extend_information+0x7c>
40008b28: b5 2c 20 10 sll %l0, 0x10, %i2
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
40008b2c: 40 00 0e 83 call 4000c538 <_Workspace_Allocate_or_fatal_error>
40008b30: b6 07 40 1b add %i5, %i3, %i3
40008b34: 10 bf ff 8d b 40008968 <_Objects_Extend_information+0xc0>
40008b38: a6 10 00 08 mov %o0, %l3
object_blocks = _Workspace_Allocate( block_size );
40008b3c: 40 00 0e 69 call 4000c4e0 <_Workspace_Allocate>
40008b40: 01 00 00 00 nop
if ( !object_blocks ) {
40008b44: aa 92 20 00 orcc %o0, 0, %l5
40008b48: 32 bf ff 9a bne,a 400089b0 <_Objects_Extend_information+0x108>
<== ALWAYS TAKEN
40008b4c: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
_Workspace_Free( new_object_block );
40008b50: 40 00 0e 74 call 4000c520 <_Workspace_Free>
<== NOT EXECUTED
40008b54: 91 e8 00 13 restore %g0, %l3, %o0
<== NOT EXECUTED
40008b58: 81 c7 e0 08 ret
<== NOT EXECUTED
40008b5c: 81 e8 00 00 restore
<== NOT EXECUTED
memcpy( object_blocks,
40008b60: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40008b64: 94 10 00 1a mov %i2, %o2
40008b68: 40 00 17 39 call 4000e84c <memcpy>
40008b6c: 90 10 00 15 mov %l5, %o0
memcpy( inactive_per_block,
40008b70: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
40008b74: 94 10 00 1a mov %i2, %o2
40008b78: 40 00 17 35 call 4000e84c <memcpy>
40008b7c: 90 10 00 14 mov %l4, %o0
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
40008b80: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2
memcpy( local_table,
40008b84: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
40008b88: 94 02 80 12 add %o2, %l2, %o2
memcpy( local_table,
40008b8c: 90 10 00 19 mov %i1, %o0
40008b90: 40 00 17 2f call 4000e84c <memcpy>
40008b94: 95 2a a0 02 sll %o2, 2, %o2
40008b98: 10 bf ff 97 b 400089f4 <_Objects_Extend_information+0x14c>
40008b9c: c0 25 40 1a clr [ %l5 + %i2 ]
for ( ; block < block_count; block++ ) {
40008ba0: ba 10 00 12 mov %l2, %i5
<== NOT EXECUTED
do_extend = true;
40008ba4: a8 10 20 01 mov 1, %l4
<== NOT EXECUTED
block = 0;
40008ba8: 10 bf ff 5f b 40008924 <_Objects_Extend_information+0x7c>
<== NOT EXECUTED
40008bac: b8 10 20 00 clr %i4
<== NOT EXECUTED
do_extend = false;
40008bb0: a8 10 20 00 clr %l4
<== NOT EXECUTED
block = 0;
40008bb4: 10 bf ff 5c b 40008924 <_Objects_Extend_information+0x7c>
<== NOT EXECUTED
40008bb8: b8 10 20 00 clr %i4
<== NOT EXECUTED
4000de74 <_Objects_Get>:
const Objects_Information *information
)
{
uint32_t index;
index = id - information->minimum_id + 1;
4000de74: c4 02 a0 08 ld [ %o2 + 8 ], %g2
if ( information->maximum >= index ) {
4000de78: c2 12 a0 10 lduh [ %o2 + 0x10 ], %g1
index = id - information->minimum_id + 1;
4000de7c: 90 02 20 01 inc %o0
4000de80: 90 22 00 02 sub %o0, %g2, %o0
if ( information->maximum >= index ) {
4000de84: 80 a0 40 08 cmp %g1, %o0
4000de88: 0a 80 00 0c bcs 4000deb8 <_Objects_Get+0x44>
<== NEVER TAKEN
4000de8c: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000de90: 91 d0 20 09 ta 9
<== NOT EXECUTED
Objects_Control *the_object;
_ISR_lock_ISR_disable( lock_context );
4000de94: c2 22 40 00 st %g1, [ %o1 ]
the_object = information->local_table[ index ];
4000de98: c2 02 a0 1c ld [ %o2 + 0x1c ], %g1
4000de9c: 91 2a 20 02 sll %o0, 2, %o0
4000dea0: d0 00 40 08 ld [ %g1 + %o0 ], %o0
if ( the_object != NULL ) {
4000dea4: 80 a2 20 00 cmp %o0, 0
4000dea8: 02 80 00 06 be 4000dec0 <_Objects_Get+0x4c>
<== NEVER TAKEN
4000deac: 01 00 00 00 nop
_ISR_lock_ISR_enable( lock_context );
}
return NULL;
}
4000deb0: 81 c3 e0 08 retl
4000deb4: 01 00 00 00 nop
4000deb8: 81 c3 e0 08 retl
<== NOT EXECUTED
4000debc: 90 10 20 00 clr %o0 ! 0 <PROM_START>
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000dec0: c2 02 40 00 ld [ %o1 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000dec4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000dec8: 01 00 00 00 nop
<== NOT EXECUTED
4000decc: 81 c3 e0 08 retl
<== NOT EXECUTED
4000ded0: 01 00 00 00 nop
<== NOT EXECUTED
40008c84 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
40008c84: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
40008c88: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40008c8c: 02 80 00 19 be 40008cf0 <_Objects_Get_information+0x6c>
<== NOT EXECUTED
40008c90: 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 );
40008c94: 40 00 14 67 call 4000de30 <_Objects_API_maximum_class>
40008c98: 90 10 00 18 mov %i0, %o0
if ( the_class_api_maximum == 0 )
40008c9c: 80 a2 20 00 cmp %o0, 0
40008ca0: 02 80 00 14 be 40008cf0 <_Objects_Get_information+0x6c>
<== NEVER TAKEN
40008ca4: 80 a2 00 19 cmp %o0, %i1
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
40008ca8: 0a 80 00 12 bcs 40008cf0 <_Objects_Get_information+0x6c>
<== NEVER TAKEN
40008cac: 03 10 00 41 sethi %hi(0x40010400), %g1
return NULL;
if ( !_Objects_Information_table[ the_api ] )
40008cb0: b1 2e 20 02 sll %i0, 2, %i0
40008cb4: 82 10 63 c4 or %g1, 0x3c4, %g1
40008cb8: c2 00 40 18 ld [ %g1 + %i0 ], %g1
40008cbc: 80 a0 60 00 cmp %g1, 0
40008cc0: 02 80 00 0c be 40008cf0 <_Objects_Get_information+0x6c>
<== NEVER TAKEN
40008cc4: b3 2e 60 02 sll %i1, 2, %i1
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
40008cc8: f0 00 40 19 ld [ %g1 + %i1 ], %i0
if ( !info )
40008ccc: 80 a6 20 00 cmp %i0, 0
40008cd0: 02 80 00 08 be 40008cf0 <_Objects_Get_information+0x6c>
<== NEVER TAKEN
40008cd4: 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 )
40008cd8: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
40008cdc: 80 a0 60 00 cmp %g1, 0
40008ce0: 02 80 00 04 be 40008cf0 <_Objects_Get_information+0x6c>
<== NEVER TAKEN
40008ce4: 01 00 00 00 nop
return NULL;
#endif
return info;
}
40008ce8: 81 c7 e0 08 ret
40008cec: 81 e8 00 00 restore
return NULL;
40008cf0: 81 c7 e0 08 ret
<== NOT EXECUTED
40008cf4: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
4001a94c <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
4001a94c: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
4001a950: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4001a954: 02 80 00 1e be 4001a9cc <_Objects_Get_name_as_string+0x80>
<== NOT EXECUTED
4001a958: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4001a95c: 02 80 00 1c be 4001a9cc <_Objects_Get_name_as_string+0x80>
<== NOT EXECUTED
4001a960: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id;
4001a964: 22 80 00 18 be,a 4001a9c4 <_Objects_Get_name_as_string+0x78>
<== NOT EXECUTED
4001a968: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1
<== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
4001a96c: 7f ff dc 2e call 40011a24 <_Objects_Get_information_id>
<== NOT EXECUTED
4001a970: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( !information )
4001a974: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001a978: 02 80 00 15 be 4001a9cc <_Objects_Get_name_as_string+0x80>
<== NOT EXECUTED
4001a97c: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
return NULL;
the_object = _Objects_Get( tmpId, &lock_context, information );
4001a980: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
4001a984: 7f ff dc 4b call 40011ab0 <_Objects_Get>
<== NOT EXECUTED
4001a988: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( the_object == NULL ) {
4001a98c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001a990: 02 80 00 0f be 4001a9cc <_Objects_Get_name_as_string+0x80>
<== NOT EXECUTED
4001a994: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
return NULL;
}
_Objects_Name_to_string(
4001a998: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
4001a99c: d2 0f 60 38 ldub [ %i5 + 0x38 ], %o1
<== NOT EXECUTED
4001a9a0: c2 27 bf f4 st %g1, [ %fp + -12 ]
<== NOT EXECUTED
4001a9a4: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4001a9a8: 7f ff ff be call 4001a8a0 <_Objects_Name_to_string>
<== NOT EXECUTED
4001a9ac: 90 07 bf f4 add %fp, -12, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4001a9b0: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001a9b4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001a9b8: 01 00 00 00 nop
<== NOT EXECUTED
length
);
_ISR_lock_ISR_enable( &lock_context );
return name;
}
4001a9bc: 81 c7 e0 08 ret
<== NOT EXECUTED
4001a9c0: 91 e8 00 1a restore %g0, %i2, %o0
<== NOT EXECUTED
4001a9c4: 10 bf ff ea b 4001a96c <_Objects_Get_name_as_string+0x20>
<== NOT EXECUTED
4001a9c8: f0 00 60 08 ld [ %g1 + 8 ], %i0
<== NOT EXECUTED
return NULL;
4001a9cc: 81 c7 e0 08 ret
<== NOT EXECUTED
4001a9d0: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
4001bc3c <_Objects_Get_next>:
Objects_Control *_Objects_Get_next(
Objects_Id id,
const Objects_Information *information,
Objects_Id *next_id_p
)
{
4001bc3c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Objects_Id next_id;
if ( !information )
return NULL;
if ( !next_id_p )
4001bc40: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4001bc44: 02 80 00 20 be 4001bcc4 <_Objects_Get_next+0x88>
<== NOT EXECUTED
4001bc48: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4001bc4c: 02 80 00 1e be 4001bcc4 <_Objects_Get_next+0x88>
<== NOT EXECUTED
4001bc50: 83 2e 20 10 sll %i0, 0x10, %g1
<== NOT EXECUTED
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
4001bc54: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001bc58: 22 80 00 02 be,a 4001bc60 <_Objects_Get_next+0x24>
<== NOT EXECUTED
4001bc5c: f0 06 60 08 ld [ %i1 + 8 ], %i0
<== NOT EXECUTED
4001bc60: 7f ff ce 28 call 4000f500 <_RTEMS_Lock_allocator>
<== NOT EXECUTED
4001bc64: 01 00 00 00 nop
<== NOT EXECUTED
_Objects_Allocator_lock();
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
4001bc68: 10 80 00 08 b 4001bc88 <_Objects_Get_next+0x4c>
<== NOT EXECUTED
4001bc6c: c4 16 60 10 lduh [ %i1 + 0x10 ], %g2
<== NOT EXECUTED
*next_id_p = OBJECTS_ID_FINAL;
return NULL;
}
/* try to grab one */
the_object = _Objects_Get_no_protection( next_id, information );
4001bc70: 7f ff d7 a8 call 40011b10 <_Objects_Get_no_protection>
<== NOT EXECUTED
4001bc74: b0 06 20 01 inc %i0
<== NOT EXECUTED
next_id++;
} while ( the_object == NULL );
4001bc78: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001bc7c: 32 80 00 10 bne,a 4001bcbc <_Objects_Get_next+0x80>
<== NOT EXECUTED
4001bc80: f0 26 80 00 st %i0, [ %i2 ]
<== NOT EXECUTED
if (_Objects_Get_index(next_id) > information->maximum)
4001bc84: c4 16 60 10 lduh [ %i1 + 0x10 ], %g2
<== NOT EXECUTED
4001bc88: 83 2e 20 10 sll %i0, 0x10, %g1
<== NOT EXECUTED
the_object = _Objects_Get_no_protection( next_id, information );
4001bc8c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (_Objects_Get_index(next_id) > information->maximum)
4001bc90: 83 30 60 10 srl %g1, 0x10, %g1
<== NOT EXECUTED
4001bc94: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4001bc98: 1a bf ff f6 bcc 4001bc70 <_Objects_Get_next+0x34>
<== NOT EXECUTED
4001bc9c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
4001bca0: 7f ff ce 1d call 4000f514 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4001bca4: 01 00 00 00 nop
<== NOT EXECUTED
*next_id_p = OBJECTS_ID_FINAL;
4001bca8: 82 10 3f ff mov -1, %g1 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
4001bcac: c2 26 80 00 st %g1, [ %i2 ]
<== NOT EXECUTED
return NULL;
4001bcb0: 90 10 20 00 clr %o0
<== NOT EXECUTED
*next_id_p = next_id;
return the_object;
}
4001bcb4: 81 c7 e0 08 ret
<== NOT EXECUTED
4001bcb8: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4001bcbc: 81 c7 e0 08 ret
<== NOT EXECUTED
4001bcc0: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
return NULL;
4001bcc4: 10 bf ff fc b 4001bcb4 <_Objects_Get_next+0x78>
<== NOT EXECUTED
4001bcc8: 90 10 20 00 clr %o0
<== NOT EXECUTED
40008cf8 <_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;
40008cf8: c4 02 60 08 ld [ %o1 + 8 ], %g2
<== NOT EXECUTED
if ( information->maximum >= index ) {
40008cfc: c2 12 60 10 lduh [ %o1 + 0x10 ], %g1
<== NOT EXECUTED
index = id - information->minimum_id + 1;
40008d00: 90 02 20 01 inc %o0
<== NOT EXECUTED
40008d04: 90 22 00 02 sub %o0, %g2, %o0
<== NOT EXECUTED
if ( information->maximum >= index ) {
40008d08: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
40008d0c: 0a 80 00 06 bcs 40008d24 <_Objects_Get_no_protection+0x2c>
<== NOT EXECUTED
40008d10: 01 00 00 00 nop
<== NOT EXECUTED
if ( (the_object = information->local_table[ index ]) != NULL ) {
40008d14: c2 02 60 1c ld [ %o1 + 0x1c ], %g1
<== NOT EXECUTED
40008d18: 91 2a 20 02 sll %o0, 2, %o0
<== NOT EXECUTED
40008d1c: 81 c3 e0 08 retl
<== NOT EXECUTED
40008d20: d0 00 40 08 ld [ %g1 + %o0 ], %o0
<== NOT EXECUTED
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
return NULL;
}
40008d24: 81 c3 e0 08 retl
<== NOT EXECUTED
40008d28: 90 10 20 00 clr %o0
<== NOT EXECUTED
40011b44 <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
40011b44: 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;
40011b48: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
40011b4c: 12 80 00 04 bne 40011b5c <_Objects_Id_to_name+0x18>
<== NOT EXECUTED
40011b50: 01 00 00 00 nop
<== NOT EXECUTED
40011b54: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1
<== NOT EXECUTED
40011b58: f0 00 60 08 ld [ %g1 + 8 ], %i0
<== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
40011b5c: 7f ff ff b2 call 40011a24 <_Objects_Get_information_id>
<== NOT EXECUTED
40011b60: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( !information )
40011b64: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40011b68: 02 80 00 13 be 40011bb4 <_Objects_Id_to_name+0x70>
<== NOT EXECUTED
40011b6c: 01 00 00 00 nop
<== NOT EXECUTED
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
40011b70: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1
<== NOT EXECUTED
40011b74: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40011b78: 12 80 00 0f bne 40011bb4 <_Objects_Id_to_name+0x70>
<== NOT EXECUTED
40011b7c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get(
40011b80: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
40011b84: 7f ff ff cb call 40011ab0 <_Objects_Get>
<== NOT EXECUTED
40011b88: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
tmpId,
&lock_context,
information
);
if ( !the_object )
40011b8c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40011b90: 02 80 00 09 be 40011bb4 <_Objects_Id_to_name+0x70>
<== NOT EXECUTED
40011b94: 01 00 00 00 nop
<== NOT EXECUTED
return OBJECTS_INVALID_ID;
*name = the_object->name;
40011b98: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
40011b9c: c2 26 40 00 st %g1, [ %i1 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40011ba0: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40011ba4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40011ba8: 01 00 00 00 nop
<== NOT EXECUTED
_ISR_lock_ISR_enable( &lock_context );
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
40011bac: 81 c7 e0 08 ret
<== NOT EXECUTED
40011bb0: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
return OBJECTS_INVALID_ID;
40011bb4: 81 c7 e0 08 ret
<== NOT EXECUTED
40011bb8: 91 e8 20 03 restore %g0, 3, %o0
<== NOT EXECUTED
40008e04 <_Objects_Name_to_id_u32>:
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
40008e04: 80 a2 e0 00 cmp %o3, 0
<== NOT EXECUTED
40008e08: 02 80 00 21 be 40008e8c <_Objects_Name_to_id_u32+0x88>
<== NOT EXECUTED
40008e0c: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
40008e10: 02 80 00 1d be 40008e84 <_Objects_Name_to_id_u32+0x80>
<== NOT EXECUTED
40008e14: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
search_local_node = false;
if ( information->maximum != 0 &&
(node == OBJECTS_SEARCH_ALL_NODES ||
node == OBJECTS_SEARCH_LOCAL_NODE ||
40008e18: 05 20 00 00 sethi %hi(0x80000000), %g2
<== NOT EXECUTED
40008e1c: 84 38 80 0a xnor %g2, %o2, %g2
<== NOT EXECUTED
40008e20: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40008e24: 02 80 00 05 be 40008e38 <_Objects_Name_to_id_u32+0x34>
<== NOT EXECUTED
40008e28: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3
<== NOT EXECUTED
40008e2c: 80 a2 a0 01 cmp %o2, 1
<== NOT EXECUTED
40008e30: 18 80 00 15 bgu 40008e84 <_Objects_Name_to_id_u32+0x80>
<== NOT EXECUTED
40008e34: 01 00 00 00 nop
<== NOT EXECUTED
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
40008e38: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40008e3c: 02 80 00 11 be 40008e80 <_Objects_Name_to_id_u32+0x7c>
<== NOT EXECUTED
40008e40: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
the_object = information->local_table[ index ];
40008e44: da 02 20 1c ld [ %o0 + 0x1c ], %o5
<== NOT EXECUTED
40008e48: 86 00 e0 01 inc %g3
<== NOT EXECUTED
40008e4c: 85 28 60 02 sll %g1, 2, %g2
<== NOT EXECUTED
40008e50: c4 03 40 02 ld [ %o5 + %g2 ], %g2
<== NOT EXECUTED
if ( !the_object )
40008e54: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40008e58: 22 80 00 07 be,a 40008e74 <_Objects_Name_to_id_u32+0x70>
<== NOT EXECUTED
40008e5c: 82 00 60 01 inc %g1
<== NOT EXECUTED
continue;
if ( name == the_object->name.name_u32 ) {
40008e60: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
<== NOT EXECUTED
40008e64: 80 a1 00 09 cmp %g4, %o1
<== NOT EXECUTED
40008e68: 22 80 00 0c be,a 40008e98 <_Objects_Name_to_id_u32+0x94>
<== NOT EXECUTED
40008e6c: c2 00 a0 08 ld [ %g2 + 8 ], %g1
<== NOT EXECUTED
for ( index = 1; index <= information->maximum; index++ ) {
40008e70: 82 00 60 01 inc %g1
<== NOT EXECUTED
40008e74: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
40008e78: 32 bf ff f6 bne,a 40008e50 <_Objects_Name_to_id_u32+0x4c>
<== NOT EXECUTED
40008e7c: 85 28 60 02 sll %g1, 2, %g2
<== NOT EXECUTED
return OBJECTS_INVALID_NAME;
40008e80: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
name_for_mp.name_u32 = name;
return _Objects_MP_Global_name_search( information, name_for_mp, node, id );
#else
return OBJECTS_INVALID_NAME;
#endif
}
40008e84: 81 c3 e0 08 retl
<== NOT EXECUTED
40008e88: 90 10 00 01 mov %g1, %o0
<== NOT EXECUTED
return OBJECTS_INVALID_ADDRESS;
40008e8c: 82 10 20 02 mov 2, %g1
<== NOT EXECUTED
}
40008e90: 81 c3 e0 08 retl
<== NOT EXECUTED
40008e94: 90 10 00 01 mov %g1, %o0
<== NOT EXECUTED
*id = the_object->id;
40008e98: c2 22 c0 00 st %g1, [ %o3 ]
<== NOT EXECUTED
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
40008e9c: 10 bf ff fa b 40008e84 <_Objects_Name_to_id_u32+0x80>
<== NOT EXECUTED
40008ea0: 82 10 20 00 clr %g1
<== NOT EXECUTED
4001a8a0 <_Objects_Name_to_string>:
Objects_Name name,
bool is_string,
char *buffer,
size_t buffer_size
)
{
4001a8a0: 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 ) {
4001a8a4: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
4001a8a8: 12 80 00 20 bne 4001a928 <_Objects_Name_to_string+0x88>
<== NOT EXECUTED
4001a8ac: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
s = name.name_p;
} else
#endif
{
lname[ 0 ] = (name.name_u32 >> 24) & 0xff;
4001a8b0: 85 30 60 18 srl %g1, 0x18, %g2
<== NOT EXECUTED
lname[ 1 ] = (name.name_u32 >> 16) & 0xff;
4001a8b4: 89 30 60 10 srl %g1, 0x10, %g4
<== NOT EXECUTED
lname[ 2 ] = (name.name_u32 >> 8) & 0xff;
4001a8b8: 87 30 60 08 srl %g1, 8, %g3
<== NOT EXECUTED
lname[ 0 ] = (name.name_u32 >> 24) & 0xff;
4001a8bc: c4 2b a0 48 stb %g2, [ %sp + 0x48 ]
<== NOT EXECUTED
lname[ 1 ] = (name.name_u32 >> 16) & 0xff;
4001a8c0: c8 2b a0 49 stb %g4, [ %sp + 0x49 ]
<== NOT EXECUTED
lname[ 2 ] = (name.name_u32 >> 8) & 0xff;
4001a8c4: c6 2b a0 4a stb %g3, [ %sp + 0x4a ]
<== NOT EXECUTED
lname[ 3 ] = (name.name_u32 >> 0) & 0xff;
lname[ 4 ] = '\0';
4001a8c8: c0 2b a0 4c clrb [ %sp + 0x4c ]
<== NOT EXECUTED
lname[ 3 ] = (name.name_u32 >> 0) & 0xff;
4001a8cc: c2 2b a0 4b stb %g1, [ %sp + 0x4b ]
<== NOT EXECUTED
s = lname;
4001a8d0: 82 03 a0 48 add %sp, 0x48, %g1
<== NOT EXECUTED
d = buffer;
i = 1;
if ( s != NULL ) {
while ( *s != '\0' ) {
4001a8d4: 87 28 a0 18 sll %g2, 0x18, %g3
<== NOT EXECUTED
4001a8d8: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
4001a8dc: 02 80 00 16 be 4001a934 <_Objects_Name_to_string+0x94>
<== NOT EXECUTED
4001a8e0: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
if ( i < buffer_size ) {
4001a8e4: 80 a2 c0 08 cmp %o3, %o0
<== NOT EXECUTED
4001a8e8: 08 80 00 09 bleu 4001a90c <_Objects_Name_to_string+0x6c>
<== NOT EXECUTED
4001a8ec: 82 00 60 01 inc %g1
<== NOT EXECUTED
return uc >= ' ' && uc <= '~';
4001a8f0: 86 00 bf e0 add %g2, -32, %g3
<== NOT EXECUTED
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
4001a8f4: 86 08 e0 ff and %g3, 0xff, %g3
<== NOT EXECUTED
4001a8f8: 80 a0 e0 5e cmp %g3, 0x5e
<== NOT EXECUTED
4001a8fc: 38 80 00 02 bgu,a 4001a904 <_Objects_Name_to_string+0x64>
<== NOT EXECUTED
4001a900: 84 10 20 2a mov 0x2a, %g2
<== NOT EXECUTED
4001a904: c4 2a 80 00 stb %g2, [ %o2 ]
<== NOT EXECUTED
++d;
4001a908: 94 02 a0 01 inc %o2
<== NOT EXECUTED
while ( *s != '\0' ) {
4001a90c: c6 48 40 00 ldsb [ %g1 ], %g3
<== NOT EXECUTED
}
++s;
++i;
4001a910: 88 02 20 01 add %o0, 1, %g4
<== NOT EXECUTED
while ( *s != '\0' ) {
4001a914: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
4001a918: 02 80 00 08 be 4001a938 <_Objects_Name_to_string+0x98>
<== NOT EXECUTED
4001a91c: c4 08 40 00 ldub [ %g1 ], %g2
<== NOT EXECUTED
++i;
4001a920: 10 bf ff f1 b 4001a8e4 <_Objects_Name_to_string+0x44>
<== NOT EXECUTED
4001a924: 90 10 00 04 mov %g4, %o0
<== NOT EXECUTED
if ( s != NULL ) {
4001a928: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001a92c: 32 bf ff ea bne,a 4001a8d4 <_Objects_Name_to_string+0x34>
<== NOT EXECUTED
4001a930: c4 08 40 00 ldub [ %g1 ], %g2
<== NOT EXECUTED
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
4001a934: 90 10 20 00 clr %o0
<== NOT EXECUTED
}
}
if ( buffer_size > 0 ) {
4001a938: 80 a2 e0 00 cmp %o3, 0
<== NOT EXECUTED
4001a93c: 32 80 00 02 bne,a 4001a944 <_Objects_Name_to_string+0xa4>
<== NOT EXECUTED
4001a940: c0 2a 80 00 clrb [ %o2 ]
<== NOT EXECUTED
*d = '\0';
}
return i - 1;
}
4001a944: 81 c3 e0 08 retl
<== NOT EXECUTED
4001a948: 9c 03 a0 50 add %sp, 0x50, %sp
<== NOT EXECUTED
4000ded4 <_Objects_Namespace_remove>:
void _Objects_Namespace_remove(
Objects_Information *information,
Objects_Control *the_object
)
{
4000ded4: 9d e3 bf a0 save %sp, -96, %sp
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/*
* If this is a string format name, then free the memory.
*/
if ( information->is_string )
4000ded8: c2 0e 20 38 ldub [ %i0 + 0x38 ], %g1
4000dedc: 80 a0 60 00 cmp %g1, 0
4000dee0: 22 80 00 05 be,a 4000def4 <_Objects_Namespace_remove+0x20>
<== ALWAYS TAKEN
4000dee4: c0 26 60 0c clr [ %i1 + 0xc ]
_Workspace_Free( (void *)the_object->name.name_p );
4000dee8: 7f ff f9 8e call 4000c520 <_Workspace_Free>
<== NOT EXECUTED
4000deec: d0 06 60 0c ld [ %i1 + 0xc ], %o0
<== NOT EXECUTED
/*
* Clear out either format.
*/
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
the_object->name.name_p = NULL;
4000def0: c0 26 60 0c clr [ %i1 + 0xc ]
<== NOT EXECUTED
#endif
the_object->name.name_u32 = 0;
}
4000def4: 81 c7 e0 08 ret
4000def8: 81 e8 00 00 restore
40008ea4 <_Objects_Shrink_information>:
#include <rtems/score/wkspace.h>
void _Objects_Shrink_information(
Objects_Information *information
)
{
40008ea4: 9d e3 bf a0 save %sp, -96, %sp
40008ea8: c6 16 20 0a lduh [ %i0 + 0xa ], %g3
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
40008eac: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2
block_count = (information->maximum - index_base) /
40008eb0: c8 16 20 10 lduh [ %i0 + 0x10 ], %g4
40008eb4: 88 21 00 03 sub %g4, %g3, %g4
for ( block = 0; block < block_count; block++ ) {
40008eb8: 81 80 20 00 wr %g0, %y
40008ebc: 01 00 00 00 nop
40008ec0: 01 00 00 00 nop
40008ec4: 01 00 00 00 nop
40008ec8: 88 f1 00 02 udivcc %g4, %g2, %g4
40008ecc: 02 80 00 35 be 40008fa0 <_Objects_Shrink_information+0xfc>
40008ed0: 01 00 00 00 nop
if ( information->inactive_per_block[ block ] ==
40008ed4: f4 06 20 30 ld [ %i0 + 0x30 ], %i2
40008ed8: c2 06 80 00 ld [ %i2 ], %g1
40008edc: 80 a0 80 01 cmp %g2, %g1
40008ee0: 02 80 00 0f be 40008f1c <_Objects_Shrink_information+0x78>
<== NEVER TAKEN
40008ee4: ba 10 20 04 mov 4, %i5
for ( block = 0; block < block_count; block++ ) {
40008ee8: 10 80 00 07 b 40008f04 <_Objects_Shrink_information+0x60>
40008eec: 82 10 20 00 clr %g1
if ( information->inactive_per_block[ block ] ==
40008ef0: f8 06 80 1d ld [ %i2 + %i5 ], %i4
40008ef4: 80 a0 80 1c cmp %g2, %i4
40008ef8: 02 80 00 0a be 40008f20 <_Objects_Shrink_information+0x7c>
40008efc: b6 07 60 04 add %i5, 4, %i3
40008f00: ba 10 00 1b mov %i3, %i5
for ( block = 0; block < block_count; block++ ) {
40008f04: 82 00 60 01 inc %g1
40008f08: 80 a1 00 01 cmp %g4, %g1
40008f0c: 12 bf ff f9 bne 40008ef0 <_Objects_Shrink_information+0x4c>
40008f10: 86 00 c0 02 add %g3, %g2, %g3
return;
}
index_base += information->allocation_size;
}
}
40008f14: 81 c7 e0 08 ret
40008f18: 81 e8 00 00 restore
if ( information->inactive_per_block[ block ] ==
40008f1c: ba 10 20 00 clr %i5
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40008f20: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
return &the_chain->Tail.Node;
40008f24: b4 06 20 24 add %i0, 0x24, %i2
while ( node != tail ) {
40008f28: 80 a0 40 1a cmp %g1, %i2
40008f2c: 02 80 00 12 be 40008f74 <_Objects_Shrink_information+0xd0>
<== NEVER TAKEN
40008f30: 84 00 80 03 add %g2, %g3, %g2
40008f34: 37 00 00 3f sethi %hi(0xfc00), %i3
40008f38: b6 16 e3 ff or %i3, 0x3ff, %i3 ! ffff <_Configuration_Interrupt_stack_size+0xefff>
40008f3c: c8 00 60 08 ld [ %g1 + 8 ], %g4
40008f40: 88 09 00 1b and %g4, %i3, %g4
if ( index >= index_base && index < index_end ) {
40008f44: 80 a1 00 03 cmp %g4, %g3
40008f48: 0a 80 00 08 bcs 40008f68 <_Objects_Shrink_information+0xc4>
40008f4c: f8 00 40 00 ld [ %g1 ], %i4
40008f50: 80 a1 00 02 cmp %g4, %g2
40008f54: 1a 80 00 06 bcc 40008f6c <_Objects_Shrink_information+0xc8>
<== NEVER TAKEN
40008f58: 80 a6 80 1c cmp %i2, %i4
previous = the_node->previous;
40008f5c: c2 00 60 04 ld [ %g1 + 4 ], %g1
next->previous = previous;
40008f60: c2 27 20 04 st %g1, [ %i4 + 4 ]
previous->next = next;
40008f64: f8 20 40 00 st %i4, [ %g1 ]
while ( node != tail ) {
40008f68: 80 a6 80 1c cmp %i2, %i4
40008f6c: 12 bf ff f4 bne 40008f3c <_Objects_Shrink_information+0x98>
40008f70: 82 10 00 1c mov %i4, %g1
_Workspace_Free( information->object_blocks[ block ] );
40008f74: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
40008f78: 40 00 0d 6a call 4000c520 <_Workspace_Free>
40008f7c: d0 00 40 1d ld [ %g1 + %i5 ], %o0
information->object_blocks[ block ] = NULL;
40008f80: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
40008f84: c0 20 40 1d clr [ %g1 + %i5 ]
information->inactive_per_block[ block ] = 0;
40008f88: c4 06 20 30 ld [ %i0 + 0x30 ], %g2
information->inactive -= information->allocation_size;
40008f8c: c2 16 20 2c lduh [ %i0 + 0x2c ], %g1
information->inactive_per_block[ block ] = 0;
40008f90: c0 20 80 1d clr [ %g2 + %i5 ]
information->inactive -= information->allocation_size;
40008f94: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2
40008f98: 82 20 40 02 sub %g1, %g2, %g1
40008f9c: c2 36 20 2c sth %g1, [ %i0 + 0x2c ]
return;
40008fa0: 81 c7 e0 08 ret
40008fa4: 81 e8 00 00 restore
40011dc0 <_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 ) )
{
40011dc0: 9d e3 bf a0 save %sp, -96, %sp
int eno = 0;
if ( *once_state != ONCE_STATE_COMPLETE ) {
40011dc4: c2 0e 00 00 ldub [ %i0 ], %g1
40011dc8: 80 a0 60 02 cmp %g1, 2
40011dcc: 02 80 00 0e be 40011e04 <_Once+0x44>
40011dd0: 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 );
40011dd4: 39 10 00 cb sethi %hi(0x40032c00), %i4
40011dd8: 7f ff f5 d4 call 4000f528 <_API_Mutex_Lock>
40011ddc: 90 17 22 90 or %i4, 0x290, %o0 ! 40032e90 <_Once_Mutex>
switch ( *once_state ) {
40011de0: c2 0e 00 00 ldub [ %i0 ], %g1
40011de4: 80 a0 60 00 cmp %g1, 0
40011de8: 02 80 00 09 be 40011e0c <_Once+0x4c>
<== ALWAYS TAKEN
40011dec: 82 18 60 01 xor %g1, 1, %g1
int eno = 0;
40011df0: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
40011df4: ba 40 3f ff addx %g0, -1, %i5
<== NOT EXECUTED
40011df8: ba 0f 60 16 and %i5, 0x16, %i5
<== NOT EXECUTED
}
void _Once_Unlock( void )
{
_API_Mutex_Unlock( &_Once_Mutex );
40011dfc: 7f ff f5 d7 call 4000f558 <_API_Mutex_Unlock>
40011e00: 90 17 22 90 or %i4, 0x290, %o0
}
40011e04: 81 c7 e0 08 ret
40011e08: 91 e8 00 1d restore %g0, %i5, %o0
*once_state = ONCE_STATE_RUNNING;
40011e0c: 82 10 20 01 mov 1, %g1
( *init_routine )();
40011e10: 9f c6 40 00 call %i1
40011e14: c2 2e 00 00 stb %g1, [ %i0 ]
*once_state = ONCE_STATE_COMPLETE;
40011e18: 82 10 20 02 mov 2, %g1
break;
40011e1c: 10 bf ff f8 b 40011dfc <_Once+0x3c>
40011e20: c2 2e 00 00 stb %g1, [ %i0 ]
4001c7b0 <_Protected_heap_Get_free_information>:
bool _Protected_heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
)
{
4001c7b0: 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();
4001c7b4: 7f ff f5 ac call 40019e64 <_RTEMS_Lock_allocator>
<== NOT EXECUTED
4001c7b8: 01 00 00 00 nop
<== NOT EXECUTED
_Heap_Get_free_information( the_heap, info );
4001c7bc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4001c7c0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001c7c4: 40 00 a0 c1 call 40044ac8 <_Heap_Get_free_information>
<== NOT EXECUTED
4001c7c8: b0 10 20 01 mov 1, %i0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
4001c7cc: 7f ff f5 ab call 40019e78 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4001c7d0: 01 00 00 00 nop
<== NOT EXECUTED
return true;
}
4001c7d4: 81 c7 e0 08 ret
<== NOT EXECUTED
4001c7d8: 81 e8 00 00 restore
<== NOT EXECUTED
40044dcc <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
40044dcc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( !the_heap )
return false;
if ( !the_info )
40044dd0: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
40044dd4: 02 80 00 0e be 40044e0c <_Protected_heap_Get_information+0x40>
<== NOT EXECUTED
40044dd8: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40044ddc: 22 80 00 0d be,a 40044e10 <_Protected_heap_Get_information+0x44>
<== NOT EXECUTED
40044de0: b0 10 20 00 clr %i0
<== NOT EXECUTED
return false;
_RTEMS_Lock_allocator();
40044de4: 7f ff 54 20 call 40019e64 <_RTEMS_Lock_allocator>
<== NOT EXECUTED
40044de8: 01 00 00 00 nop
<== NOT EXECUTED
_Heap_Get_information( the_heap, the_info );
40044dec: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40044df0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40044df4: 40 00 50 28 call 40058e94 <_Heap_Get_information>
<== NOT EXECUTED
40044df8: b0 10 20 01 mov 1, %i0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
40044dfc: 7f ff 54 1f call 40019e78 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40044e00: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
return true;
}
40044e04: 81 c7 e0 08 ret
<== NOT EXECUTED
40044e08: 81 e8 00 00 restore
<== NOT EXECUTED
return false;
40044e0c: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
40044e10: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
40044e14: 81 c7 e0 08 ret
<== NOT EXECUTED
40044e18: 81 e8 00 00 restore
<== NOT EXECUTED
40044e1c <_Protected_heap_Walk>:
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
40044e1c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
enabled = _Thread_Dispatch_disable_level == 0;
40044e20: 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() ) {
40044e24: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40044e28: 02 80 00 04 be 40044e38 <_Protected_heap_Walk+0x1c>
<== NOT EXECUTED
40044e2c: 01 00 00 00 nop
<== NOT EXECUTED
_RTEMS_Lock_allocator();
status = _Heap_Walk( the_heap, source, do_dump );
_RTEMS_Unlock_allocator();
} else {
status = _Heap_Walk( the_heap, source, do_dump );
40044e30: 40 00 50 5c call 40058fa0 <_Heap_Walk>
<== NOT EXECUTED
40044e34: 81 e8 00 00 restore
<== NOT EXECUTED
_RTEMS_Lock_allocator();
40044e38: 7f ff 54 0b call 40019e64 <_RTEMS_Lock_allocator>
<== NOT EXECUTED
40044e3c: 01 00 00 00 nop
<== NOT EXECUTED
status = _Heap_Walk( the_heap, source, do_dump );
40044e40: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
40044e44: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40044e48: 40 00 50 56 call 40058fa0 <_Heap_Walk>
<== NOT EXECUTED
40044e4c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
40044e50: 7f ff 54 0a call 40019e78 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40044e54: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
}
return status;
}
40044e58: 81 c7 e0 08 ret
<== NOT EXECUTED
40044e5c: 81 e8 00 00 restore
<== NOT EXECUTED
40008fd0 <_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 )
40008fd0: c6 02 40 00 ld [ %o1 ], %g3
40008fd4: 80 a0 e0 00 cmp %g3, 0
40008fd8: 02 80 00 d0 be 40009318 <_RBTree_Extract+0x348>
40008fdc: c4 02 60 04 ld [ %o1 + 4 ], %g2
40008fe0: 80 a0 a0 00 cmp %g2, 0
40008fe4: 32 80 00 13 bne,a 40009030 <_RBTree_Extract+0x60>
<== ALWAYS TAKEN
40008fe8: c2 00 80 00 ld [ %g2 ], %g1
40008fec: c2 02 60 08 ld [ %o1 + 8 ], %g1
<== NOT EXECUTED
40008ff0: c8 02 60 0c ld [ %o1 + 0xc ], %g4
<== NOT EXECUTED
40008ff4: c2 20 e0 08 st %g1, [ %g3 + 8 ]
40008ff8: 80 a0 60 00 cmp %g1, 0
40008ffc: 22 80 00 cf be,a 40009338 <_RBTree_Extract+0x368>
40009000: c6 22 00 00 st %g3, [ %o0 ]
40009004: c4 00 40 00 ld [ %g1 ], %g2
40009008: 80 a2 40 02 cmp %o1, %g2
4000900c: 22 80 00 d3 be,a 40009358 <_RBTree_Extract+0x388>
<== ALWAYS TAKEN
40009010: c6 20 40 00 st %g3, [ %g1 ]
40009014: c6 20 60 04 st %g3, [ %g1 + 4 ]
<== NOT EXECUTED
40009018: 80 a1 20 00 cmp %g4, 0
<== NOT EXECUTED
4000901c: 02 80 00 55 be 40009170 <_RBTree_Extract+0x1a0>
<== NOT EXECUTED
40009020: 9a 10 20 01 mov 1, %o5
<== NOT EXECUTED
)
{
_Assert( _RBTree_Find_root( the_node ) == _RBTree_Root( the_rbtree ) );
RB_REMOVE( RBTree_Control, the_rbtree, the_node );
_RBTree_Initialize_node( the_node );
}
40009024: 81 c3 e0 08 retl
40009028: 01 00 00 00 nop
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
4000902c: c2 00 80 00 ld [ %g2 ], %g1
40009030: 80 a0 60 00 cmp %g1, 0
40009034: 32 bf ff fe bne,a 4000902c <_RBTree_Extract+0x5c>
40009038: 84 10 00 01 mov %g1, %g2
4000903c: c6 00 a0 04 ld [ %g2 + 4 ], %g3
40009040: c2 00 a0 08 ld [ %g2 + 8 ], %g1
40009044: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
40009048: 80 a0 e0 00 cmp %g3, 0
4000904c: 02 80 00 04 be 4000905c <_RBTree_Extract+0x8c>
<== ALWAYS TAKEN
40009050: 9a 10 00 01 mov %g1, %o5
40009054: c2 20 e0 08 st %g1, [ %g3 + 8 ]
<== NOT EXECUTED
40009058: da 00 a0 08 ld [ %g2 + 8 ], %o5
<== NOT EXECUTED
4000905c: 80 a0 60 00 cmp %g1, 0
40009060: 22 80 00 07 be,a 4000907c <_RBTree_Extract+0xac>
<== NEVER TAKEN
40009064: c6 22 00 00 st %g3, [ %o0 ]
<== NOT EXECUTED
40009068: d8 00 40 00 ld [ %g1 ], %o4
4000906c: 80 a0 80 0c cmp %g2, %o4
40009070: 22 80 00 03 be,a 4000907c <_RBTree_Extract+0xac>
40009074: c6 20 40 00 st %g3, [ %g1 ]
40009078: c6 20 60 04 st %g3, [ %g1 + 4 ]
4000907c: 80 a2 40 0d cmp %o1, %o5
40009080: 22 80 00 02 be,a 40009088 <_RBTree_Extract+0xb8>
40009084: 82 10 00 02 mov %g2, %g1
40009088: da 02 40 00 ld [ %o1 ], %o5
4000908c: da 20 80 00 st %o5, [ %g2 ]
40009090: da 02 60 04 ld [ %o1 + 4 ], %o5
40009094: da 20 a0 04 st %o5, [ %g2 + 4 ]
40009098: da 02 60 08 ld [ %o1 + 8 ], %o5
4000909c: da 20 a0 08 st %o5, [ %g2 + 8 ]
400090a0: da 02 60 0c ld [ %o1 + 0xc ], %o5
400090a4: da 20 a0 0c st %o5, [ %g2 + 0xc ]
400090a8: da 02 60 08 ld [ %o1 + 8 ], %o5
400090ac: 80 a3 60 00 cmp %o5, 0
400090b0: 22 80 00 07 be,a 400090cc <_RBTree_Extract+0xfc>
<== ALWAYS TAKEN
400090b4: c4 22 00 00 st %g2, [ %o0 ]
400090b8: d8 03 40 00 ld [ %o5 ], %o4
<== NOT EXECUTED
400090bc: 80 a2 40 0c cmp %o1, %o4
<== NOT EXECUTED
400090c0: 22 80 00 03 be,a 400090cc <_RBTree_Extract+0xfc>
<== NOT EXECUTED
400090c4: c4 23 40 00 st %g2, [ %o5 ]
<== NOT EXECUTED
400090c8: c4 23 60 04 st %g2, [ %o5 + 4 ]
<== NOT EXECUTED
400090cc: da 02 40 00 ld [ %o1 ], %o5
400090d0: c4 23 60 08 st %g2, [ %o5 + 8 ]
400090d4: da 02 60 04 ld [ %o1 + 4 ], %o5
400090d8: 80 a3 60 00 cmp %o5, 0
400090dc: 32 80 00 02 bne,a 400090e4 <_RBTree_Extract+0x114>
400090e0: c4 23 60 08 st %g2, [ %o5 + 8 ]
400090e4: 80 a0 60 00 cmp %g1, 0
400090e8: 02 bf ff cc be 40009018 <_RBTree_Extract+0x48>
<== NEVER TAKEN
400090ec: 84 10 00 01 mov %g1, %g2
400090f0: c4 00 a0 08 ld [ %g2 + 8 ], %g2
400090f4: 80 a0 a0 00 cmp %g2, 0
400090f8: 32 bf ff ff bne,a 400090f4 <_RBTree_Extract+0x124>
400090fc: c4 00 a0 08 ld [ %g2 + 8 ], %g2
40009100: 80 a1 20 00 cmp %g4, 0
40009104: 12 bf ff c8 bne 40009024 <_RBTree_Extract+0x54>
<== ALWAYS TAKEN
40009108: 9a 10 20 01 mov 1, %o5
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
4000910c: 10 80 00 1a b 40009174 <_RBTree_Extract+0x1a4>
<== NOT EXECUTED
40009110: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40009114: 80 a0 e0 01 cmp %g3, 1
<== NOT EXECUTED
40009118: 22 80 00 54 be,a 40009268 <_RBTree_Extract+0x298>
<== NOT EXECUTED
4000911c: c8 00 a0 04 ld [ %g2 + 4 ], %g4
<== NOT EXECUTED
40009120: c6 00 80 00 ld [ %g2 ], %g3
<== NOT EXECUTED
40009124: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40009128: 22 80 00 07 be,a 40009144 <_RBTree_Extract+0x174>
<== NOT EXECUTED
4000912c: c8 00 a0 04 ld [ %g2 + 4 ], %g4
<== NOT EXECUTED
40009130: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
<== NOT EXECUTED
40009134: 80 a1 20 00 cmp %g4, 0
<== NOT EXECUTED
40009138: 32 80 00 98 bne,a 40009398 <_RBTree_Extract+0x3c8>
<== NOT EXECUTED
4000913c: da 00 60 0c ld [ %g1 + 0xc ], %o5
<== NOT EXECUTED
40009140: c8 00 a0 04 ld [ %g2 + 4 ], %g4
<== NOT EXECUTED
40009144: 80 a1 20 00 cmp %g4, 0
<== NOT EXECUTED
40009148: 22 80 00 07 be,a 40009164 <_RBTree_Extract+0x194>
<== NOT EXECUTED
4000914c: da 20 a0 0c st %o5, [ %g2 + 0xc ]
<== NOT EXECUTED
40009150: d8 01 20 0c ld [ %g4 + 0xc ], %o4
<== NOT EXECUTED
40009154: 80 a3 20 00 cmp %o4, 0
<== NOT EXECUTED
40009158: 12 80 00 89 bne 4000937c <_RBTree_Extract+0x3ac>
<== NOT EXECUTED
4000915c: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40009160: da 20 a0 0c st %o5, [ %g2 + 0xc ]
<== NOT EXECUTED
40009164: 86 10 00 01 mov %g1, %g3
40009168: c4 00 60 08 ld [ %g1 + 8 ], %g2
4000916c: 82 10 00 02 mov %g2, %g1
40009170: 80 a0 e0 00 cmp %g3, 0
40009174: 22 80 00 07 be,a 40009190 <_RBTree_Extract+0x1c0>
40009178: c4 02 00 00 ld [ %o0 ], %g2
4000917c: c4 00 e0 0c ld [ %g3 + 0xc ], %g2
40009180: 80 a0 a0 00 cmp %g2, 0
40009184: 12 80 00 37 bne 40009260 <_RBTree_Extract+0x290>
40009188: 01 00 00 00 nop
4000918c: c4 02 00 00 ld [ %o0 ], %g2
40009190: 80 a0 c0 02 cmp %g3, %g2
40009194: 02 80 00 31 be 40009258 <_RBTree_Extract+0x288>
40009198: 80 a0 e0 00 cmp %g3, 0
4000919c: c4 00 40 00 ld [ %g1 ], %g2
400091a0: 80 a0 80 03 cmp %g2, %g3
400091a4: 32 bf ff dc bne,a 40009114 <_RBTree_Extract+0x144>
<== NEVER TAKEN
400091a8: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
<== NOT EXECUTED
400091ac: c4 00 60 04 ld [ %g1 + 4 ], %g2
400091b0: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
400091b4: 80 a1 20 01 cmp %g4, 1
400091b8: 02 80 00 40 be 400092b8 <_RBTree_Extract+0x2e8>
<== NEVER TAKEN
400091bc: c6 00 80 00 ld [ %g2 ], %g3
400091c0: 80 a0 e0 00 cmp %g3, 0
400091c4: 22 80 00 06 be,a 400091dc <_RBTree_Extract+0x20c>
400091c8: c8 00 a0 04 ld [ %g2 + 4 ], %g4
400091cc: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
400091d0: 80 a1 20 00 cmp %g4, 0
400091d4: 12 80 00 ac bne 40009484 <_RBTree_Extract+0x4b4>
<== ALWAYS TAKEN
400091d8: c8 00 a0 04 ld [ %g2 + 4 ], %g4
400091dc: 80 a1 20 00 cmp %g4, 0
400091e0: 22 bf ff e1 be,a 40009164 <_RBTree_Extract+0x194>
<== ALWAYS TAKEN
400091e4: da 20 a0 0c st %o5, [ %g2 + 0xc ]
400091e8: c6 01 20 0c ld [ %g4 + 0xc ], %g3
<== NOT EXECUTED
400091ec: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
400091f0: 22 bf ff dd be,a 40009164 <_RBTree_Extract+0x194>
<== NOT EXECUTED
400091f4: da 20 a0 0c st %o5, [ %g2 + 0xc ]
<== NOT EXECUTED
400091f8: c6 00 60 0c ld [ %g1 + 0xc ], %g3
<== NOT EXECUTED
400091fc: da 00 60 04 ld [ %g1 + 4 ], %o5
40009200: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
40009204: c0 20 60 0c clr [ %g1 + 0xc ]
40009208: c0 21 20 0c clr [ %g4 + 0xc ]
4000920c: c4 03 40 00 ld [ %o5 ], %g2
40009210: 80 a0 a0 00 cmp %g2, 0
40009214: 02 80 00 03 be 40009220 <_RBTree_Extract+0x250>
40009218: c4 20 60 04 st %g2, [ %g1 + 4 ]
4000921c: c2 20 a0 08 st %g1, [ %g2 + 8 ]
40009220: c4 00 60 08 ld [ %g1 + 8 ], %g2
40009224: 80 a0 a0 00 cmp %g2, 0
40009228: 02 80 00 c1 be 4000952c <_RBTree_Extract+0x55c>
<== ALWAYS TAKEN
4000922c: c4 23 60 08 st %g2, [ %o5 + 8 ]
40009230: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
40009234: c6 00 80 00 ld [ %g2 ], %g3
<== NOT EXECUTED
40009238: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
4000923c: 22 80 00 c1 be,a 40009540 <_RBTree_Extract+0x570>
<== NOT EXECUTED
40009240: da 20 80 00 st %o5, [ %g2 ]
<== NOT EXECUTED
40009244: da 20 a0 04 st %o5, [ %g2 + 4 ]
<== NOT EXECUTED
40009248: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
4000924c: c2 23 40 00 st %g1, [ %o5 ]
<== NOT EXECUTED
40009250: da 20 60 08 st %o5, [ %g1 + 8 ]
<== NOT EXECUTED
40009254: 80 a0 e0 00 cmp %g3, 0
40009258: 02 bf ff 73 be 40009024 <_RBTree_Extract+0x54>
4000925c: 01 00 00 00 nop
}
40009260: 81 c3 e0 08 retl
40009264: c0 20 e0 0c clr [ %g3 + 0xc ]
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
40009268: c0 20 a0 0c clr [ %g2 + 0xc ]
<== NOT EXECUTED
4000926c: 80 a1 20 00 cmp %g4, 0
<== NOT EXECUTED
40009270: c6 20 60 0c st %g3, [ %g1 + 0xc ]
<== NOT EXECUTED
40009274: 02 80 00 03 be 40009280 <_RBTree_Extract+0x2b0>
<== NOT EXECUTED
40009278: c8 20 40 00 st %g4, [ %g1 ]
<== NOT EXECUTED
4000927c: c2 21 20 08 st %g1, [ %g4 + 8 ]
<== NOT EXECUTED
40009280: c6 00 60 08 ld [ %g1 + 8 ], %g3
<== NOT EXECUTED
40009284: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40009288: 02 80 00 22 be 40009310 <_RBTree_Extract+0x340>
<== NOT EXECUTED
4000928c: c6 20 a0 08 st %g3, [ %g2 + 8 ]
<== NOT EXECUTED
40009290: c6 00 60 08 ld [ %g1 + 8 ], %g3
<== NOT EXECUTED
40009294: d8 00 c0 00 ld [ %g3 ], %o4
<== NOT EXECUTED
40009298: 80 a0 40 0c cmp %g1, %o4
<== NOT EXECUTED
4000929c: 22 80 00 25 be,a 40009330 <_RBTree_Extract+0x360>
<== NOT EXECUTED
400092a0: c4 20 c0 00 st %g2, [ %g3 ]
<== NOT EXECUTED
400092a4: c4 20 e0 04 st %g2, [ %g3 + 4 ]
<== NOT EXECUTED
400092a8: c2 20 a0 04 st %g1, [ %g2 + 4 ]
<== NOT EXECUTED
400092ac: c4 20 60 08 st %g2, [ %g1 + 8 ]
<== NOT EXECUTED
400092b0: 10 bf ff 9c b 40009120 <_RBTree_Extract+0x150>
<== NOT EXECUTED
400092b4: 84 10 00 04 mov %g4, %g2
<== NOT EXECUTED
400092b8: c0 20 a0 0c clr [ %g2 + 0xc ]
<== NOT EXECUTED
400092bc: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
400092c0: c8 20 60 0c st %g4, [ %g1 + 0xc ]
<== NOT EXECUTED
400092c4: 02 80 00 03 be 400092d0 <_RBTree_Extract+0x300>
<== NOT EXECUTED
400092c8: c6 20 60 04 st %g3, [ %g1 + 4 ]
<== NOT EXECUTED
400092cc: c2 20 e0 08 st %g1, [ %g3 + 8 ]
<== NOT EXECUTED
400092d0: c8 00 60 08 ld [ %g1 + 8 ], %g4
<== NOT EXECUTED
400092d4: 80 a1 20 00 cmp %g4, 0
<== NOT EXECUTED
400092d8: 02 80 00 1d be 4000934c <_RBTree_Extract+0x37c>
<== NOT EXECUTED
400092dc: c8 20 a0 08 st %g4, [ %g2 + 8 ]
<== NOT EXECUTED
400092e0: c8 00 60 08 ld [ %g1 + 8 ], %g4
<== NOT EXECUTED
400092e4: d8 01 00 00 ld [ %g4 ], %o4
<== NOT EXECUTED
400092e8: 80 a0 40 0c cmp %g1, %o4
<== NOT EXECUTED
400092ec: 22 80 00 22 be,a 40009374 <_RBTree_Extract+0x3a4>
<== NOT EXECUTED
400092f0: c4 21 00 00 st %g2, [ %g4 ]
<== NOT EXECUTED
400092f4: c4 21 20 04 st %g2, [ %g4 + 4 ]
<== NOT EXECUTED
400092f8: c8 00 60 04 ld [ %g1 + 4 ], %g4
<== NOT EXECUTED
400092fc: c2 20 80 00 st %g1, [ %g2 ]
<== NOT EXECUTED
40009300: c6 01 00 00 ld [ %g4 ], %g3
<== NOT EXECUTED
40009304: c4 20 60 08 st %g2, [ %g1 + 8 ]
<== NOT EXECUTED
40009308: 10 bf ff ae b 400091c0 <_RBTree_Extract+0x1f0>
<== NOT EXECUTED
4000930c: 84 10 00 04 mov %g4, %g2
<== NOT EXECUTED
40009310: 10 bf ff e6 b 400092a8 <_RBTree_Extract+0x2d8>
<== NOT EXECUTED
40009314: c4 22 00 00 st %g2, [ %o0 ]
<== NOT EXECUTED
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
40009318: c2 02 60 08 ld [ %o1 + 8 ], %g1
4000931c: 80 a0 a0 00 cmp %g2, 0
40009320: 02 bf ff 36 be 40008ff8 <_RBTree_Extract+0x28>
40009324: c8 02 60 0c ld [ %o1 + 0xc ], %g4
40009328: 10 bf ff 33 b 40008ff4 <_RBTree_Extract+0x24>
4000932c: 86 10 00 02 mov %g2, %g3
40009330: 10 bf ff de b 400092a8 <_RBTree_Extract+0x2d8>
<== NOT EXECUTED
40009334: c8 00 40 00 ld [ %g1 ], %g4
<== NOT EXECUTED
40009338: 80 a1 20 00 cmp %g4, 0
4000933c: 12 bf ff 3a bne 40009024 <_RBTree_Extract+0x54>
<== NEVER TAKEN
40009340: 9a 10 20 01 mov 1, %o5
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
40009344: 10 bf ff 8c b 40009174 <_RBTree_Extract+0x1a4>
40009348: 80 a0 e0 00 cmp %g3, 0
4000934c: c4 22 00 00 st %g2, [ %o0 ]
<== NOT EXECUTED
40009350: 10 bf ff eb b 400092fc <_RBTree_Extract+0x32c>
<== NOT EXECUTED
40009354: 88 10 00 03 mov %g3, %g4
<== NOT EXECUTED
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
40009358: 80 a1 20 00 cmp %g4, 0
4000935c: 12 bf ff 32 bne 40009024 <_RBTree_Extract+0x54>
40009360: 9a 10 20 01 mov 1, %o5
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
40009364: 10 bf ff 84 b 40009174 <_RBTree_Extract+0x1a4>
40009368: 80 a0 e0 00 cmp %g3, 0
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
4000936c: 10 bf ff 58 b 400090cc <_RBTree_Extract+0xfc>
<== NOT EXECUTED
40009370: c4 23 40 00 st %g2, [ %o5 ]
<== NOT EXECUTED
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
40009374: 10 bf ff e2 b 400092fc <_RBTree_Extract+0x32c>
<== NOT EXECUTED
40009378: 88 10 00 03 mov %g3, %g4
<== NOT EXECUTED
4000937c: 22 80 00 21 be,a 40009400 <_RBTree_Extract+0x430>
<== NOT EXECUTED
40009380: c6 01 00 00 ld [ %g4 ], %g3
<== NOT EXECUTED
40009384: da 00 e0 0c ld [ %g3 + 0xc ], %o5
<== NOT EXECUTED
40009388: 80 a3 60 00 cmp %o5, 0
<== NOT EXECUTED
4000938c: 22 80 00 1d be,a 40009400 <_RBTree_Extract+0x430>
<== NOT EXECUTED
40009390: c6 01 00 00 ld [ %g4 ], %g3
<== NOT EXECUTED
40009394: da 00 60 0c ld [ %g1 + 0xc ], %o5
<== NOT EXECUTED
40009398: c8 00 40 00 ld [ %g1 ], %g4
<== NOT EXECUTED
4000939c: da 20 a0 0c st %o5, [ %g2 + 0xc ]
<== NOT EXECUTED
400093a0: c0 20 60 0c clr [ %g1 + 0xc ]
<== NOT EXECUTED
400093a4: c0 20 e0 0c clr [ %g3 + 0xc ]
<== NOT EXECUTED
400093a8: c4 01 20 04 ld [ %g4 + 4 ], %g2
<== NOT EXECUTED
400093ac: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
400093b0: 02 80 00 03 be 400093bc <_RBTree_Extract+0x3ec>
<== NOT EXECUTED
400093b4: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
400093b8: c2 20 a0 08 st %g1, [ %g2 + 8 ]
<== NOT EXECUTED
400093bc: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
400093c0: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
400093c4: 02 80 00 2b be 40009470 <_RBTree_Extract+0x4a0>
<== NOT EXECUTED
400093c8: c4 21 20 08 st %g2, [ %g4 + 8 ]
<== NOT EXECUTED
400093cc: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
400093d0: c6 00 80 00 ld [ %g2 ], %g3
<== NOT EXECUTED
400093d4: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
400093d8: 22 80 00 4f be,a 40009514 <_RBTree_Extract+0x544>
<== NOT EXECUTED
400093dc: c8 20 80 00 st %g4, [ %g2 ]
<== NOT EXECUTED
400093e0: c8 20 a0 04 st %g4, [ %g2 + 4 ]
<== NOT EXECUTED
400093e4: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
400093e8: c2 21 20 04 st %g1, [ %g4 + 4 ]
<== NOT EXECUTED
400093ec: c8 20 60 08 st %g4, [ %g1 + 8 ]
<== NOT EXECUTED
400093f0: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
400093f4: 12 bf ff 9b bne 40009260 <_RBTree_Extract+0x290>
<== NOT EXECUTED
400093f8: 01 00 00 00 nop
<== NOT EXECUTED
400093fc: 30 bf ff 0a b,a 40009024 <_RBTree_Extract+0x54>
<== NOT EXECUTED
40009400: c0 21 20 0c clr [ %g4 + 0xc ]
<== NOT EXECUTED
40009404: 9a 10 20 01 mov 1, %o5
<== NOT EXECUTED
40009408: c6 20 a0 04 st %g3, [ %g2 + 4 ]
<== NOT EXECUTED
4000940c: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40009410: 02 80 00 03 be 4000941c <_RBTree_Extract+0x44c>
<== NOT EXECUTED
40009414: da 20 a0 0c st %o5, [ %g2 + 0xc ]
<== NOT EXECUTED
40009418: c4 20 e0 08 st %g2, [ %g3 + 8 ]
<== NOT EXECUTED
4000941c: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
40009420: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40009424: 02 80 00 40 be 40009524 <_RBTree_Extract+0x554>
<== NOT EXECUTED
40009428: c6 21 20 08 st %g3, [ %g4 + 8 ]
<== NOT EXECUTED
4000942c: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
40009430: da 00 c0 00 ld [ %g3 ], %o5
<== NOT EXECUTED
40009434: 80 a0 80 0d cmp %g2, %o5
<== NOT EXECUTED
40009438: 22 80 00 03 be,a 40009444 <_RBTree_Extract+0x474>
<== NOT EXECUTED
4000943c: c8 20 c0 00 st %g4, [ %g3 ]
<== NOT EXECUTED
40009440: c8 20 e0 04 st %g4, [ %g3 + 4 ]
<== NOT EXECUTED
40009444: c4 21 00 00 st %g2, [ %g4 ]
<== NOT EXECUTED
40009448: c8 20 a0 08 st %g4, [ %g2 + 8 ]
<== NOT EXECUTED
4000944c: c8 00 40 00 ld [ %g1 ], %g4
<== NOT EXECUTED
40009450: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
40009454: c4 21 20 0c st %g2, [ %g4 + 0xc ]
<== NOT EXECUTED
40009458: c6 01 00 00 ld [ %g4 ], %g3
<== NOT EXECUTED
4000945c: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40009460: 02 bf ff d2 be 400093a8 <_RBTree_Extract+0x3d8>
<== NOT EXECUTED
40009464: c0 20 60 0c clr [ %g1 + 0xc ]
<== NOT EXECUTED
40009468: 10 bf ff d0 b 400093a8 <_RBTree_Extract+0x3d8>
<== NOT EXECUTED
4000946c: c0 20 e0 0c clr [ %g3 + 0xc ]
<== NOT EXECUTED
40009470: c8 22 00 00 st %g4, [ %o0 ]
<== NOT EXECUTED
40009474: 86 10 00 04 mov %g4, %g3
<== NOT EXECUTED
40009478: c2 21 20 04 st %g1, [ %g4 + 4 ]
<== NOT EXECUTED
4000947c: 10 bf ff dd b 400093f0 <_RBTree_Extract+0x420>
<== NOT EXECUTED
40009480: c8 20 60 08 st %g4, [ %g1 + 8 ]
<== NOT EXECUTED
40009484: 80 a1 20 00 cmp %g4, 0
40009488: 22 80 00 07 be,a 400094a4 <_RBTree_Extract+0x4d4>
4000948c: c8 00 e0 04 ld [ %g3 + 4 ], %g4
40009490: da 01 20 0c ld [ %g4 + 0xc ], %o5
40009494: 80 a3 60 00 cmp %o5, 0
40009498: 32 bf ff 59 bne,a 400091fc <_RBTree_Extract+0x22c>
<== ALWAYS TAKEN
4000949c: c6 00 60 0c ld [ %g1 + 0xc ], %g3
400094a0: c8 00 e0 04 ld [ %g3 + 4 ], %g4
<== NOT EXECUTED
400094a4: c0 20 e0 0c clr [ %g3 + 0xc ]
400094a8: 9a 10 20 01 mov 1, %o5
400094ac: c8 20 80 00 st %g4, [ %g2 ]
400094b0: 80 a1 20 00 cmp %g4, 0
400094b4: 02 80 00 03 be 400094c0 <_RBTree_Extract+0x4f0>
<== ALWAYS TAKEN
400094b8: da 20 a0 0c st %o5, [ %g2 + 0xc ]
400094bc: c4 21 20 08 st %g2, [ %g4 + 8 ]
<== NOT EXECUTED
400094c0: c8 00 a0 08 ld [ %g2 + 8 ], %g4
400094c4: 80 a1 20 00 cmp %g4, 0
400094c8: 02 80 00 22 be 40009550 <_RBTree_Extract+0x580>
<== NEVER TAKEN
400094cc: c8 20 e0 08 st %g4, [ %g3 + 8 ]
400094d0: c8 00 a0 08 ld [ %g2 + 8 ], %g4
400094d4: da 01 00 00 ld [ %g4 ], %o5
400094d8: 80 a0 80 0d cmp %g2, %o5
400094dc: 22 80 00 03 be,a 400094e8 <_RBTree_Extract+0x518>
<== NEVER TAKEN
400094e0: c6 21 00 00 st %g3, [ %g4 ]
<== NOT EXECUTED
400094e4: c6 21 20 04 st %g3, [ %g4 + 4 ]
400094e8: c4 20 e0 04 st %g2, [ %g3 + 4 ]
400094ec: c6 20 a0 08 st %g3, [ %g2 + 8 ]
400094f0: da 00 60 04 ld [ %g1 + 4 ], %o5
400094f4: c4 00 60 0c ld [ %g1 + 0xc ], %g2
400094f8: c4 23 60 0c st %g2, [ %o5 + 0xc ]
400094fc: c8 03 60 04 ld [ %o5 + 4 ], %g4
40009500: 80 a1 20 00 cmp %g4, 0
40009504: 02 bf ff 42 be 4000920c <_RBTree_Extract+0x23c>
<== NEVER TAKEN
40009508: c0 20 60 0c clr [ %g1 + 0xc ]
4000950c: 10 bf ff 40 b 4000920c <_RBTree_Extract+0x23c>
40009510: c0 21 20 0c clr [ %g4 + 0xc ]
40009514: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
40009518: c2 21 20 04 st %g1, [ %g4 + 4 ]
<== NOT EXECUTED
4000951c: 10 bf ff b5 b 400093f0 <_RBTree_Extract+0x420>
<== NOT EXECUTED
40009520: c8 20 60 08 st %g4, [ %g1 + 8 ]
<== NOT EXECUTED
40009524: 10 bf ff c8 b 40009444 <_RBTree_Extract+0x474>
<== NOT EXECUTED
40009528: c8 22 00 00 st %g4, [ %o0 ]
<== NOT EXECUTED
4000952c: da 22 00 00 st %o5, [ %o0 ]
40009530: 86 10 00 0d mov %o5, %g3
40009534: c2 23 40 00 st %g1, [ %o5 ]
40009538: 10 bf ff 47 b 40009254 <_RBTree_Extract+0x284>
4000953c: da 20 60 08 st %o5, [ %g1 + 8 ]
40009540: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
40009544: c2 23 40 00 st %g1, [ %o5 ]
<== NOT EXECUTED
40009548: 10 bf ff 43 b 40009254 <_RBTree_Extract+0x284>
<== NOT EXECUTED
4000954c: da 20 60 08 st %o5, [ %g1 + 8 ]
<== NOT EXECUTED
40009550: 10 bf ff e6 b 400094e8 <_RBTree_Extract+0x518>
<== NOT EXECUTED
40009554: c6 22 00 00 st %g3, [ %o0 ]
<== NOT EXECUTED
40009558 <_RBTree_Insert_color>:
#include "config.h"
#endif
#include <rtems/score/rbtreeimpl.h>
RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline )
40009558: 98 10 20 01 mov 1, %o4
4000955c: c2 02 60 08 ld [ %o1 + 8 ], %g1
40009560: 80 a0 60 00 cmp %g1, 0
40009564: 22 80 00 2f be,a 40009620 <_RBTree_Insert_color+0xc8>
40009568: c2 02 00 00 ld [ %o0 ], %g1
4000956c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40009570: 80 a0 a0 01 cmp %g2, 1
40009574: 32 80 00 2b bne,a 40009620 <_RBTree_Insert_color+0xc8>
40009578: c2 02 00 00 ld [ %o0 ], %g1
4000957c: c6 00 60 08 ld [ %g1 + 8 ], %g3
40009580: c8 00 c0 00 ld [ %g3 ], %g4
40009584: 80 a0 40 04 cmp %g1, %g4
40009588: 02 80 00 28 be 40009628 <_RBTree_Insert_color+0xd0>
4000958c: 84 10 00 03 mov %g3, %g2
40009590: 80 a1 20 00 cmp %g4, 0
40009594: 22 80 00 07 be,a 400095b0 <_RBTree_Insert_color+0x58>
40009598: c8 00 40 00 ld [ %g1 ], %g4
4000959c: da 01 20 0c ld [ %g4 + 0xc ], %o5
400095a0: 80 a3 60 01 cmp %o5, 1
400095a4: 22 80 00 58 be,a 40009704 <_RBTree_Insert_color+0x1ac>
<== ALWAYS TAKEN
400095a8: c0 21 20 0c clr [ %g4 + 0xc ]
400095ac: c8 00 40 00 ld [ %g1 ], %g4
<== NOT EXECUTED
400095b0: 80 a2 40 04 cmp %o1, %g4
400095b4: 22 80 00 3c be,a 400096a4 <_RBTree_Insert_color+0x14c>
400095b8: c8 02 60 04 ld [ %o1 + 4 ], %g4
400095bc: c6 00 a0 04 ld [ %g2 + 4 ], %g3
400095c0: c0 20 60 0c clr [ %g1 + 0xc ]
400095c4: c2 00 c0 00 ld [ %g3 ], %g1
400095c8: c2 20 a0 04 st %g1, [ %g2 + 4 ]
400095cc: 80 a0 60 00 cmp %g1, 0
400095d0: 02 80 00 03 be 400095dc <_RBTree_Insert_color+0x84>
<== ALWAYS TAKEN
400095d4: d8 20 a0 0c st %o4, [ %g2 + 0xc ]
400095d8: c4 20 60 08 st %g2, [ %g1 + 8 ]
<== NOT EXECUTED
400095dc: c2 00 a0 08 ld [ %g2 + 8 ], %g1
400095e0: 80 a0 60 00 cmp %g1, 0
400095e4: 02 80 00 44 be 400096f4 <_RBTree_Insert_color+0x19c>
<== ALWAYS TAKEN
400095e8: c2 20 e0 08 st %g1, [ %g3 + 8 ]
400095ec: c2 00 a0 08 ld [ %g2 + 8 ], %g1
<== NOT EXECUTED
400095f0: c8 00 40 00 ld [ %g1 ], %g4
<== NOT EXECUTED
400095f4: 80 a0 80 04 cmp %g2, %g4
<== NOT EXECUTED
400095f8: 22 80 00 47 be,a 40009714 <_RBTree_Insert_color+0x1bc>
<== NOT EXECUTED
400095fc: c6 20 40 00 st %g3, [ %g1 ]
<== NOT EXECUTED
40009600: c6 20 60 04 st %g3, [ %g1 + 4 ]
<== NOT EXECUTED
40009604: c4 20 c0 00 st %g2, [ %g3 ]
<== NOT EXECUTED
40009608: c6 20 a0 08 st %g3, [ %g2 + 8 ]
<== NOT EXECUTED
4000960c: c2 02 60 08 ld [ %o1 + 8 ], %g1
40009610: 80 a0 60 00 cmp %g1, 0
40009614: 32 bf ff d7 bne,a 40009570 <_RBTree_Insert_color+0x18>
<== ALWAYS TAKEN
40009618: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000961c: 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 );
}
40009620: 81 c3 e0 08 retl
40009624: c0 20 60 0c clr [ %g1 + 0xc ]
RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline )
40009628: c8 00 e0 04 ld [ %g3 + 4 ], %g4
4000962c: 80 a1 20 00 cmp %g4, 0
40009630: 22 80 00 07 be,a 4000964c <_RBTree_Insert_color+0xf4>
<== ALWAYS TAKEN
40009634: da 00 60 04 ld [ %g1 + 4 ], %o5
40009638: da 01 20 0c ld [ %g4 + 0xc ], %o5
<== NOT EXECUTED
4000963c: 80 a3 60 01 cmp %o5, 1
<== NOT EXECUTED
40009640: 22 80 00 31 be,a 40009704 <_RBTree_Insert_color+0x1ac>
<== NOT EXECUTED
40009644: c0 21 20 0c clr [ %g4 + 0xc ]
<== NOT EXECUTED
40009648: da 00 60 04 ld [ %g1 + 4 ], %o5
<== NOT EXECUTED
4000964c: 80 a3 40 09 cmp %o5, %o1
40009650: 02 80 00 3a be 40009738 <_RBTree_Insert_color+0x1e0>
40009654: 88 10 00 01 mov %g1, %g4
40009658: c0 20 60 0c clr [ %g1 + 0xc ]
4000965c: 80 a3 60 00 cmp %o5, 0
40009660: d8 20 a0 0c st %o4, [ %g2 + 0xc ]
40009664: 02 80 00 03 be 40009670 <_RBTree_Insert_color+0x118>
<== ALWAYS TAKEN
40009668: da 20 80 00 st %o5, [ %g2 ]
4000966c: c4 23 60 08 st %g2, [ %o5 + 8 ]
<== NOT EXECUTED
40009670: c2 00 a0 08 ld [ %g2 + 8 ], %g1
40009674: 80 a0 60 00 cmp %g1, 0
40009678: 02 80 00 2c be 40009728 <_RBTree_Insert_color+0x1d0>
4000967c: c2 21 20 08 st %g1, [ %g4 + 8 ]
40009680: c2 00 a0 08 ld [ %g2 + 8 ], %g1
40009684: c6 00 40 00 ld [ %g1 ], %g3
40009688: 80 a0 80 03 cmp %g2, %g3
4000968c: 22 80 00 4a be,a 400097b4 <_RBTree_Insert_color+0x25c>
<== NEVER TAKEN
40009690: c8 20 40 00 st %g4, [ %g1 ]
<== NOT EXECUTED
40009694: c8 20 60 04 st %g4, [ %g1 + 4 ]
40009698: c4 21 20 04 st %g2, [ %g4 + 4 ]
4000969c: 10 bf ff b0 b 4000955c <_RBTree_Insert_color+0x4>
400096a0: c8 20 a0 08 st %g4, [ %g2 + 8 ]
400096a4: 80 a1 20 00 cmp %g4, 0
400096a8: 02 80 00 3b be 40009794 <_RBTree_Insert_color+0x23c>
<== ALWAYS TAKEN
400096ac: c8 20 40 00 st %g4, [ %g1 ]
400096b0: c2 21 20 08 st %g1, [ %g4 + 8 ]
<== NOT EXECUTED
400096b4: c6 00 60 08 ld [ %g1 + 8 ], %g3
<== NOT EXECUTED
400096b8: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
400096bc: 02 80 00 19 be 40009720 <_RBTree_Insert_color+0x1c8>
<== NOT EXECUTED
400096c0: c6 22 60 08 st %g3, [ %o1 + 8 ]
<== NOT EXECUTED
400096c4: c6 00 60 08 ld [ %g1 + 8 ], %g3
<== NOT EXECUTED
400096c8: c8 00 c0 00 ld [ %g3 ], %g4
<== NOT EXECUTED
400096cc: 80 a0 40 04 cmp %g1, %g4
<== NOT EXECUTED
400096d0: 22 80 00 03 be,a 400096dc <_RBTree_Insert_color+0x184>
<== NOT EXECUTED
400096d4: d2 20 c0 00 st %o1, [ %g3 ]
<== NOT EXECUTED
400096d8: d2 20 e0 04 st %o1, [ %g3 + 4 ]
<== NOT EXECUTED
400096dc: 86 10 00 09 mov %o1, %g3
400096e0: c2 22 60 04 st %g1, [ %o1 + 4 ]
400096e4: d2 20 60 08 st %o1, [ %g1 + 8 ]
400096e8: 92 10 00 01 mov %g1, %o1
400096ec: 10 bf ff b4 b 400095bc <_RBTree_Insert_color+0x64>
400096f0: 82 10 00 03 mov %g3, %g1
400096f4: c6 22 00 00 st %g3, [ %o0 ]
400096f8: c4 20 c0 00 st %g2, [ %g3 ]
400096fc: 10 bf ff c4 b 4000960c <_RBTree_Insert_color+0xb4>
40009700: c6 20 a0 08 st %g3, [ %g2 + 8 ]
40009704: 92 10 00 03 mov %g3, %o1
40009708: c0 20 60 0c clr [ %g1 + 0xc ]
4000970c: 10 bf ff 94 b 4000955c <_RBTree_Insert_color+0x4>
40009710: da 20 e0 0c st %o5, [ %g3 + 0xc ]
40009714: c4 20 c0 00 st %g2, [ %g3 ]
<== NOT EXECUTED
40009718: 10 bf ff bd b 4000960c <_RBTree_Insert_color+0xb4>
<== NOT EXECUTED
4000971c: c6 20 a0 08 st %g3, [ %g2 + 8 ]
<== NOT EXECUTED
40009720: 10 bf ff ef b 400096dc <_RBTree_Insert_color+0x184>
<== NOT EXECUTED
40009724: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
40009728: c8 22 00 00 st %g4, [ %o0 ]
4000972c: c4 21 20 04 st %g2, [ %g4 + 4 ]
40009730: 10 bf ff 8b b 4000955c <_RBTree_Insert_color+0x4>
40009734: c8 20 a0 08 st %g4, [ %g2 + 8 ]
40009738: c8 02 40 00 ld [ %o1 ], %g4
4000973c: 80 a1 20 00 cmp %g4, 0
40009740: 02 80 00 04 be 40009750 <_RBTree_Insert_color+0x1f8>
<== ALWAYS TAKEN
40009744: c8 20 60 04 st %g4, [ %g1 + 4 ]
40009748: c2 21 20 08 st %g1, [ %g4 + 8 ]
<== NOT EXECUTED
4000974c: c6 00 60 08 ld [ %g1 + 8 ], %g3
<== NOT EXECUTED
40009750: 80 a0 e0 00 cmp %g3, 0
40009754: 02 80 00 1b be 400097c0 <_RBTree_Insert_color+0x268>
<== NEVER TAKEN
40009758: c6 22 60 08 st %g3, [ %o1 + 8 ]
4000975c: c6 00 60 08 ld [ %g1 + 8 ], %g3
40009760: c8 00 c0 00 ld [ %g3 ], %g4
40009764: 80 a0 40 04 cmp %g1, %g4
40009768: 22 80 00 03 be,a 40009774 <_RBTree_Insert_color+0x21c>
<== ALWAYS TAKEN
4000976c: d2 20 c0 00 st %o1, [ %g3 ]
40009770: d2 20 e0 04 st %o1, [ %g3 + 4 ]
<== NOT EXECUTED
40009774: 86 10 00 09 mov %o1, %g3
40009778: c2 22 40 00 st %g1, [ %o1 ]
4000977c: c8 00 80 00 ld [ %g2 ], %g4
40009780: da 01 20 04 ld [ %g4 + 4 ], %o5
40009784: d2 20 60 08 st %o1, [ %g1 + 8 ]
40009788: 92 10 00 01 mov %g1, %o1
4000978c: 10 bf ff b3 b 40009658 <_RBTree_Insert_color+0x100>
40009790: 82 10 00 03 mov %g3, %g1
40009794: c6 22 60 08 st %g3, [ %o1 + 8 ]
40009798: c6 00 60 08 ld [ %g1 + 8 ], %g3
4000979c: c8 00 c0 00 ld [ %g3 ], %g4
400097a0: 80 a0 40 04 cmp %g1, %g4
400097a4: 32 bf ff ce bne,a 400096dc <_RBTree_Insert_color+0x184>
<== ALWAYS TAKEN
400097a8: d2 20 e0 04 st %o1, [ %g3 + 4 ]
400097ac: 10 bf ff cc b 400096dc <_RBTree_Insert_color+0x184>
<== NOT EXECUTED
400097b0: d2 20 c0 00 st %o1, [ %g3 ]
<== NOT EXECUTED
400097b4: c4 21 20 04 st %g2, [ %g4 + 4 ]
<== NOT EXECUTED
400097b8: 10 bf ff 69 b 4000955c <_RBTree_Insert_color+0x4>
<== NOT EXECUTED
400097bc: c8 20 a0 08 st %g4, [ %g2 + 8 ]
<== NOT EXECUTED
400097c0: 10 bf ff ed b 40009774 <_RBTree_Insert_color+0x21c>
<== NOT EXECUTED
400097c4: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
4000defc <_RBTree_Minimum>:
#endif
#include <rtems/score/rbtreeimpl.h>
#include <rtems/score/basedefs.h>
RB_GENERATE_MINMAX( RBTree_Control, RBTree_Node, Node, static )
4000defc: d0 02 00 00 ld [ %o0 ], %o0
4000df00: 80 a2 20 00 cmp %o0, 0
4000df04: 32 80 00 04 bne,a 4000df14 <_RBTree_Minimum+0x18>
<== ALWAYS TAKEN
4000df08: c2 02 00 00 ld [ %o0 ], %g1
4000df0c: 30 80 00 07 b,a 4000df28 <_RBTree_Minimum+0x2c>
<== NOT EXECUTED
4000df10: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
4000df14: 80 a0 60 00 cmp %g1, 0
4000df18: 32 bf ff fe bne,a 4000df10 <_RBTree_Minimum+0x14>
<== NEVER TAKEN
4000df1c: 90 10 00 01 mov %g1, %o0
<== NOT EXECUTED
RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static )
RBTree_Node *_RBTree_Minimum( const RBTree_Control *tree )
{
return RB_MIN( RBTree_Control, RTEMS_DECONST( RBTree_Control *, tree ) );
}
4000df20: 81 c3 e0 08 retl
4000df24: 01 00 00 00 nop
4000df28: 81 c3 e0 08 retl
<== NOT EXECUTED
4000df2c: 01 00 00 00 nop
<== NOT EXECUTED
40009800 <_Scheduler_default_Cancel_job>:
{
(void) scheduler;
(void) the_thread;
(void) priority_node;
(void) queue_context;
}
40009800: 81 c3 e0 08 retl
<== NOT EXECUTED
40009804: 01 00 00 00 nop
<== NOT EXECUTED
400097f8 <_Scheduler_default_Release_job>:
(void) scheduler;
(void) the_thread;
(void) priority_node;
(void) deadline;
(void) queue_context;
}
400097f8: 81 c3 e0 08 retl
<== NOT EXECUTED
400097fc: 01 00 00 00 nop
<== NOT EXECUTED
4000982c <_Scheduler_default_Tick>:
void _Scheduler_default_Tick(
const Scheduler_Control *scheduler,
Thread_Control *executing
)
{
4000982c: 9d e3 bf a0 save %sp, -96, %sp
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
40009830: c2 0e 60 89 ldub [ %i1 + 0x89 ], %g1
40009834: 80 a0 60 00 cmp %g1, 0
40009838: 02 80 00 24 be 400098c8 <_Scheduler_default_Tick+0x9c>
4000983c: 01 00 00 00 nop
return;
if ( !_States_Is_ready( executing->current_state ) )
40009840: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
40009844: 80 a0 60 00 cmp %g1, 0
40009848: 12 80 00 20 bne 400098c8 <_Scheduler_default_Tick+0x9c>
4000984c: 01 00 00 00 nop
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
40009850: c2 06 60 90 ld [ %i1 + 0x90 ], %g1
40009854: 80 a0 60 01 cmp %g1, 1
40009858: 0a 80 00 0e bcs 40009890 <_Scheduler_default_Tick+0x64>
4000985c: 80 a0 60 02 cmp %g1, 2
40009860: 08 80 00 0e bleu 40009898 <_Scheduler_default_Tick+0x6c>
<== ALWAYS TAKEN
40009864: 80 a0 60 03 cmp %g1, 3
40009868: 12 80 00 18 bne 400098c8 <_Scheduler_default_Tick+0x9c>
<== NOT EXECUTED
4000986c: 01 00 00 00 nop
<== NOT EXECUTED
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
40009870: c2 06 60 8c ld [ %i1 + 0x8c ], %g1
<== NOT EXECUTED
40009874: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
40009878: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000987c: 12 80 00 05 bne 40009890 <_Scheduler_default_Tick+0x64>
<== NOT EXECUTED
40009880: c2 26 60 8c st %g1, [ %i1 + 0x8c ]
<== NOT EXECUTED
(*executing->budget_callout)( executing );
40009884: c2 06 60 94 ld [ %i1 + 0x94 ], %g1
<== NOT EXECUTED
40009888: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000988c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
break;
#endif
}
}
40009890: 81 c7 e0 08 ret
40009894: 81 e8 00 00 restore
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
40009898: c2 06 60 8c ld [ %i1 + 0x8c ], %g1
4000989c: 82 00 7f ff add %g1, -1, %g1
400098a0: 80 a0 60 00 cmp %g1, 0
400098a4: 14 bf ff fb bg 40009890 <_Scheduler_default_Tick+0x64>
<== ALWAYS TAKEN
400098a8: c2 26 60 8c st %g1, [ %i1 + 0x8c ]
_Thread_Yield( executing );
400098ac: 40 00 09 14 call 4000bcfc <_Thread_Yield>
<== NOT EXECUTED
400098b0: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
rtems_configuration_get_ticks_per_timeslice();
400098b4: 03 10 00 3f sethi %hi(0x4000fc00), %g1
<== NOT EXECUTED
executing->cpu_time_budget =
400098b8: c2 00 62 44 ld [ %g1 + 0x244 ], %g1 ! 4000fe44 <Configuration+0x18>
<== NOT EXECUTED
400098bc: c2 26 60 8c st %g1, [ %i1 + 0x8c ]
<== NOT EXECUTED
400098c0: 81 c7 e0 08 ret
<== NOT EXECUTED
400098c4: 81 e8 00 00 restore
<== NOT EXECUTED
400098c8: 81 c7 e0 08 ret
400098cc: 81 e8 00 00 restore
400098f0 <_Scheduler_priority_Block>:
void _Scheduler_priority_Block(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
400098f0: 9d e3 bf a0 save %sp, -96, %sp
Chain_Node *node,
Scheduler_priority_Ready_queue *ready_queue,
Priority_bit_map_Control *bit_map
)
{
Chain_Control *ready_chain = ready_queue->ready_chain;
400098f4: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
if ( _Chain_Has_only_one_node( ready_chain ) ) {
400098f8: c6 00 40 00 ld [ %g1 ], %g3
400098fc: c4 00 60 08 ld [ %g1 + 8 ], %g2
40009900: 80 a0 c0 02 cmp %g3, %g2
40009904: 22 80 00 31 be,a 400099c8 <_Scheduler_priority_Block+0xd8>
40009908: c6 06 a0 40 ld [ %i2 + 0x40 ], %g3
next = the_node->next;
4000990c: c4 06 40 00 ld [ %i1 ], %g2
previous = the_node->previous;
40009910: c2 06 60 04 ld [ %i1 + 4 ], %g1
next->previous = previous;
40009914: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40009918: c4 20 40 00 st %g2, [ %g1 ]
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
4000991c: 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 ) ) {
40009920: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1
40009924: 80 a6 40 01 cmp %i1, %g1
40009928: 02 80 00 07 be 40009944 <_Scheduler_priority_Block+0x54>
<== ALWAYS TAKEN
4000992c: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3
40009930: 80 a6 40 1b cmp %i1, %i3
<== NOT EXECUTED
40009934: 22 80 00 05 be,a 40009948 <_Scheduler_priority_Block+0x58>
<== NOT EXECUTED
40009938: f4 06 00 00 ld [ %i0 ], %i2
<== NOT EXECUTED
the_thread,
node,
_Scheduler_priority_Extract_body,
_Scheduler_priority_Schedule_body
);
}
4000993c: 81 c7 e0 08 ret
<== NOT EXECUTED
40009940: 81 e8 00 00 restore
<== NOT EXECUTED
40009944: 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 )
40009948: 40 00 15 cb call 4000f074 <__clzsi2>
4000994c: d0 16 80 00 lduh [ %i2 ], %o0
40009950: 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 ] );
40009954: 83 2f 60 01 sll %i5, 1, %g1
return (_Priority_Bits_index( major ) << 4) +
40009958: bb 2f 60 04 sll %i5, 4, %i5
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
4000995c: 82 06 80 01 add %i2, %g1, %g1
bit_number = (unsigned int) __builtin_clz( value )
40009960: 40 00 15 c5 call 4000f074 <__clzsi2>
40009964: 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 ] );
40009968: 90 02 00 1d add %o0, %i5, %o0
4000996c: 90 02 3f f0 add %o0, -16, %o0
return _Chain_Immutable_head( the_chain )->next;
40009970: bb 2a 20 01 sll %o0, 1, %i5
40009974: 90 07 40 08 add %i5, %o0, %o0
40009978: 91 2a 20 02 sll %o0, 2, %o0
4000997c: b4 06 80 08 add %i2, %o0, %i2
40009980: 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 ) ) {
40009984: 80 a7 40 1b cmp %i5, %i3
40009988: 02 80 00 0e be 400099c0 <_Scheduler_priority_Block+0xd0>
<== NEVER TAKEN
4000998c: 01 00 00 00 nop
*time = _Timecounter_Sbinuptime();
40009990: 7f ff fa 52 call 400082d8 <_Timecounter_Sbinuptime>
40009994: e0 1f 20 28 ldd [ %i4 + 0x28 ], %l0
40009998: d0 3f 20 28 std %o0, [ %i4 + 0x28 ]
const Timestamp_Control *_start,
const Timestamp_Control *_end,
Timestamp_Control *_result
)
{
*_result = *_end - *_start;
4000999c: b2 a2 40 11 subcc %o1, %l1, %i1
*_time += *_add;
400099a0: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4
*_result = *_end - *_start;
400099a4: b0 62 00 10 subx %o0, %l0, %i0
*_time += *_add;
400099a8: 86 83 40 19 addcc %o5, %i1, %g3
400099ac: 84 43 00 18 addx %o4, %i0, %g2
400099b0: 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;
400099b4: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
400099b8: fa 21 a0 24 st %i5, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
400099bc: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
400099c0: 81 c7 e0 08 ret
400099c4: 81 e8 00 00 restore
*bit_map_info->minor &= bit_map_info->block_minor;
400099c8: c4 10 c0 00 lduh [ %g3 ], %g2
400099cc: f8 16 a0 4a lduh [ %i2 + 0x4a ], %i4
400099d0: c8 06 00 00 ld [ %i0 ], %g4
return &the_chain->Tail.Node;
400099d4: ba 00 60 04 add %g1, 4, %i5
head->previous = NULL;
400099d8: c0 20 60 04 clr [ %g1 + 4 ]
400099dc: 84 08 80 1c and %g2, %i4, %g2
head->next = tail;
400099e0: fa 20 40 00 st %i5, [ %g1 ]
if ( *bit_map_info->minor == 0 )
400099e4: 80 a0 a0 00 cmp %g2, 0
tail->previous = head;
400099e8: c2 20 60 08 st %g1, [ %g1 + 8 ]
400099ec: 12 bf ff cc bne 4000991c <_Scheduler_priority_Block+0x2c>
<== NEVER TAKEN
400099f0: c4 30 c0 00 sth %g2, [ %g3 ]
bit_map->major_bit_map &= bit_map_info->block_major;
400099f4: c2 11 00 00 lduh [ %g4 ], %g1
400099f8: c4 16 a0 48 lduh [ %i2 + 0x48 ], %g2
400099fc: 82 08 40 02 and %g1, %g2, %g1
40009a00: 10 bf ff c7 b 4000991c <_Scheduler_priority_Block+0x2c>
40009a04: c2 31 00 00 sth %g1, [ %g4 ]
40009cbc <_Scheduler_priority_Schedule>:
void _Scheduler_priority_Schedule(
const Scheduler_Control *scheduler,
Thread_Control *the_thread
)
{
40009cbc: 9d e3 bf a0 save %sp, -96, %sp
40009cc0: f8 06 00 00 ld [ %i0 ], %i4
bit_number = (unsigned int) __builtin_clz( value )
40009cc4: 40 00 14 ec call 4000f074 <__clzsi2>
40009cc8: d0 17 00 00 lduh [ %i4 ], %o0
40009ccc: ba 02 3f f0 add %o0, -16, %i5
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
40009cd0: 83 2f 60 01 sll %i5, 1, %g1
return (_Priority_Bits_index( major ) << 4) +
40009cd4: bb 2f 60 04 sll %i5, 4, %i5
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
40009cd8: 82 07 00 01 add %i4, %g1, %g1
bit_number = (unsigned int) __builtin_clz( value )
40009cdc: 40 00 14 e6 call 4000f074 <__clzsi2>
40009ce0: d0 10 60 02 lduh [ %g1 + 2 ], %o0
Chain_Node *first = _Chain_First( &ready_queues[ index ] );
40009ce4: 90 02 00 1d add %o0, %i5, %o0
40009ce8: 90 02 3f f0 add %o0, -16, %o0
return _Chain_Immutable_head( the_chain )->next;
40009cec: bb 2a 20 01 sll %o0, 1, %i5
Thread_Control *heir = _Thread_Heir;
40009cf0: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3
40009cf4: 90 07 40 08 add %i5, %o0, %o0
40009cf8: 91 2a 20 02 sll %o0, 2, %o0
40009cfc: b8 07 00 08 add %i4, %o0, %i4
40009d00: fa 07 20 24 ld [ %i4 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40009d04: 80 a7 40 1b cmp %i5, %i3
40009d08: 02 80 00 06 be 40009d20 <_Scheduler_priority_Schedule+0x64>
<== ALWAYS TAKEN
40009d0c: b4 10 00 06 mov %g6, %i2
40009d10: c2 0e e0 89 ldub [ %i3 + 0x89 ], %g1
<== NOT EXECUTED
40009d14: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40009d18: 12 80 00 04 bne 40009d28 <_Scheduler_priority_Schedule+0x6c>
<== NOT EXECUTED
40009d1c: 01 00 00 00 nop
<== NOT EXECUTED
_Scheduler_priority_Schedule_body( scheduler, the_thread, false );
}
40009d20: 81 c7 e0 08 ret
40009d24: 81 e8 00 00 restore
40009d28: 7f ff f9 6c call 400082d8 <_Timecounter_Sbinuptime>
<== NOT EXECUTED
40009d2c: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0
<== NOT EXECUTED
40009d30: d0 3e a0 28 std %o0, [ %i2 + 0x28 ]
<== NOT EXECUTED
*_result = *_end - *_start;
40009d34: b2 a2 40 11 subcc %o1, %l1, %i1
<== NOT EXECUTED
*_time += *_add;
40009d38: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4
<== NOT EXECUTED
*_result = *_end - *_start;
40009d3c: b0 62 00 10 subx %o0, %l0, %i0
<== NOT EXECUTED
*_time += *_add;
40009d40: 86 83 40 19 addcc %o5, %i1, %g3
<== NOT EXECUTED
40009d44: 84 43 00 18 addx %o4, %i0, %g2
<== NOT EXECUTED
40009d48: c4 3e e0 98 std %g2, [ %i3 + 0x98 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40009d4c: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
_Thread_Heir = new_heir;
40009d50: fa 21 a0 24 st %i5, [ %g6 + 0x24 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40009d54: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
<== NOT EXECUTED
40009d58: 81 c7 e0 08 ret
<== NOT EXECUTED
40009d5c: 81 e8 00 00 restore
<== NOT EXECUTED
40009d60 <_Scheduler_priority_Unblock>:
void _Scheduler_priority_Unblock (
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40009d60: 9d e3 bf a0 save %sp, -96, %sp
40009d64: f6 06 a0 34 ld [ %i2 + 0x34 ], %i3
context = _Scheduler_priority_Get_context( scheduler );
the_node = _Scheduler_priority_Node_downcast( node );
priority = (unsigned int ) _Scheduler_Node_get_priority( &the_node->Base );
unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority );
if ( unmapped_priority != the_node->Ready_queue.current_priority ) {
40009d68: c2 06 a0 38 ld [ %i2 + 0x38 ], %g1
unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority );
40009d6c: 87 36 e0 01 srl %i3, 1, %g3
if ( unmapped_priority != the_node->Ready_queue.current_priority ) {
40009d70: 80 a0 40 03 cmp %g1, %g3
40009d74: 02 80 00 4a be 40009e9c <_Scheduler_priority_Unblock+0x13c>
<== ALWAYS TAKEN
40009d78: fa 06 00 00 ld [ %i0 ], %i5
ready_queue->ready_chain = &ready_queues[ new_priority ];
40009d7c: b9 28 e0 01 sll %g3, 1, %i4
<== NOT EXECUTED
40009d80: b8 07 00 03 add %i4, %g3, %i4
<== NOT EXECUTED
40009d84: b9 2f 20 02 sll %i4, 2, %i4
<== NOT EXECUTED
_Scheduler_priority_Ready_queue_update(
40009d88: 84 07 60 24 add %i5, 0x24, %g2
<== NOT EXECUTED
40009d8c: 84 00 80 1c add %g2, %i4, %g2
<== NOT EXECUTED
return the_priority % 16;
40009d90: b8 08 e0 0f and %g3, 0xf, %i4
<== NOT EXECUTED
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
40009d94: 09 00 00 20 sethi %hi(0x8000), %g4
<== NOT EXECUTED
return the_priority / 16;
40009d98: 83 36 e0 05 srl %i3, 5, %g1
<== NOT EXECUTED
ready_queue->current_priority = new_priority;
40009d9c: c6 26 a0 38 st %g3, [ %i2 + 0x38 ]
<== NOT EXECUTED
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
40009da0: b1 31 00 01 srl %g4, %g1, %i0
<== NOT EXECUTED
40009da4: 87 31 00 1c srl %g4, %i4, %g3
<== NOT EXECUTED
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
40009da8: 82 00 60 01 inc %g1
<== NOT EXECUTED
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
40009dac: 9e 38 00 18 xnor %g0, %i0, %o7
<== NOT EXECUTED
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
40009db0: 83 28 60 01 sll %g1, 1, %g1
<== NOT EXECUTED
bit_map_info->block_minor = (Priority_bit_map_Word) ~mask;
40009db4: b8 38 00 03 xnor %g0, %g3, %i4
<== NOT EXECUTED
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
40009db8: 82 07 40 01 add %i5, %g1, %g1
<== NOT EXECUTED
ready_queue->ready_chain = &ready_queues[ new_priority ];
40009dbc: c4 26 a0 3c st %g2, [ %i2 + 0x3c ]
<== NOT EXECUTED
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
40009dc0: 88 10 00 03 mov %g3, %g4
<== NOT EXECUTED
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
40009dc4: c2 26 a0 40 st %g1, [ %i2 + 0x40 ]
<== NOT EXECUTED
bit_map_info->ready_major = mask;
40009dc8: f0 36 a0 44 sth %i0, [ %i2 + 0x44 ]
<== NOT EXECUTED
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
40009dcc: de 36 a0 48 sth %o7, [ %i2 + 0x48 ]
<== NOT EXECUTED
bit_map_info->ready_minor = mask;
40009dd0: c6 36 a0 46 sth %g3, [ %i2 + 0x46 ]
<== NOT EXECUTED
bit_map_info->block_minor = (Priority_bit_map_Word) ~mask;
40009dd4: f8 36 a0 4a sth %i4, [ %i2 + 0x4a ]
<== NOT EXECUTED
return &the_chain->Tail.Node;
40009dd8: b8 00 a0 04 add %g2, 4, %i4
old_last = tail->previous;
40009ddc: c6 00 a0 08 ld [ %g2 + 8 ], %g3
the_node->next = tail;
40009de0: f8 26 40 00 st %i4, [ %i1 ]
tail->previous = the_node;
40009de4: f2 20 a0 08 st %i1, [ %g2 + 8 ]
old_last->next = the_node;
40009de8: f2 20 c0 00 st %i1, [ %g3 ]
*bit_map_info->minor |= bit_map_info->ready_minor;
40009dec: c4 10 40 00 lduh [ %g1 ], %g2
the_node->previous = old_last;
40009df0: c6 26 60 04 st %g3, [ %i1 + 4 ]
40009df4: 84 10 80 04 or %g2, %g4, %g2
40009df8: 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 ) ) {
40009dfc: f8 01 a0 24 ld [ %g6 + 0x24 ], %i4
bit_map->major_bit_map |= bit_map_info->ready_major;
40009e00: c4 16 a0 44 lduh [ %i2 + 0x44 ], %g2
40009e04: c2 17 40 00 lduh [ %i5 ], %g1
40009e08: 82 10 40 02 or %g1, %g2, %g1
40009e0c: c4 07 20 38 ld [ %i4 + 0x38 ], %g2
40009e10: c2 37 40 00 sth %g1, [ %i5 ]
40009e14: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1
40009e18: 80 a0 60 00 cmp %g1, 0
40009e1c: 18 80 00 09 bgu 40009e40 <_Scheduler_priority_Unblock+0xe0>
<== NEVER TAKEN
40009e20: b0 10 00 06 mov %g6, %i0
40009e24: 22 80 00 04 be,a 40009e34 <_Scheduler_priority_Unblock+0xd4>
<== ALWAYS TAKEN
40009e28: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1
_Scheduler_Update_heir( the_thread, priority == PRIORITY_PSEUDO_ISR );
}
}
40009e2c: 81 c7 e0 08 ret
<== NOT EXECUTED
40009e30: 81 e8 00 00 restore
<== NOT EXECUTED
if ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
40009e34: 80 a0 40 1b cmp %g1, %i3
40009e38: 08 80 00 17 bleu 40009e94 <_Scheduler_priority_Unblock+0x134>
40009e3c: 01 00 00 00 nop
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40009e40: 80 a7 00 19 cmp %i4, %i1
40009e44: 02 bf ff fa be 40009e2c <_Scheduler_priority_Unblock+0xcc>
<== NEVER TAKEN
40009e48: 80 a6 e0 00 cmp %i3, 0
40009e4c: 02 80 00 06 be 40009e64 <_Scheduler_priority_Unblock+0x104>
<== NEVER TAKEN
40009e50: 01 00 00 00 nop
40009e54: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1
40009e58: 80 a0 60 00 cmp %g1, 0
40009e5c: 02 80 00 0e be 40009e94 <_Scheduler_priority_Unblock+0x134>
<== NEVER TAKEN
40009e60: 01 00 00 00 nop
40009e64: 7f ff f9 1d call 400082d8 <_Timecounter_Sbinuptime>
40009e68: e0 1e 20 28 ldd [ %i0 + 0x28 ], %l0
40009e6c: d0 3e 20 28 std %o0, [ %i0 + 0x28 ]
*_result = *_end - *_start;
40009e70: b6 a2 40 11 subcc %o1, %l1, %i3
*_time += *_add;
40009e74: d8 1f 20 98 ldd [ %i4 + 0x98 ], %o4
*_result = *_end - *_start;
40009e78: b4 62 00 10 subx %o0, %l0, %i2
*_time += *_add;
40009e7c: 86 83 40 1b addcc %o5, %i3, %g3
40009e80: 84 43 00 1a addx %o4, %i2, %g2
40009e84: c4 3f 20 98 std %g2, [ %i4 + 0x98 ]
_Thread_Dispatch_necessary = true;
40009e88: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
40009e8c: f2 21 a0 24 st %i1, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
40009e90: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
}
40009e94: 81 c7 e0 08 ret
40009e98: 81 e8 00 00 restore
40009e9c: c4 06 a0 3c ld [ %i2 + 0x3c ], %g2
40009ea0: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1
40009ea4: 10 bf ff cd b 40009dd8 <_Scheduler_priority_Unblock+0x78>
40009ea8: c8 16 a0 46 lduh [ %i2 + 0x46 ], %g4
40009a08 <_Scheduler_priority_Update_priority>:
void _Scheduler_priority_Update_priority(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40009a08: 9d e3 bf a0 save %sp, -96, %sp
Scheduler_priority_Context *context;
Scheduler_priority_Node *the_node;
unsigned int new_priority;
unsigned int unmapped_priority;
if ( !_Thread_Is_ready( the_thread ) ) {
40009a0c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
40009a10: 80 a0 60 00 cmp %g1, 0
40009a14: 12 80 00 5c bne 40009b84 <_Scheduler_priority_Update_priority+0x17c>
<== NEVER TAKEN
40009a18: 01 00 00 00 nop
/* Nothing to do */
return;
}
the_node = _Scheduler_priority_Node_downcast( node );
new_priority = (unsigned int)
40009a1c: 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 ) {
40009a20: c2 06 a0 38 ld [ %i2 + 0x38 ], %g1
unmapped_priority = SCHEDULER_PRIORITY_UNMAP( new_priority );
40009a24: 87 36 e0 01 srl %i3, 1, %g3
if ( unmapped_priority == the_node->Ready_queue.current_priority ) {
40009a28: 80 a0 40 03 cmp %g1, %g3
40009a2c: 02 80 00 56 be 40009b84 <_Scheduler_priority_Update_priority+0x17c>
<== NEVER TAKEN
40009a30: 01 00 00 00 nop
Chain_Control *ready_chain = ready_queue->ready_chain;
40009a34: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
if ( _Chain_Has_only_one_node( ready_chain ) ) {
40009a38: c8 00 40 00 ld [ %g1 ], %g4
40009a3c: c4 00 60 08 ld [ %g1 + 8 ], %g2
40009a40: 80 a1 00 02 cmp %g4, %g2
40009a44: 02 80 00 52 be 40009b8c <_Scheduler_priority_Update_priority+0x184>
40009a48: fa 06 00 00 ld [ %i0 ], %i5
next = the_node->next;
40009a4c: c4 06 40 00 ld [ %i1 ], %g2
previous = the_node->previous;
40009a50: c2 06 60 04 ld [ %i1 + 4 ], %g1
next->previous = previous;
40009a54: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40009a58: c4 20 40 00 st %g2, [ %g1 ]
return the_priority / 16;
40009a5c: 85 36 e0 05 srl %i3, 5, %g2
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
40009a60: 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 ];
40009a64: 89 28 e0 01 sll %g3, 1, %g4
40009a68: 9f 30 40 02 srl %g1, %g2, %o7
40009a6c: 88 01 00 03 add %g4, %g3, %g4
return the_priority % 16;
40009a70: 96 08 e0 0f and %g3, 0xf, %o3
&the_thread->Object.Node,
&the_node->Ready_queue,
&context->Bit_map
);
_Scheduler_priority_Ready_queue_update(
40009a74: 9a 07 60 24 add %i5, 0x24, %o5
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
40009a78: 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 ) ];
40009a7c: b8 00 a0 01 add %g2, 1, %i4
40009a80: 89 29 20 02 sll %g4, 2, %g4
40009a84: b9 2f 20 01 sll %i4, 1, %i4
40009a88: b0 03 40 04 add %o5, %g4, %i0
40009a8c: 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;
40009a90: 98 38 00 0f xnor %g0, %o7, %o4
ready_queue->current_priority = new_priority;
40009a94: 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;
40009a98: 86 38 00 01 xnor %g0, %g1, %g3
ready_queue->ready_chain = &ready_queues[ new_priority ];
40009a9c: f0 26 a0 3c st %i0, [ %i2 + 0x3c ]
unmapped_priority,
&context->Bit_map,
&context->Ready[ 0 ]
);
if ( SCHEDULER_PRIORITY_IS_APPEND( new_priority ) ) {
40009aa0: 80 8e e0 01 btst 1, %i3
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
40009aa4: f8 26 a0 40 st %i4, [ %i2 + 0x40 ]
bit_map_info->ready_major = mask;
40009aa8: de 36 a0 44 sth %o7, [ %i2 + 0x44 ]
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
40009aac: d8 36 a0 48 sth %o4, [ %i2 + 0x48 ]
bit_map_info->ready_minor = mask;
40009ab0: c2 36 a0 46 sth %g1, [ %i2 + 0x46 ]
40009ab4: 02 80 00 46 be 40009bcc <_Scheduler_priority_Update_priority+0x1c4>
40009ab8: c6 36 a0 4a sth %g3, [ %i2 + 0x4a ]
old_last = tail->previous;
40009abc: c6 06 20 08 ld [ %i0 + 8 ], %g3
return &the_chain->Tail.Node;
40009ac0: 88 06 20 04 add %i0, 4, %g4
the_node->next = tail;
40009ac4: c8 26 40 00 st %g4, [ %i1 ]
40009ac8: 85 28 a0 01 sll %g2, 1, %g2
tail->previous = the_node;
40009acc: f2 26 20 08 st %i1, [ %i0 + 8 ]
40009ad0: 84 07 40 02 add %i5, %g2, %g2
old_last->next = the_node;
40009ad4: f2 20 c0 00 st %i1, [ %g3 ]
*bit_map_info->minor |= bit_map_info->ready_minor;
40009ad8: c8 10 a0 02 lduh [ %g2 + 2 ], %g4
the_node->previous = old_last;
40009adc: c6 26 60 04 st %g3, [ %i1 + 4 ]
40009ae0: 82 10 40 04 or %g1, %g4, %g1
40009ae4: c2 30 a0 02 sth %g1, [ %g2 + 2 ]
bit_map->major_bit_map |= bit_map_info->ready_major;
40009ae8: c4 16 a0 44 lduh [ %i2 + 0x44 ], %g2
40009aec: c2 17 40 00 lduh [ %i5 ], %g1
40009af0: 82 10 40 02 or %g1, %g2, %g1
40009af4: c2 37 40 00 sth %g1, [ %i5 ]
bit_number = (unsigned int) __builtin_clz( value )
40009af8: 40 00 15 5f call 4000f074 <__clzsi2>
40009afc: d0 17 40 00 lduh [ %i5 ], %o0
40009b00: b8 02 3f f0 add %o0, -16, %i4
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
40009b04: 83 2f 20 01 sll %i4, 1, %g1
return (_Priority_Bits_index( major ) << 4) +
40009b08: b9 2f 20 04 sll %i4, 4, %i4
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
40009b0c: 82 07 40 01 add %i5, %g1, %g1
bit_number = (unsigned int) __builtin_clz( value )
40009b10: 40 00 15 59 call 4000f074 <__clzsi2>
40009b14: d0 10 60 02 lduh [ %g1 + 2 ], %o0
Chain_Node *first = _Chain_First( &ready_queues[ index ] );
40009b18: 90 02 00 1c add %o0, %i4, %o0
Thread_Control *heir = _Thread_Heir;
40009b1c: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3
40009b20: 90 02 3f f0 add %o0, -16, %o0
return _Chain_Immutable_head( the_chain )->next;
40009b24: b9 2a 20 01 sll %o0, 1, %i4
40009b28: 90 07 00 08 add %i4, %o0, %o0
40009b2c: 91 2a 20 02 sll %o0, 2, %o0
40009b30: ba 07 40 08 add %i5, %o0, %i5
40009b34: fa 07 60 24 ld [ %i5 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40009b38: 80 a7 40 1b cmp %i5, %i3
40009b3c: 02 80 00 12 be 40009b84 <_Scheduler_priority_Update_priority+0x17c>
<== ALWAYS TAKEN
40009b40: b4 10 00 06 mov %g6, %i2
40009b44: c2 0e e0 89 ldub [ %i3 + 0x89 ], %g1
<== NOT EXECUTED
40009b48: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40009b4c: 02 80 00 0e be 40009b84 <_Scheduler_priority_Update_priority+0x17c>
<== NOT EXECUTED
40009b50: 01 00 00 00 nop
<== NOT EXECUTED
40009b54: 7f ff f9 e1 call 400082d8 <_Timecounter_Sbinuptime>
<== NOT EXECUTED
40009b58: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0
<== NOT EXECUTED
40009b5c: d0 3e a0 28 std %o0, [ %i2 + 0x28 ]
<== NOT EXECUTED
*_result = *_end - *_start;
40009b60: b2 a2 40 11 subcc %o1, %l1, %i1
<== NOT EXECUTED
*_time += *_add;
40009b64: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4
<== NOT EXECUTED
*_result = *_end - *_start;
40009b68: b0 62 00 10 subx %o0, %l0, %i0
<== NOT EXECUTED
*_time += *_add;
40009b6c: 86 83 40 19 addcc %o5, %i1, %g3
<== NOT EXECUTED
40009b70: 84 43 00 18 addx %o4, %i0, %g2
<== NOT EXECUTED
40009b74: c4 3e e0 98 std %g2, [ %i3 + 0x98 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40009b78: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
_Thread_Heir = new_heir;
40009b7c: fa 21 a0 24 st %i5, [ %g6 + 0x24 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40009b80: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
<== NOT EXECUTED
&context->Bit_map
);
}
_Scheduler_priority_Schedule_body( scheduler, the_thread, false );
}
40009b84: 81 c7 e0 08 ret
40009b88: 81 e8 00 00 restore
*bit_map_info->minor &= bit_map_info->block_minor;
40009b8c: c8 06 a0 40 ld [ %i2 + 0x40 ], %g4
40009b90: c4 11 00 00 lduh [ %g4 ], %g2
40009b94: f0 16 a0 4a lduh [ %i2 + 0x4a ], %i0
return &the_chain->Tail.Node;
40009b98: b8 00 60 04 add %g1, 4, %i4
head->previous = NULL;
40009b9c: c0 20 60 04 clr [ %g1 + 4 ]
40009ba0: 84 08 80 18 and %g2, %i0, %g2
head->next = tail;
40009ba4: f8 20 40 00 st %i4, [ %g1 ]
if ( *bit_map_info->minor == 0 )
40009ba8: 80 a0 a0 00 cmp %g2, 0
tail->previous = head;
40009bac: c2 20 60 08 st %g1, [ %g1 + 8 ]
40009bb0: 12 bf ff ab bne 40009a5c <_Scheduler_priority_Update_priority+0x54>
<== NEVER TAKEN
40009bb4: c4 31 00 00 sth %g2, [ %g4 ]
bit_map->major_bit_map &= bit_map_info->block_major;
40009bb8: c2 17 40 00 lduh [ %i5 ], %g1
40009bbc: c4 16 a0 48 lduh [ %i2 + 0x48 ], %g2
40009bc0: 82 08 40 02 and %g1, %g2, %g1
40009bc4: 10 bf ff a6 b 40009a5c <_Scheduler_priority_Update_priority+0x54>
40009bc8: c2 37 40 00 sth %g1, [ %i5 ]
the_node->previous = after_node;
40009bcc: f0 26 60 04 st %i0, [ %i1 + 4 ]
40009bd0: 85 28 a0 01 sll %g2, 1, %g2
before_node = after_node->next;
40009bd4: c6 03 40 04 ld [ %o5 + %g4 ], %g3
after_node->next = the_node;
40009bd8: f2 23 40 04 st %i1, [ %o5 + %g4 ]
40009bdc: 84 07 40 02 add %i5, %g2, %g2
the_node->next = before_node;
40009be0: c6 26 40 00 st %g3, [ %i1 ]
*bit_map_info->minor |= bit_map_info->ready_minor;
40009be4: c8 10 a0 02 lduh [ %g2 + 2 ], %g4
before_node->previous = the_node;
40009be8: 10 bf ff be b 40009ae0 <_Scheduler_priority_Update_priority+0xd8>
40009bec: f2 20 e0 04 st %i1, [ %g3 + 4 ]
40009eac <_Scheduler_priority_Yield>:
void _Scheduler_priority_Yield(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40009eac: 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;
40009eb0: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
<== NOT EXECUTED
if ( !_Chain_Has_only_one_node( ready_chain ) ) {
40009eb4: c6 00 60 08 ld [ %g1 + 8 ], %g3
<== NOT EXECUTED
40009eb8: c4 00 40 00 ld [ %g1 ], %g2
<== NOT EXECUTED
40009ebc: 80 a0 c0 02 cmp %g3, %g2
<== NOT EXECUTED
40009ec0: 02 80 00 0b be 40009eec <_Scheduler_priority_Yield+0x40>
<== NOT EXECUTED
40009ec4: 88 00 60 04 add %g1, 4, %g4
<== NOT EXECUTED
previous = the_node->previous;
40009ec8: c4 06 60 04 ld [ %i1 + 4 ], %g2
<== NOT EXECUTED
next = the_node->next;
40009ecc: c6 06 40 00 ld [ %i1 ], %g3
<== NOT EXECUTED
next->previous = previous;
40009ed0: c4 20 e0 04 st %g2, [ %g3 + 4 ]
<== NOT EXECUTED
previous->next = next;
40009ed4: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
old_last = tail->previous;
40009ed8: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
the_node->next = tail;
40009edc: c8 26 40 00 st %g4, [ %i1 ]
<== NOT EXECUTED
tail->previous = the_node;
40009ee0: f2 20 60 08 st %i1, [ %g1 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
40009ee4: f2 20 80 00 st %i1, [ %g2 ]
<== NOT EXECUTED
the_node->previous = old_last;
40009ee8: c4 26 60 04 st %g2, [ %i1 + 4 ]
<== NOT EXECUTED
40009eec: f8 06 00 00 ld [ %i0 ], %i4
<== NOT EXECUTED
bit_number = (unsigned int) __builtin_clz( value )
40009ef0: 40 00 14 61 call 4000f074 <__clzsi2>
<== NOT EXECUTED
40009ef4: d0 17 00 00 lduh [ %i4 ], %o0
<== NOT EXECUTED
40009ef8: ba 02 3f f0 add %o0, -16, %i5
<== NOT EXECUTED
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
40009efc: 83 2f 60 01 sll %i5, 1, %g1
<== NOT EXECUTED
return (_Priority_Bits_index( major ) << 4) +
40009f00: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
40009f04: 82 07 00 01 add %i4, %g1, %g1
<== NOT EXECUTED
bit_number = (unsigned int) __builtin_clz( value )
40009f08: 40 00 14 5b call 4000f074 <__clzsi2>
<== NOT EXECUTED
40009f0c: d0 10 60 02 lduh [ %g1 + 2 ], %o0
<== NOT EXECUTED
Chain_Node *first = _Chain_First( &ready_queues[ index ] );
40009f10: 90 02 00 1d add %o0, %i5, %o0
<== NOT EXECUTED
40009f14: 90 02 3f f0 add %o0, -16, %o0
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40009f18: bb 2a 20 01 sll %o0, 1, %i5
<== NOT EXECUTED
Thread_Control *heir = _Thread_Heir;
40009f1c: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3
<== NOT EXECUTED
40009f20: 90 07 40 08 add %i5, %o0, %o0
<== NOT EXECUTED
40009f24: 91 2a 20 02 sll %o0, 2, %o0
<== NOT EXECUTED
40009f28: b8 07 00 08 add %i4, %o0, %i4
<== NOT EXECUTED
40009f2c: fa 07 20 24 ld [ %i4 + 0x24 ], %i5
<== NOT EXECUTED
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40009f30: 80 a7 40 1b cmp %i5, %i3
<== NOT EXECUTED
40009f34: 02 80 00 0e be 40009f6c <_Scheduler_priority_Yield+0xc0>
<== NOT EXECUTED
40009f38: b4 10 00 06 mov %g6, %i2
<== NOT EXECUTED
40009f3c: 7f ff f8 e7 call 400082d8 <_Timecounter_Sbinuptime>
<== NOT EXECUTED
40009f40: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0
<== NOT EXECUTED
40009f44: d0 3e a0 28 std %o0, [ %i2 + 0x28 ]
<== NOT EXECUTED
*_result = *_end - *_start;
40009f48: b2 a2 40 11 subcc %o1, %l1, %i1
<== NOT EXECUTED
*_time += *_add;
40009f4c: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4
<== NOT EXECUTED
*_result = *_end - *_start;
40009f50: b0 62 00 10 subx %o0, %l0, %i0
<== NOT EXECUTED
*_time += *_add;
40009f54: 86 83 40 19 addcc %o5, %i1, %g3
<== NOT EXECUTED
40009f58: 84 43 00 18 addx %o4, %i0, %g2
<== NOT EXECUTED
40009f5c: c4 3e e0 98 std %g2, [ %i3 + 0x98 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40009f60: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
_Thread_Heir = new_heir;
40009f64: fa 21 a0 24 st %i5, [ %g6 + 0x24 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40009f68: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
<== NOT EXECUTED
_Chain_Extract_unprotected( &the_thread->Object.Node );
_Chain_Append_unprotected( ready_chain, &the_thread->Object.Node );
}
_Scheduler_priority_Schedule_body( scheduler, the_thread, true );
}
40009f6c: 81 c7 e0 08 ret
<== NOT EXECUTED
40009f70: 81 e8 00 00 restore
<== NOT EXECUTED
40012f14 <_Semaphore_Post_binary>:
);
}
}
void _Semaphore_Post_binary( struct _Semaphore_Control *_sem )
{
40012f14: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40012f18: 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;
40012f1c: d0 06 20 08 ld [ %i0 + 8 ], %o0
<== NOT EXECUTED
if ( __predict_true( heads == NULL ) ) {
40012f20: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40012f24: 12 80 00 07 bne 40012f40 <_Semaphore_Post_binary+0x2c>
<== NOT EXECUTED
40012f28: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
sem->count = 1;
40012f2c: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40012f30: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40012f34: 01 00 00 00 nop
<== NOT EXECUTED
40012f38: 81 c7 e0 08 ret
<== NOT EXECUTED
40012f3c: 81 e8 00 00 restore
<== NOT EXECUTED
40012f40: c2 27 bf dc st %g1, [ %fp + -36 ]
<== NOT EXECUTED
const Thread_queue_Operations *operations;
Thread_Control *first;
_Thread_queue_Context_set_ISR_level( &queue_context, level );
operations = SEMAPHORE_TQ_OPERATIONS;
first = ( *operations->first )( heads );
40012f44: 3b 10 00 bb sethi %hi(0x4002ec00), %i5
<== NOT EXECUTED
40012f48: ba 17 63 70 or %i5, 0x370, %i5 ! 4002ef70 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
40012f4c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
<== NOT EXECUTED
40012f50: 9f c0 40 00 call %g1
<== NOT EXECUTED
40012f54: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_queue_Extract_critical(
40012f58: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
40012f5c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40012f60: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40012f64: 40 00 03 dc call 40013ed4 <_Thread_queue_Extract_critical>
<== NOT EXECUTED
40012f68: 90 06 20 08 add %i0, 8, %o0
<== NOT EXECUTED
operations,
first,
&queue_context
);
}
}
40012f6c: 81 c7 e0 08 ret
<== NOT EXECUTED
40012f70: 81 e8 00 00 restore
<== NOT EXECUTED
40012ed0 <_Semaphore_Try_wait>:
int _Semaphore_Try_wait( struct _Semaphore_Control *_sem )
{
40012ed0: 86 10 00 08 mov %o0, %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40012ed4: 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;
40012ed8: c4 02 20 14 ld [ %o0 + 0x14 ], %g2
<== NOT EXECUTED
if ( __predict_true( count > 0 ) ) {
40012edc: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40012ee0: 02 80 00 08 be 40012f00 <_Semaphore_Try_wait+0x30>
<== NOT EXECUTED
40012ee4: 84 00 bf ff add %g2, -1, %g2
<== NOT EXECUTED
sem->count = count - 1;
eno = 0;
40012ee8: 90 10 20 00 clr %o0
<== NOT EXECUTED
sem->count = count - 1;
40012eec: c4 20 e0 14 st %g2, [ %g3 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40012ef0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40012ef4: 01 00 00 00 nop
<== NOT EXECUTED
eno = EAGAIN;
}
_Sem_Queue_release( sem, level, &queue_context );
return eno;
}
40012ef8: 81 c3 e0 08 retl
<== NOT EXECUTED
40012efc: 01 00 00 00 nop
<== NOT EXECUTED
eno = EAGAIN;
40012f00: 90 10 20 0b mov 0xb, %o0 ! b <_TLS_Alignment+0xa>
<== NOT EXECUTED
40012f04: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40012f08: 01 00 00 00 nop
<== NOT EXECUTED
}
40012f0c: 81 c3 e0 08 retl
<== NOT EXECUTED
40012f10: 01 00 00 00 nop
<== NOT EXECUTED
40012df0 <_Semaphore_Wait>:
sizeof( Sem_Control ) == sizeof( struct _Semaphore_Control ),
SEMAPHORE_CONTROL_SIZE
);
void _Semaphore_Wait( struct _Semaphore_Control *_sem )
{
40012df0: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40012df4: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
40012df8: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
sem = _Sem_Get( _sem );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
executing = _Sem_Queue_acquire_critical( sem, &queue_context );
count = sem->count;
40012dfc: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
if ( __predict_true( count > 0 ) ) {
40012e00: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40012e04: 02 80 00 07 be 40012e20 <_Semaphore_Wait+0x30>
<== NOT EXECUTED
40012e08: 84 00 bf ff add %g2, -1, %g2
<== NOT EXECUTED
sem->count = count - 1;
40012e0c: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40012e10: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40012e14: 01 00 00 00 nop
<== NOT EXECUTED
40012e18: 81 c7 e0 08 ret
<== NOT EXECUTED
40012e1c: 81 e8 00 00 restore
<== NOT EXECUTED
queue_context->thread_state = thread_state;
40012e20: 82 10 20 02 mov 2, %g1
<== NOT EXECUTED
Thread_queue_Context *queue_context
)
{
Thread_Control *executing;
executing = _Thread_Executing;
40012e24: d4 01 a0 20 ld [ %g6 + 0x20 ], %o2
<== NOT EXECUTED
40012e28: c2 27 bf e0 st %g1, [ %fp + -32 ]
<== NOT EXECUTED
queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;
40012e2c: 03 10 00 4f sethi %hi(0x40013c00), %g1
<== NOT EXECUTED
40012e30: 82 10 60 d4 or %g1, 0xd4, %g1 ! 40013cd4 <_Thread_queue_Enqueue_do_nothing_extra>
<== NOT EXECUTED
&queue_context,
STATES_WAITING_FOR_SEMAPHORE
);
_Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context );
_Thread_queue_Context_set_ISR_level( &queue_context, level );
_Thread_queue_Enqueue(
40012e34: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
40012e38: c2 27 bf e4 st %g1, [ %fp + -28 ]
<== NOT EXECUTED
40012e3c: 13 10 00 bb sethi %hi(0x4002ec00), %o1
<== NOT EXECUTED
40012e40: c6 27 bf dc st %g3, [ %fp + -36 ]
<== NOT EXECUTED
40012e44: 92 12 63 70 or %o1, 0x370, %o1
<== NOT EXECUTED
40012e48: 40 00 03 ad call 40013cfc <_Thread_queue_Enqueue>
<== NOT EXECUTED
40012e4c: 90 06 20 08 add %i0, 8, %o0
<== NOT EXECUTED
SEMAPHORE_TQ_OPERATIONS,
executing,
&queue_context
);
}
}
40012e50: 81 c7 e0 08 ret
<== NOT EXECUTED
40012e54: 81 e8 00 00 restore
<== NOT EXECUTED
40012e58 <_Semaphore_Wait_timed_ticks>:
int _Semaphore_Wait_timed_ticks( struct _Semaphore_Control *_sem, uint32_t ticks )
{
40012e58: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40012e5c: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
40012e60: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
sem = _Sem_Get( _sem );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
executing = _Sem_Queue_acquire_critical( sem, &queue_context );
count = sem->count;
40012e64: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
if ( __predict_true( count > 0 ) ) {
40012e68: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40012e6c: 02 80 00 07 be 40012e88 <_Semaphore_Wait_timed_ticks+0x30>
<== NOT EXECUTED
40012e70: 84 00 bf ff add %g2, -1, %g2
<== NOT EXECUTED
sem->count = count - 1;
40012e74: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40012e78: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40012e7c: 01 00 00 00 nop
<== NOT EXECUTED
_Sem_Queue_release( sem, level, &queue_context );
return 0;
40012e80: 81 c7 e0 08 ret
<== NOT EXECUTED
40012e84: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
queue_context->thread_state = thread_state;
40012e88: 82 10 20 02 mov 2, %g1
<== NOT EXECUTED
40012e8c: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
<== NOT EXECUTED
40012e90: c2 27 bf e0 st %g1, [ %fp + -32 ]
<== NOT EXECUTED
queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks;
40012e94: 03 10 00 53 sethi %hi(0x40014c00), %g1
<== NOT EXECUTED
40012e98: 82 10 61 78 or %g1, 0x178, %g1 ! 40014d78 <_Thread_queue_Add_timeout_ticks>
<== NOT EXECUTED
&queue_context,
STATES_WAITING_FOR_SEMAPHORE
);
_Thread_queue_Context_set_enqueue_timeout_ticks( &queue_context, ticks );
_Thread_queue_Context_set_ISR_level( &queue_context, level );
_Thread_queue_Enqueue(
40012e9c: 90 06 20 08 add %i0, 8, %o0
<== NOT EXECUTED
queue_context->Timeout.ticks = ticks;
40012ea0: f2 27 bf e8 st %i1, [ %fp + -24 ]
<== NOT EXECUTED
40012ea4: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
40012ea8: c6 27 bf dc st %g3, [ %fp + -36 ]
<== NOT EXECUTED
40012eac: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks;
40012eb0: c2 27 bf e4 st %g1, [ %fp + -28 ]
<== NOT EXECUTED
40012eb4: 13 10 00 bb sethi %hi(0x4002ec00), %o1
<== NOT EXECUTED
40012eb8: 40 00 03 91 call 40013cfc <_Thread_queue_Enqueue>
<== NOT EXECUTED
40012ebc: 92 12 63 70 or %o1, 0x370, %o1 ! 4002ef70 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
&sem->Queue.Queue,
SEMAPHORE_TQ_OPERATIONS,
executing,
&queue_context
);
return STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) );
40012ec0: f0 07 60 4c ld [ %i5 + 0x4c ], %i0
<== NOT EXECUTED
40012ec4: b1 3e 20 08 sra %i0, 8, %i0
<== NOT EXECUTED
}
}
40012ec8: 81 c7 e0 08 ret
<== NOT EXECUTED
40012ecc: 81 e8 00 00 restore
<== NOT EXECUTED
40044824 <_TOD_Set>:
void _TOD_Set(
const struct timespec *tod,
ISR_lock_Context *lock_context
)
{
40044824: 9d e3 bf 88 save %sp, -120, %sp
_bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL;
40044828: c4 06 20 08 ld [ %i0 + 8 ], %g2
4004482c: 89 28 a0 02 sll %g2, 2, %g4
_bt->sec = _ts->tv_sec;
40044830: f8 1e 00 00 ldd [ %i0 ], %i4
_bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL;
40044834: 83 38 a0 1f sra %g2, 0x1f, %g1
40044838: 07 12 e0 be sethi %hi(0x4b82f800), %g3
4004483c: 86 10 e2 09 or %g3, 0x209, %g3 ! 4b82fa09 <RAM_END+0xb42fa09>
40044840: 82 58 40 03 smul %g1, %g3, %g1
40044844: 86 50 80 03 umul %g2, %g3, %g3
40044848: 85 40 00 00 rd %y, %g2
4004484c: 82 00 40 04 add %g1, %g4, %g1
40044850: 84 00 40 02 add %g1, %g2, %g2
_bt->sec = _ts->tv_sec;
40044854: 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 );
40044858: 92 10 00 19 mov %i1, %o1
_bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL;
4004485c: c4 3f bf f8 std %g2, [ %fp + -8 ]
40044860: 7f ff 5d 02 call 4001bc68 <_Timecounter_Set_clock>
40044864: 90 07 bf f0 add %fp, -16, %o0
ticks = (uint64_t) ts->tv_sec;
40044868: c6 06 00 00 ld [ %i0 ], %g3
<== NOT EXECUTED
4004486c: c4 06 20 04 ld [ %i0 + 4 ], %g2
<== NOT EXECUTED
ticks |= (uint32_t) ts->tv_nsec;
40044870: d6 06 20 08 ld [ %i0 + 8 ], %o3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40044874: 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 );
40044878: c2 27 bf ec st %g1, [ %fp + -20 ]
4004487c: 11 10 02 44 sethi %hi(0x40091000), %o0
40044880: 90 12 22 40 or %o0, 0x240, %o0 ! 40091240 <_Per_CPU_Information>
40044884: d2 02 20 44 ld [ %o0 + 0x44 ], %o1
first = _Watchdog_Header_first( header );
if ( first != NULL ) {
40044888: 80 a2 60 00 cmp %o1, 0
4004488c: 02 80 00 09 be 400448b0 <_TOD_Set+0x8c>
<== ALWAYS TAKEN
40044890: 95 30 a0 02 srl %g2, 2, %o2
ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS;
40044894: 87 28 e0 1e sll %g3, 0x1e, %g3
<== NOT EXECUTED
40044898: 85 28 a0 1e sll %g2, 0x1e, %g2
<== NOT EXECUTED
_Watchdog_Tickle(
4004489c: 98 07 bf ec add %fp, -20, %o4
<== NOT EXECUTED
400448a0: 94 12 80 03 or %o2, %g3, %o2
<== NOT EXECUTED
400448a4: 96 12 c0 02 or %o3, %g2, %o3
<== NOT EXECUTED
400448a8: 7f ff 6e 9d call 4002031c <_Watchdog_Do_tickle>
<== NOT EXECUTED
400448ac: 90 02 20 40 add %o0, 0x40, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400448b0: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400448b4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400448b8: 01 00 00 00 nop
}
_ISR_lock_Release_and_ISR_enable( &cpu->Watchdog.Lock, &lock_context );
}
_TOD.is_set = true;
400448bc: 03 10 02 44 sethi %hi(0x40091000), %g1
400448c0: 84 10 20 01 mov 1, %g2
400448c4: c4 28 63 58 stb %g2, [ %g1 + 0x358 ]
}
400448c8: 81 c7 e0 08 ret
400448cc: 81 e8 00 00 restore
400072a0 <_Terminate>:
void _Terminate(
Internal_errors_Source the_source,
Internal_errors_t the_error
)
{
400072a0: 9d e3 bf 98 save %sp, -104, %sp
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, error };
_User_extensions_Iterate(
400072a4: 94 10 20 00 clr %o2
400072a8: 90 07 bf f8 add %fp, -8, %o0
User_extensions_Fatal_context ctx = { source, error };
400072ac: f0 27 bf f8 st %i0, [ %fp + -8 ]
_User_extensions_Iterate(
400072b0: 13 10 00 2f sethi %hi(0x4000bc00), %o1
User_extensions_Fatal_context ctx = { source, error };
400072b4: f2 27 bf fc st %i1, [ %fp + -4 ]
_User_extensions_Iterate(
400072b8: 40 00 13 10 call 4000bef8 <_User_extensions_Iterate>
400072bc: 92 12 62 a8 or %o1, 0x2a8, %o1
_User_extensions_Fatal( the_source, the_error );
_Internal_errors_What_happened.the_source = the_source;
400072c0: 03 10 00 4d sethi %hi(0x40013400), %g1
400072c4: 84 10 61 64 or %g1, 0x164, %g2 ! 40013564 <_Internal_errors_What_happened>
400072c8: f0 20 61 64 st %i0, [ %g1 + 0x164 ]
400072cc: 03 10 00 4d sethi %hi(0x40013400), %g1
_Internal_errors_What_happened.the_error = the_error;
400072d0: f2 20 a0 04 st %i1, [ %g2 + 4 ]
400072d4: 84 10 20 03 mov 3, %g2
_System_state_Set( SYSTEM_STATE_TERMINATED );
_SMP_Request_shutdown();
_CPU_Fatal_halt( the_source, the_error );
400072d8: 92 10 00 19 mov %i1, %o1
400072dc: 90 10 00 18 mov %i0, %o0
400072e0: 40 00 21 a4 call 4000f970 <_CPU_Fatal_halt>
400072e4: c4 20 61 6c st %g2, [ %g1 + 0x16c ]
400072e8: 01 00 00 00 nop
<== NOT EXECUTED
4000b810 <_Thread_Cancel>:
void _Thread_Cancel(
Thread_Control *the_thread,
Thread_Control *executing,
void *exit_value
)
{
4000b810: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b814: 91 d0 20 09 ta 9
<== NOT EXECUTED
previous = the_thread->Life.state;
4000b818: c4 06 21 70 ld [ %i0 + 0x170 ], %g2
<== NOT EXECUTED
state |= set;
4000b81c: 86 10 a0 04 or %g2, 4, %g3
<== NOT EXECUTED
the_thread->Life.exit_value = exit_value;
4000b820: f4 26 21 78 st %i2, [ %i0 + 0x178 ]
<== NOT EXECUTED
if (
4000b824: 80 88 a0 09 btst 9, %g2
<== NOT EXECUTED
4000b828: 02 80 00 36 be 4000b900 <_Thread_Cancel+0xf0>
<== NOT EXECUTED
4000b82c: c6 26 21 70 st %g3, [ %i0 + 0x170 ]
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000b830: c4 01 a0 18 ld [ %g6 + 0x18 ], %g2
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000b834: 84 00 a0 01 inc %g2
<== NOT EXECUTED
4000b838: c4 21 a0 18 st %g2, [ %g6 + 0x18 ]
<== NOT EXECUTED
);
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
priority = _Thread_Get_priority( executing );
if ( _States_Is_dormant( the_thread->current_state ) ) {
4000b83c: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
<== NOT EXECUTED
4000b840: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000b844: 06 80 00 1d bl 4000b8b8 <_Thread_Cancel+0xa8>
<== NOT EXECUTED
4000b848: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
pending_requests = the_thread->Life.pending_life_change_requests;
4000b84c: c4 06 21 74 ld [ %i0 + 0x174 ], %g2
<== NOT EXECUTED
4000b850: c6 06 60 38 ld [ %i1 + 0x38 ], %g3
<== NOT EXECUTED
4000b854: f4 18 e0 18 ldd [ %g3 + 0x18 ], %i2
<== NOT EXECUTED
the_thread->Life.pending_life_change_requests = pending_requests + 1;
4000b858: 86 00 a0 01 add %g2, 1, %g3
<== NOT EXECUTED
if ( pending_requests == 0 ) {
4000b85c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000b860: 02 80 00 44 be 4000b970 <_Thread_Cancel+0x160>
<== NOT EXECUTED
4000b864: c6 26 21 74 st %g3, [ %i0 + 0x174 ]
<== NOT EXECUTED
4000b868: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
_Thread_State_release( the_thread, &lock_context );
_Thread_Finalize_life_change( the_thread, priority );
} else {
_Thread_Add_life_change_request( the_thread );
_Thread_Clear_state_locked( the_thread, STATES_SUSPENDED );
4000b86c: 13 00 00 20 sethi %hi(0x8000), %o1
<== NOT EXECUTED
4000b870: 40 00 0a a5 call 4000e304 <_Thread_Clear_state_locked>
<== NOT EXECUTED
4000b874: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000b878: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b87c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b880: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_State_release( the_thread, &lock_context );
_Thread_Raise_real_priority( the_thread, priority );
4000b884: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4000b888: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
4000b88c: 7f ff fe da call 4000b3f4 <_Thread_Raise_real_priority>
<== NOT EXECUTED
4000b890: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
_Thread_Remove_life_change_request( the_thread );
4000b894: 7f ff fe c3 call 4000b3a0 <_Thread_Remove_life_change_request>
<== NOT EXECUTED
4000b898: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000b89c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000b8a0: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000b8a4: 02 80 00 0d be 4000b8d8 <_Thread_Cancel+0xc8>
<== NOT EXECUTED
4000b8a8: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000b8ac: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
}
_Thread_Dispatch_enable( cpu_self );
}
4000b8b0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000b8b4: 81 e8 00 00 restore
<== NOT EXECUTED
4000b8b8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b8bc: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Make_zombie( the_thread );
4000b8c0: 7f ff ff 09 call 4000b4e4 <_Thread_Make_zombie>
<== NOT EXECUTED
4000b8c4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000b8c8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000b8cc: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000b8d0: 12 bf ff f7 bne 4000b8ac <_Thread_Cancel+0x9c>
<== NOT EXECUTED
4000b8d4: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b8d8: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000b8dc: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
<== NOT EXECUTED
4000b8e0: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000b8e4: 12 80 00 2f bne 4000b9a0 <_Thread_Cancel+0x190>
<== NOT EXECUTED
4000b8e8: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4000b8ec: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b8f0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b8f4: 01 00 00 00 nop
<== NOT EXECUTED
4000b8f8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000b8fc: 81 e8 00 00 restore
<== NOT EXECUTED
4000b900: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
4000b904: 7f ff fe e0 call 4000b484 <_Thread_Change_life_locked.part.37>
<== NOT EXECUTED
4000b908: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000b90c: c4 01 a0 18 ld [ %g6 + 0x18 ], %g2
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000b910: 84 00 a0 01 inc %g2
<== NOT EXECUTED
4000b914: c4 21 a0 18 st %g2, [ %g6 + 0x18 ]
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000b918: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
4000b91c: c6 06 60 38 ld [ %i1 + 0x38 ], %g3
<== NOT EXECUTED
if ( _States_Is_dormant( the_thread->current_state ) ) {
4000b920: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
<== NOT EXECUTED
4000b924: f4 18 e0 18 ldd [ %g3 + 0x18 ], %i2
<== NOT EXECUTED
4000b928: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000b92c: 06 bf ff e3 bl 4000b8b8 <_Thread_Cancel+0xa8>
<== NOT EXECUTED
4000b930: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
pending_requests = the_thread->Life.pending_life_change_requests;
4000b934: c4 06 21 74 ld [ %i0 + 0x174 ], %g2
<== NOT EXECUTED
the_thread->Life.pending_life_change_requests = pending_requests + 1;
4000b938: 86 00 a0 01 add %g2, 1, %g3
<== NOT EXECUTED
if ( pending_requests == 0 ) {
4000b93c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000b940: 02 80 00 12 be 4000b988 <_Thread_Cancel+0x178>
<== NOT EXECUTED
4000b944: c6 26 21 74 st %g3, [ %i0 + 0x174 ]
<== NOT EXECUTED
4000b948: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b94c: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_queue_Extract_with_proxy( the_thread );
4000b950: 40 00 0a 8f call 4000e38c <_Thread_queue_Extract_with_proxy>
<== NOT EXECUTED
4000b954: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b958: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000b95c: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
4000b960: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
<== NOT EXECUTED
4000b964: 40 00 01 e4 call 4000c0f4 <_Watchdog_Remove>
<== NOT EXECUTED
4000b968: 92 06 20 68 add %i0, 0x68, %o1
<== NOT EXECUTED
4000b96c: 30 bf ff c3 b,a 4000b878 <_Thread_Cancel+0x68>
<== NOT EXECUTED
4000b970: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
_Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING );
4000b974: 13 00 00 80 sethi %hi(0x20000), %o1
<== NOT EXECUTED
4000b978: 40 00 00 65 call 4000bb0c <_Thread_Set_state_locked>
<== NOT EXECUTED
4000b97c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000b980: 10 bf ff ba b 4000b868 <_Thread_Cancel+0x58>
<== NOT EXECUTED
4000b984: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
4000b988: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
4000b98c: 13 00 00 80 sethi %hi(0x20000), %o1
<== NOT EXECUTED
4000b990: 40 00 00 5f call 4000bb0c <_Thread_Set_state_locked>
<== NOT EXECUTED
4000b994: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000b998: 10 bf ff ec b 4000b948 <_Thread_Cancel+0x138>
<== NOT EXECUTED
4000b99c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
4000b9a0: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
4000b9a4: 7f ff f9 b8 call 4000a084 <_Thread_Do_dispatch>
<== NOT EXECUTED
4000b9a8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000b9ac: 10 bf ff d1 b 4000b8f0 <_Thread_Cancel+0xe0>
<== NOT EXECUTED
4000b9b0: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
4000ba44 <_Thread_Change_life>:
Thread_Life_state _Thread_Change_life(
Thread_Life_state clear,
Thread_Life_state set,
Thread_Life_state ignore
)
{
4000ba44: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000ba48: 91 d0 20 09 ta 9
<== NOT EXECUTED
executing = _Thread_Executing;
4000ba4c: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
previous = the_thread->Life.state;
4000ba50: fa 02 21 70 ld [ %o0 + 0x170 ], %i5
state &= ~clear;
4000ba54: 84 2f 40 18 andn %i5, %i0, %g2
state |= set;
4000ba58: b2 16 40 02 or %i1, %g2, %i1
the_thread->Life.state = state;
4000ba5c: f2 22 21 70 st %i1, [ %o0 + 0x170 ]
state &= ~ignore;
4000ba60: b2 2e 40 1a andn %i1, %i2, %i1
if (
4000ba64: 80 8e 60 09 btst 9, %i1
4000ba68: 12 80 00 07 bne 4000ba84 <_Thread_Change_life+0x40>
4000ba6c: 80 8e 60 06 btst 6, %i1
&& _Thread_Is_life_changing( state )
4000ba70: 02 80 00 05 be 4000ba84 <_Thread_Change_life+0x40>
<== ALWAYS TAKEN
4000ba74: 01 00 00 00 nop
4000ba78: 7f ff fe 83 call 4000b484 <_Thread_Change_life_locked.part.37>
<== NOT EXECUTED
4000ba7c: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
4000ba80: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000ba84: c4 01 a0 18 ld [ %g6 + 0x18 ], %g2
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000ba88: 84 00 a0 01 inc %g2
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000ba8c: 90 10 00 06 mov %g6, %o0
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000ba90: c4 21 a0 18 st %g2, [ %g6 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ba94: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ba98: 01 00 00 00 nop
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000ba9c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
if ( disable_level == 1 ) {
4000baa0: 80 a0 60 01 cmp %g1, 1
4000baa4: 02 80 00 06 be 4000babc <_Thread_Change_life+0x78>
4000baa8: 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;
}
4000baac: b0 10 00 1d mov %i5, %i0
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000bab0: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
4000bab4: 81 c7 e0 08 ret
4000bab8: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000babc: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000bac0: c4 09 a0 1c ldub [ %g6 + 0x1c ], %g2
4000bac4: 80 a0 a0 00 cmp %g2, 0
4000bac8: 12 80 00 07 bne 4000bae4 <_Thread_Change_life+0xa0>
<== NEVER TAKEN
4000bacc: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4000bad0: c0 21 a0 18 clr [ %g6 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000bad4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000bad8: 01 00 00 00 nop
4000badc: 81 c7 e0 08 ret
4000bae0: 91 e8 00 1d restore %g0, %i5, %o0
_Thread_Do_dispatch( cpu_self, level );
4000bae4: 7f ff f9 68 call 4000a084 <_Thread_Do_dispatch>
<== NOT EXECUTED
4000bae8: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
4000baec: 10 bf ff fa b 4000bad4 <_Thread_Change_life+0x90>
<== NOT EXECUTED
4000baf0: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
4000e334 <_Thread_Clear_state>:
States_Control _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
4000e334: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e338: 91 d0 20 09 ta 9
<== NOT EXECUTED
previous_state = the_thread->current_state;
4000e33c: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
if ( ( previous_state & state ) != 0 ) {
4000e340: 80 8e 40 1d btst %i1, %i5
4000e344: 02 80 00 06 be 4000e35c <_Thread_Clear_state+0x28>
<== NEVER TAKEN
4000e348: 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);
4000e34c: b2 2f 40 19 andn %i5, %i1, %i1
if ( _States_Is_ready( next_state ) ) {
4000e350: 80 a6 60 00 cmp %i1, 0
4000e354: 02 80 00 06 be 4000e36c <_Thread_Clear_state+0x38>
<== ALWAYS TAKEN
4000e358: f2 26 20 1c st %i1, [ %i0 + 0x1c ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e35c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e360: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_State_acquire( the_thread, &lock_context );
previous_state = _Thread_Clear_state_locked( the_thread, state );
_Thread_State_release( the_thread, &lock_context );
return previous_state;
}
4000e364: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e368: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
4000e36c: c2 27 bf fc st %g1, [ %fp + -4 ]
4000e370: 7f ff ff dc call 4000e2e0 <_Thread_Clear_state_locked.part.10>
4000e374: 90 10 00 18 mov %i0, %o0
4000e378: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
4000e37c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e380: 01 00 00 00 nop
4000e384: 81 c7 e0 08 ret
4000e388: 91 e8 00 1d restore %g0, %i5, %o0
4000e304 <_Thread_Clear_state_locked>:
{
4000e304: 9d e3 bf a0 save %sp, -96, %sp
previous_state = the_thread->current_state;
4000e308: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
if ( ( previous_state & state ) != 0 ) {
4000e30c: 80 8f 40 19 btst %i5, %i1
4000e310: 02 80 00 07 be 4000e32c <_Thread_Clear_state_locked+0x28>
<== NEVER TAKEN
4000e314: b2 2f 40 19 andn %i5, %i1, %i1
if ( _States_Is_ready( next_state ) ) {
4000e318: 80 a6 60 00 cmp %i1, 0
4000e31c: 12 80 00 04 bne 4000e32c <_Thread_Clear_state_locked+0x28>
<== NEVER TAKEN
4000e320: f2 26 20 1c st %i1, [ %i0 + 0x1c ]
4000e324: 7f ff ff ef call 4000e2e0 <_Thread_Clear_state_locked.part.10>
4000e328: 90 10 00 18 mov %i0, %o0
}
4000e32c: 81 c7 e0 08 ret
4000e330: 91 e8 00 1d restore %g0, %i5, %o0
4000b9c8 <_Thread_Close>:
Thread_Control *the_thread,
Thread_Control *executing,
Thread_Close_context *context
)
{
context->cancel = the_thread;
4000b9c8: d0 22 a0 24 st %o0, [ %o2 + 0x24 ]
<== NOT EXECUTED
queue_context->enqueue_callout = enqueue_callout;
4000b9cc: 03 10 00 2e sethi %hi(0x4000b800), %g1
<== NOT EXECUTED
4000b9d0: 82 10 61 b4 or %g1, 0x1b4, %g1 ! 4000b9b4 <_Thread_Close_enqueue_callout>
<== NOT EXECUTED
4000b9d4: c2 22 a0 08 st %g1, [ %o2 + 8 ]
<== NOT EXECUTED
{
4000b9d8: 96 10 00 0a mov %o2, %o3
<== NOT EXECUTED
executing->Wait.return_argument = NULL;
4000b9dc: c0 22 60 40 clr [ %o1 + 0x40 ]
<== NOT EXECUTED
queue_context->thread_state = thread_state;
4000b9e0: 03 00 00 10 sethi %hi(0x4000), %g1
<== NOT EXECUTED
4000b9e4: c2 22 e0 04 st %g1, [ %o3 + 4 ]
<== NOT EXECUTED
{
4000b9e8: 94 10 00 09 mov %o1, %o2
<== NOT EXECUTED
_Thread_queue_Enqueue(
4000b9ec: 90 02 20 10 add %o0, 0x10, %o0
<== NOT EXECUTED
4000b9f0: 13 10 00 42 sethi %hi(0x40010800), %o1
<== NOT EXECUTED
4000b9f4: 92 12 60 3c or %o1, 0x3c, %o1 ! 4001083c <_Thread_queue_Operations_priority>
<== NOT EXECUTED
4000b9f8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000b9fc: 7f ff fb 72 call 4000a7c4 <_Thread_queue_Enqueue>
<== NOT EXECUTED
4000ba00: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
400157a0 <_Thread_Continue>:
#include <rtems/score/threadimpl.h>
#include <rtems/score/status.h>
void _Thread_Continue( Thread_Control *the_thread, Status_Control status )
{
400157a0: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
queue_context->Priority.update_count = 0;
400157a4: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400157a8: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
400157ac: c2 27 bf dc st %g1, [ %fp + -36 ]
400157b0: 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 ) {
400157b4: 80 8f 60 04 btst 4, %i5
400157b8: 12 80 00 20 bne 40015838 <_Thread_Continue+0x98>
<== NEVER TAKEN
400157bc: 92 10 00 18 mov %i0, %o1
( *the_thread->Wait.operations->extract )(
400157c0: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
400157c4: c2 00 60 08 ld [ %g1 + 8 ], %g1
400157c8: d0 06 20 54 ld [ %i0 + 0x54 ], %o0
400157cc: 9f c0 40 00 call %g1
400157d0: 94 07 bf dc add %fp, -36, %o2
the_thread->Wait.operations = &_Thread_queue_Operations_default;
400157d4: 03 10 00 bb sethi %hi(0x4002ec00), %g1
400157d8: 82 10 63 98 or %g1, 0x398, %g1 ! 4002ef98 <_Thread_queue_Operations_default>
400157dc: 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;
400157e0: 03 00 00 3f sethi %hi(0xfc00), %g1
400157e4: 82 10 63 00 or %g1, 0x300, %g1 ! ff00 <_Configuration_Interrupt_stack_size+0xef00>
if ( success ) {
400157e8: c4 06 20 50 ld [ %i0 + 0x50 ], %g2
400157ec: ba 0f 40 01 and %i5, %g1, %i5
the_thread->Wait.queue = NULL;
400157f0: c0 26 20 54 clr [ %i0 + 0x54 ]
ready_again = wait_class | THREAD_WAIT_STATE_READY_AGAIN;
success = _Thread_Wait_flags_try_change_release(
400157f4: 82 17 60 01 or %i5, 1, %g1
the_thread->Wait.return_code = status;
400157f8: f4 26 20 4c st %i2, [ %i0 + 0x4c ]
ready_again = wait_class | THREAD_WAIT_STATE_READY_AGAIN;
400157fc: ba 17 60 04 or %i5, 4, %i5
if ( success ) {
40015800: 80 a0 40 02 cmp %g1, %g2
40015804: 02 80 00 0d be 40015838 <_Thread_Continue+0x98>
<== NEVER TAKEN
40015808: fa 26 20 50 st %i5, [ %i0 + 0x50 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4001580c: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40015810: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40015814: 01 00 00 00 nop
} else {
unblock = false;
}
_Thread_Wait_release( the_thread, &queue_context );
_Thread_Priority_update( &queue_context );
40015818: 7f ff f6 b5 call 400132ec <_Thread_Priority_update>
4001581c: 90 07 bf dc add %fp, -36, %o0
_Thread_Clear_state( the_thread, STATES_BLOCKED );
40015820: 90 10 00 18 mov %i0, %o0
40015824: 13 0c 00 57 sethi %hi(0x30015c00), %o1
40015828: 7f ff f6 de call 400133a0 <_Thread_Clear_state>
4001582c: 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
}
}
40015830: 81 c7 e0 08 ret
40015834: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40015838: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001583c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40015840: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( &queue_context );
40015844: 7f ff f6 aa call 400132ec <_Thread_Priority_update>
<== NOT EXECUTED
40015848: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
}
4001584c: 81 c7 e0 08 ret
<== NOT EXECUTED
40015850: 81 e8 00 00 restore
<== NOT EXECUTED
40009f74 <_Thread_Create_idle>:
_Scheduler_Start_idle( scheduler, idle, cpu );
_User_extensions_Thread_start( idle );
}
void _Thread_Create_idle( void )
{
40009f74: 9d e3 bf 70 save %sp, -144, %sp
40009f78: 03 10 00 4d sethi %hi(0x40013400), %g1
40009f7c: 84 10 20 01 mov 1, %g2
return maximum_internal_threads;
}
RTEMS_INLINE_ROUTINE Thread_Control *_Thread_Internal_allocate( void )
{
return (Thread_Control *)
40009f80: 31 10 00 4e sethi %hi(0x40013800), %i0
40009f84: c4 20 61 6c st %g2, [ %g1 + 0x16c ]
40009f88: 7f ff fa 0d call 400087bc <_Objects_Allocate_unprotected>
40009f8c: 90 16 21 d4 or %i0, 0x1d4, %o0
_Stack_Ensure_minimum( rtems_configuration_get_idle_task_stack_size() ),
40009f90: 37 10 00 3f sethi %hi(0x4000fc00), %i3
40009f94: 03 10 00 47 sethi %hi(0x40011c00), %g1
40009f98: b6 16 e2 2c or %i3, 0x22c, %i3
40009f9c: c2 00 61 80 ld [ %g1 + 0x180 ], %g1
40009fa0: f4 06 e0 20 ld [ %i3 + 0x20 ], %i2
40009fa4: 80 a6 80 01 cmp %i2, %g1
40009fa8: 1a 80 00 03 bcc 40009fb4 <_Thread_Create_idle+0x40>
<== ALWAYS TAKEN
40009fac: b8 10 00 08 mov %o0, %i4
40009fb0: b4 10 00 01 mov %g1, %i2
<== NOT EXECUTED
_Thread_Initialize(
40009fb4: 3b 10 00 3f sethi %hi(0x4000fc00), %i5
40009fb8: ba 17 63 10 or %i5, 0x310, %i5 ! 4000ff10 <_Scheduler_Table>
return ( *scheduler->Operations.map_priority )( scheduler, priority );
40009fbc: d4 07 60 44 ld [ %i5 + 0x44 ], %o2
40009fc0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40009fc4: d2 07 60 40 ld [ %i5 + 0x40 ], %o1
40009fc8: 9f c0 40 00 call %g1
40009fcc: 90 10 00 1d mov %i5, %o0
40009fd0: d0 3f bf f0 std %o0, [ %fp + -16 ]
40009fd4: 82 07 bf fc add %fp, -4, %g1
40009fd8: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
40009fdc: b2 10 20 01 mov 1, %i1
40009fe0: c2 07 bf f0 ld [ %fp + -16 ], %g1
40009fe4: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40009fe8: 98 10 00 1a mov %i2, %o4
40009fec: c2 07 bf f4 ld [ %fp + -12 ], %g1
40009ff0: f2 23 a0 64 st %i1, [ %sp + 0x64 ]
40009ff4: 9a 10 20 00 clr %o5
40009ff8: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
40009ffc: 03 12 51 13 sethi %hi(0x49444c00), %g1
4000a000: c0 23 a0 70 clr [ %sp + 0x70 ]
4000a004: 82 10 60 45 or %g1, 0x45, %g1
4000a008: c0 23 a0 6c clr [ %sp + 0x6c ]
4000a00c: 96 10 20 00 clr %o3
4000a010: c0 23 a0 68 clr [ %sp + 0x68 ]
4000a014: 94 10 00 1d mov %i5, %o2
4000a018: 92 10 00 1c mov %i4, %o1
4000a01c: 90 16 21 d4 or %i0, 0x1d4, %o0
4000a020: 40 00 00 b5 call 4000a2f4 <_Thread_Initialize>
4000a024: c2 27 bf fc st %g1, [ %fp + -4 ]
idle->Start.Entry.Kinds.Idle.entry = rtems_configuration_get_idle_task();
4000a028: c4 06 e0 1c ld [ %i3 + 0x1c ], %g2
cpu->executing = idle;
4000a02c: 37 10 00 4e sethi %hi(0x40013800), %i3
4000a030: b6 16 e1 80 or %i3, 0x180, %i3 ! 40013980 <_Per_CPU_Information>
4000a034: f8 26 e0 20 st %i4, [ %i3 + 0x20 ]
idle->Start.Entry.adaptor = _Thread_Entry_adaptor_idle;
4000a038: 03 10 00 28 sethi %hi(0x4000a000), %g1
cpu->heir =
4000a03c: f8 26 e0 24 st %i4, [ %i3 + 0x24 ]
idle->Start.Entry.adaptor = _Thread_Entry_adaptor_idle;
4000a040: 82 10 61 d0 or %g1, 0x1d0, %g1
idle->is_idle = true;
4000a044: f2 2f 20 88 stb %i1, [ %i4 + 0x88 ]
_Thread_Load_environment( idle );
4000a048: 90 10 00 1c mov %i4, %o0
idle->Start.Entry.adaptor = _Thread_Entry_adaptor_idle;
4000a04c: c2 27 20 a0 st %g1, [ %i4 + 0xa0 ]
_User_extensions_Iterate(
4000a050: 33 10 00 2f sethi %hi(0x4000bc00), %i1
idle->Start.Entry.Kinds.Idle.entry = rtems_configuration_get_idle_task();
4000a054: c4 27 20 a4 st %g2, [ %i4 + 0xa4 ]
_Thread_Load_environment( idle );
4000a058: 40 00 01 67 call 4000a5f4 <_Thread_Load_environment>
4000a05c: b4 10 20 00 clr %i2
idle->current_state = STATES_READY;
4000a060: c0 27 20 1c clr [ %i4 + 0x1c ]
( *scheduler->Operations.start_idle )( scheduler, the_thread, cpu );
4000a064: 94 10 00 1b mov %i3, %o2
4000a068: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
4000a06c: 92 10 00 1c mov %i4, %o1
4000a070: 90 10 00 1d mov %i5, %o0
4000a074: 9f c0 40 00 call %g1
4000a078: b0 10 00 1c mov %i4, %i0
4000a07c: 40 00 07 9f call 4000bef8 <_User_extensions_Iterate>
4000a080: 93 ee 62 18 restore %i1, 0x218, %o1
4001dbe0 <_Thread_Dispatch>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001dbe0: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4001dbe4: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
_ISR_Local_disable( level );
cpu_self = _Per_CPU_Get();
if ( cpu_self->dispatch_necessary ) {
4001dbe8: c4 09 a0 1c ldub [ %g6 + 0x1c ], %g2
<== NOT EXECUTED
4001dbec: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4001dbf0: 12 80 00 06 bne 4001dc08 <_Thread_Dispatch+0x28>
<== NOT EXECUTED
4001dbf4: 90 10 00 06 mov %g6, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001dbf8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001dbfc: 01 00 00 00 nop
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 1;
_Thread_Do_dispatch( cpu_self, level );
} else {
_ISR_Local_enable( level );
}
}
4001dc00: 81 c3 e0 08 retl
<== NOT EXECUTED
4001dc04: 01 00 00 00 nop
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 1;
4001dc08: 82 10 20 01 mov 1, %g1 ! 1 <_TLS_Alignment>
<== NOT EXECUTED
4001dc0c: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
4001dc10: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4001dc14: 7f ff ff ab call 4001dac0 <_Thread_Do_dispatch>
<== NOT EXECUTED
4001dc18: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000a1a4 <_Thread_Dispatch_direct>:
_ISR_Local_enable( level );
}
}
void _Thread_Dispatch_direct( Per_CPU_Control *cpu_self )
{
4000a1a4: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
if ( cpu_self->thread_dispatch_disable_level != 1 ) {
4000a1a8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
4000a1ac: 80 a0 60 01 cmp %g1, 1
4000a1b0: 12 80 00 05 bne 4000a1c4 <_Thread_Dispatch_direct+0x20>
<== NEVER TAKEN
4000a1b4: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000a1b8: 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 );
4000a1bc: 7f ff ff b2 call 4000a084 <_Thread_Do_dispatch>
4000a1c0: 93 e8 00 01 restore %g0, %g1, %o1
_Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_DISABLE_LEVEL );
4000a1c4: 7f ff f4 4a call 400072ec <_Internal_error>
<== NOT EXECUTED
4000a1c8: 90 10 20 1e mov 0x1e, %o0
<== NOT EXECUTED
4000a1cc: 01 00 00 00 nop
<== NOT EXECUTED
4000a084 <_Thread_Do_dispatch>:
_Thread_State_release( executing, &lock_context );
}
void _Thread_Do_dispatch( Per_CPU_Control *cpu_self, ISR_Level level )
{
4000a084: 9d e3 bf 98 save %sp, -104, %sp
) {
_Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT );
}
#endif
executing = cpu_self->executing;
4000a088: f6 06 20 20 ld [ %i0 + 0x20 ], %i3
{
4000a08c: 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();
4000a090: 23 10 00 3f sethi %hi(0x4000fc00), %l1
return _Chain_Immutable_head( the_chain )->next;
4000a094: 33 10 00 48 sethi %hi(0x40012000), %i1
4000a098: a2 14 62 2c or %l1, 0x22c, %l1
4000a09c: b2 16 60 28 or %i1, 0x28, %i1
_ISR_Local_enable( level );
_User_extensions_Thread_switch( executing, heir );
_Thread_Save_fp( executing );
_Context_Switch( &executing->Registers, &heir->Registers );
4000a0a0: a0 06 e0 f0 add %i3, 0xf0, %l0
if ( node != tail ) {
4000a0a4: b4 06 60 04 add %i1, 4, %i2
Per_CPU_Control *cpu_self
)
{
Thread_Control *heir;
heir = cpu_self->heir;
4000a0a8: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
cpu_self->dispatch_necessary = false;
4000a0ac: c0 2e 20 1c clrb [ %i0 + 0x1c ]
if ( heir == executing )
4000a0b0: 80 a6 c0 1c cmp %i3, %i4
4000a0b4: 02 80 00 1f be 4000a130 <_Thread_Do_dispatch+0xac>
4000a0b8: f8 26 20 20 st %i4, [ %i0 + 0x20 ]
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
4000a0bc: c4 07 20 90 ld [ %i4 + 0x90 ], %g2
4000a0c0: 80 a0 a0 01 cmp %g2, 1
4000a0c4: 12 80 00 04 bne 4000a0d4 <_Thread_Do_dispatch+0x50>
4000a0c8: 01 00 00 00 nop
heir->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice();
4000a0cc: c4 04 60 18 ld [ %l1 + 0x18 ], %g2
<== NOT EXECUTED
4000a0d0: c4 27 20 8c st %g2, [ %i4 + 0x8c ]
<== NOT EXECUTED
4000a0d4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000a0d8: 01 00 00 00 nop
4000a0dc: fa 06 40 00 ld [ %i1 ], %i5
4000a0e0: 80 a7 40 1a cmp %i5, %i2
4000a0e4: 02 80 00 0b be 4000a110 <_Thread_Do_dispatch+0x8c>
<== ALWAYS TAKEN
4000a0e8: 92 07 20 f0 add %i4, 0xf0, %o1
(*extension->thread_switch)( executing, heir );
4000a0ec: c2 07 60 08 ld [ %i5 + 8 ], %g1
<== NOT EXECUTED
4000a0f0: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4000a0f4: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000a0f8: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
4000a0fc: fa 07 40 00 ld [ %i5 ], %i5
<== NOT EXECUTED
while ( node != tail ) {
4000a100: 80 a7 40 1a cmp %i5, %i2
<== NOT EXECUTED
4000a104: 32 bf ff fb bne,a 4000a0f0 <_Thread_Do_dispatch+0x6c>
<== NOT EXECUTED
4000a108: c2 07 60 08 ld [ %i5 + 8 ], %g1
<== NOT EXECUTED
_Context_Switch( &executing->Registers, &heir->Registers );
4000a10c: 92 07 20 f0 add %i4, 0xf0, %o1
<== NOT EXECUTED
4000a110: 40 00 0a 04 call 4000c920 <_CPU_Context_switch>
4000a114: 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();
4000a118: b0 10 00 06 mov %g6, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000a11c: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_Local_disable( level );
} while ( cpu_self->dispatch_necessary );
4000a120: c4 09 a0 1c ldub [ %g6 + 0x1c ], %g2
4000a124: 80 a0 a0 00 cmp %g2, 0
4000a128: 32 bf ff e1 bne,a 4000a0ac <_Thread_Do_dispatch+0x28>
<== NEVER TAKEN
4000a12c: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
<== NOT EXECUTED
post_switch:
_Assert( cpu_self->thread_dispatch_disable_level == 1 );
cpu_self->thread_dispatch_disable_level = 0;
4000a130: c0 26 20 18 clr [ %i0 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a134: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000a138: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000a13c: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( lock_context );
4000a140: c2 27 bf fc st %g1, [ %fp + -4 ]
4000a144: d2 06 e0 e0 ld [ %i3 + 0xe0 ], %o1
return &the_chain->Tail.Node;
4000a148: ba 06 e0 e4 add %i3, 0xe4, %i5
if ( !_Chain_Is_empty(the_chain))
4000a14c: 80 a2 40 1d cmp %o1, %i5
4000a150: 02 80 00 10 be 4000a190 <_Thread_Do_dispatch+0x10c>
4000a154: b8 06 e0 e0 add %i3, 0xe0, %i4
new_first = old_first->next;
4000a158: c2 02 40 00 ld [ %o1 ], %g1
head->next = new_first;
4000a15c: c2 26 e0 e0 st %g1, [ %i3 + 0xe0 ]
( *action->handler )( executing, action, &lock_context );
4000a160: 94 07 bf fc add %fp, -4, %o2
new_first->previous = head;
4000a164: f8 20 60 04 st %i4, [ %g1 + 4 ]
node->next = NULL;
4000a168: c0 22 40 00 clr [ %o1 ]
4000a16c: c2 02 60 08 ld [ %o1 + 8 ], %g1
4000a170: 9f c0 40 00 call %g1
4000a174: 90 10 00 1b mov %i3, %o0
4000a178: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000a17c: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000a180: d2 06 e0 e0 ld [ %i3 + 0xe0 ], %o1
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
4000a184: 80 a7 40 09 cmp %i5, %o1
<== NOT EXECUTED
4000a188: 32 bf ff f5 bne,a 4000a15c <_Thread_Do_dispatch+0xd8>
<== NOT EXECUTED
4000a18c: c2 02 40 00 ld [ %o1 ], %g1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a190: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a194: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000a198: 01 00 00 00 nop
_Profiling_Thread_dispatch_enable( cpu_self, 0 );
_ISR_Local_enable( level );
_Thread_Run_post_switch_actions( executing );
}
4000a19c: 81 c7 e0 08 ret
4000a1a0: 81 e8 00 00 restore
4000a1d0 <_Thread_Entry_adaptor_idle>:
#endif
#include <rtems/score/threadimpl.h>
void _Thread_Entry_adaptor_idle( Thread_Control *executing )
{
4000a1d0: 9d e3 bf a0 save %sp, -96, %sp
const Thread_Entry_idle *idle = &executing->Start.Entry.Kinds.Idle;
( *idle->entry )( 0 );
4000a1d4: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1
4000a1d8: 9f c0 40 00 call %g1
4000a1dc: 90 10 20 00 clr %o0
}
4000a1e0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a1e4: 81 e8 00 00 restore
<== NOT EXECUTED
4000a1e8 <_Thread_Entry_adaptor_numeric>:
#endif
#include <rtems/score/threadimpl.h>
void _Thread_Entry_adaptor_numeric( Thread_Control *executing )
{
4000a1e8: 9d e3 bf a0 save %sp, -96, %sp
const Thread_Entry_numeric *numeric = &executing->Start.Entry.Kinds.Numeric;
( *numeric->entry )( numeric->argument );
4000a1ec: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1
4000a1f0: 9f c0 40 00 call %g1
4000a1f4: d0 06 20 a8 ld [ %i0 + 0xa8 ], %o0
}
4000a1f8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a1fc: 81 e8 00 00 restore
<== NOT EXECUTED
4000ba04 <_Thread_Exit>:
void _Thread_Exit(
Thread_Control *executing,
Thread_Life_state set,
void *exit_value
)
{
4000ba04: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000ba08: 91 d0 20 09 ta 9
<== NOT EXECUTED
state |= set;
4000ba0c: c4 06 21 70 ld [ %i0 + 0x170 ], %g2
4000ba10: b2 16 40 02 or %i1, %g2, %i1
the_thread->Life.exit_value = exit_value;
4000ba14: f4 26 21 78 st %i2, [ %i0 + 0x178 ]
&& _Thread_Is_life_changing( state )
4000ba18: 80 8e 60 06 btst 6, %i1
4000ba1c: 02 80 00 06 be 4000ba34 <_Thread_Exit+0x30>
<== NEVER TAKEN
4000ba20: f2 26 21 70 st %i1, [ %i0 + 0x170 ]
4000ba24: c2 27 bf fc st %g1, [ %fp + -4 ]
4000ba28: 7f ff fe 97 call 4000b484 <_Thread_Change_life_locked.part.37>
4000ba2c: 90 10 00 18 mov %i0, %o0
4000ba30: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ba34: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ba38: 01 00 00 00 nop
0,
set,
THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED
);
_Thread_State_release( executing, &lock_context );
}
4000ba3c: 81 c7 e0 08 ret
4000ba40: 81 e8 00 00 restore
4000a200 <_Thread_Get>:
ISR_lock_Context *lock_context
)
{
Objects_Information *information;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
4000a200: 80 a2 20 00 cmp %o0, 0
4000a204: 02 80 00 11 be 4000a248 <_Thread_Get+0x48>
4000a208: 83 32 20 18 srl %o0, 0x18, %g1
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
4000a20c: 82 08 60 07 and %g1, 7, %g1
if ( !the_api || the_api > OBJECTS_APIS_LAST )
4000a210: 84 00 7f ff add %g1, -1, %g2
4000a214: 80 a0 a0 02 cmp %g2, 2
4000a218: 18 80 00 10 bgu 4000a258 <_Thread_Get+0x58>
<== NEVER TAKEN
4000a21c: 83 28 60 02 sll %g1, 2, %g1
return _Objects_Information_table[ the_api ][ 1 ];
4000a220: 05 10 00 41 sethi %hi(0x40010400), %g2
4000a224: 84 10 a3 c4 or %g2, 0x3c4, %g2 ! 400107c4 <_Objects_Information_table>
4000a228: c2 00 80 01 ld [ %g2 + %g1 ], %g1
4000a22c: 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 ) {
4000a230: 80 a2 a0 00 cmp %o2, 0
4000a234: 02 80 00 09 be 4000a258 <_Thread_Get+0x58>
<== NEVER TAKEN
4000a238: 01 00 00 00 nop
return NULL;
}
return (Thread_Control *)
4000a23c: 82 13 c0 00 mov %o7, %g1
4000a240: 40 00 0f 0d call 4000de74 <_Objects_Get>
4000a244: 9e 10 40 00 mov %g1, %o7
4000a248: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( lock_context );
4000a24c: c2 22 40 00 st %g1, [ %o1 ]
return _Thread_Executing;
4000a250: 81 c3 e0 08 retl
4000a254: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
_Objects_Get( id, lock_context, information );
}
4000a258: 81 c3 e0 08 retl
<== NOT EXECUTED
4000a25c: 90 10 20 00 clr %o0
<== NOT EXECUTED
4004526c <_Thread_Get_CPU_time_used>:
void _Thread_Get_CPU_time_used(
Thread_Control *the_thread,
Timestamp_Control *cpu_time_used
)
{
4004526c: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40045270: 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 ) ) {
40045274: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2
<== NOT EXECUTED
40045278: 80 a6 00 02 cmp %i0, %g2
<== NOT EXECUTED
4004527c: 02 80 00 08 be 4004529c <_Thread_Get_CPU_time_used+0x30>
<== NOT EXECUTED
40045280: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
40045284: 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;
40045288: c4 3e 40 00 std %g2, [ %i1 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4004528c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40045290: 01 00 00 00 nop
<== NOT EXECUTED
_Scheduler_Release_critical( scheduler, &scheduler_lock_context );
_Thread_State_release( the_thread, &state_lock_context );
}
40045294: 81 c7 e0 08 ret
<== NOT EXECUTED
40045298: 81 e8 00 00 restore
<== NOT EXECUTED
last = cpu->cpu_usage_timestamp;
4004529c: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0
<== NOT EXECUTED
*time = _Timecounter_Sbinuptime();
400452a0: 7f ff 59 ba call 4001b988 <_Timecounter_Sbinuptime>
<== NOT EXECUTED
400452a4: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
400452a8: d0 3f 60 28 std %o0, [ %i5 + 0x28 ]
<== NOT EXECUTED
*_result = *_end - *_start;
400452ac: b6 a2 40 11 subcc %o1, %l1, %i3
<== NOT EXECUTED
*_time += *_add;
400452b0: f8 1e 20 98 ldd [ %i0 + 0x98 ], %i4
<== NOT EXECUTED
*_result = *_end - *_start;
400452b4: b4 62 00 10 subx %o0, %l0, %i2
<== NOT EXECUTED
*_time += *_add;
400452b8: 86 86 c0 1d addcc %i3, %i5, %g3
<== NOT EXECUTED
400452bc: 84 46 80 1c addx %i2, %i4, %g2
<== NOT EXECUTED
400452c0: c4 3e 20 98 std %g2, [ %i0 + 0x98 ]
<== NOT EXECUTED
400452c4: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
*cpu_time_used = the_thread->cpu_time_used;
400452c8: c4 3e 40 00 std %g2, [ %i1 ]
<== NOT EXECUTED
400452cc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400452d0: 01 00 00 00 nop
<== NOT EXECUTED
}
400452d4: 81 c7 e0 08 ret
<== NOT EXECUTED
400452d8: 81 e8 00 00 restore
<== NOT EXECUTED
4001aa08 <_Thread_Get_name>:
size_t _Thread_Get_name(
const Thread_Control *the_thread,
char *buffer,
size_t buffer_size
)
{
4001aa08: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
const char *name;
name = the_thread->Join_queue.Queue.name;
4001aa0c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
{
4001aa10: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
if ( name != NULL && name[ 0 ] != '\0' ) {
4001aa14: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001aa18: 02 80 00 06 be 4001aa30 <_Thread_Get_name+0x28>
<== NOT EXECUTED
4001aa1c: 96 10 00 1a mov %i2, %o3
<== NOT EXECUTED
4001aa20: c4 48 40 00 ldsb [ %g1 ], %g2
<== NOT EXECUTED
4001aa24: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4001aa28: 12 80 00 09 bne 4001aa4c <_Thread_Get_name+0x44>
<== NOT EXECUTED
4001aa2c: b2 10 00 01 mov %g1, %i1
<== NOT EXECUTED
return strlcpy( buffer, name, buffer_size );
} else {
return _Objects_Name_to_string(
4001aa30: c2 06 20 0c ld [ %i0 + 0xc ], %g1
<== NOT EXECUTED
4001aa34: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
4001aa38: 92 10 20 00 clr %o1
<== NOT EXECUTED
4001aa3c: 7f ff ff 99 call 4001a8a0 <_Objects_Name_to_string>
<== NOT EXECUTED
4001aa40: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
false,
buffer,
buffer_size
);
}
}
4001aa44: 81 c7 e0 08 ret
<== NOT EXECUTED
4001aa48: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
return strlcpy( buffer, name, buffer_size );
4001aa4c: 40 00 14 bb call 4001fd38 <strlcpy>
<== NOT EXECUTED
4001aa50: 91 e8 00 0a restore %g0, %o2, %o0
<== NOT EXECUTED
4000a260 <_Thread_Handler>:
}
#endif
}
void _Thread_Handler( void )
{
4000a260: 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();
4000a264: 3f 10 00 28 sethi %hi(0x4000a000), %i7
<== NOT EXECUTED
4000a268: be 17 e2 60 or %i7, 0x260, %i7 ! 4000a260 <_Thread_Handler>
<== NOT EXECUTED
executing = _Thread_Executing;
4000a26c: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
<== NOT EXECUTED
4000a270: 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;
4000a274: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
<== NOT EXECUTED
_ISR_Set_level( level );
4000a278: 83 28 60 08 sll %g1, 8, %g1
<== 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
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000a284: 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 );
4000a288: 7f ff ff 7f call 4000a084 <_Thread_Do_dispatch>
4000a28c: 92 10 00 01 mov %g1, %o1
_User_extensions_Iterate(
4000a290: 94 10 20 00 clr %o2
4000a294: 90 10 00 1d mov %i5, %o0
4000a298: 13 10 00 2f sethi %hi(0x4000bc00), %o1
4000a29c: 40 00 07 17 call 4000bef8 <_User_extensions_Iterate>
4000a2a0: 92 12 62 60 or %o1, 0x260, %o1 ! 4000be60 <_User_extensions_Thread_begin_visitor>
if ( executing->Object.id == _Thread_Global_constructor ) {
4000a2a4: 03 10 00 4e sethi %hi(0x40013800), %g1
4000a2a8: c6 07 60 08 ld [ %i5 + 8 ], %g3
4000a2ac: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2
4000a2b0: 80 a0 c0 02 cmp %g3, %g2
4000a2b4: 02 80 00 0c be 4000a2e4 <_Thread_Handler+0x84>
4000a2b8: 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 );
4000a2bc: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
4000a2c0: 9f c0 40 00 call %g1
4000a2c4: 90 10 00 1d mov %i5, %o0
_User_extensions_Iterate(
4000a2c8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000a2cc: 94 10 20 00 clr %o2
<== NOT EXECUTED
4000a2d0: 13 10 00 2f sethi %hi(0x4000bc00), %o1
<== NOT EXECUTED
4000a2d4: 40 00 07 09 call 4000bef8 <_User_extensions_Iterate>
<== NOT EXECUTED
4000a2d8: 92 12 62 84 or %o1, 0x284, %o1 ! 4000be84 <_User_extensions_Thread_exitted_visitor>
<== NOT EXECUTED
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
_Internal_error( INTERNAL_ERROR_THREAD_EXITTED );
4000a2dc: 7f ff f4 04 call 400072ec <_Internal_error>
<== NOT EXECUTED
4000a2e0: 90 10 20 05 mov 5, %o0
<== NOT EXECUTED
INIT_NAME();
4000a2e4: 40 00 1a 79 call 40010cc8 <_init>
4000a2e8: c0 20 61 d0 clr [ %g1 + 0x1d0 ]
( *executing->Start.Entry.adaptor )( executing );
4000a2ec: 10 bf ff f5 b 4000a2c0 <_Thread_Handler+0x60>
4000a2f0: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
4000a69c <_Thread_Handler_initialization>:
THREAD_QUEUE_HEADS_SIZE( _Scheduler_Count )
);
}
void _Thread_Handler_initialization(void)
{
4000a69c: 9d e3 bf a0 save %sp, -96, %sp
rtems_stack_allocate_init_hook stack_allocate_init_hook =
4000a6a0: 03 10 00 3f sethi %hi(0x4000fc00), %g1
4000a6a4: 82 10 62 2c or %g1, 0x22c, %g1 ! 4000fe2c <Configuration>
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
4000a6a8: c6 00 60 28 ld [ %g1 + 0x28 ], %g3
4000a6ac: 80 a0 e0 00 cmp %g3, 0
4000a6b0: 02 80 00 12 be 4000a6f8 <_Thread_Handler_initialization+0x5c>
<== NEVER TAKEN
4000a6b4: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
4000a6b8: c6 00 60 2c ld [ %g1 + 0x2c ], %g3
4000a6bc: 80 a0 e0 00 cmp %g3, 0
4000a6c0: 02 80 00 0e be 4000a6f8 <_Thread_Handler_initialization+0x5c>
<== NEVER TAKEN
4000a6c4: 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 )
4000a6c8: 22 80 00 05 be,a 4000a6dc <_Thread_Handler_initialization+0x40>
<== ALWAYS TAKEN
4000a6cc: 31 10 00 4e sethi %hi(0x40013800), %i0
(*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
4000a6d0: 9f c0 80 00 call %g2
<== NOT EXECUTED
4000a6d4: d0 00 60 04 ld [ %g1 + 4 ], %o0
<== NOT EXECUTED
/*
* Initialize the internal class of threads. We need an IDLE thread
* per CPU in an SMP system. In addition, if this is a loosely
* coupled multiprocessing system, account for the MPCI Server Thread.
*/
_Thread_Initialize_information(
4000a6d8: 31 10 00 4e sethi %hi(0x40013800), %i0
<== NOT EXECUTED
4000a6dc: ba 10 20 08 mov 8, %i5
4000a6e0: b8 10 20 00 clr %i4
4000a6e4: b6 10 20 01 mov 1, %i3
4000a6e8: b4 10 20 01 mov 1, %i2
4000a6ec: b2 10 20 01 mov 1, %i1
4000a6f0: 7f ff ff d8 call 4000a650 <_Thread_Initialize_information>
4000a6f4: 91 ee 21 d4 restore %i0, 0x1d4, %o0
_Internal_error( INTERNAL_ERROR_BAD_STACK_HOOK );
4000a6f8: 7f ff f2 fd call 400072ec <_Internal_error>
<== NOT EXECUTED
4000a6fc: 90 10 20 0e mov 0xe, %o0
<== NOT EXECUTED
4000a700: 01 00 00 00 nop
<== NOT EXECUTED
4000a2f4 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
4000a2f4: 9d e3 bf 98 save %sp, -104, %sp
4000a2f8: c2 07 a0 74 ld [ %fp + 0x74 ], %g1
return false;
}
}
#endif
memset(
4000a2fc: d4 06 20 18 ld [ %i0 + 0x18 ], %o2
{
4000a300: e8 00 40 00 ld [ %g1 ], %l4
return (uintptr_t) _TLS_BSS_end - (uintptr_t) _TLS_Data_begin;
4000a304: 03 10 00 43 sethi %hi(0x40010c00), %g1
4000a308: 82 10 61 00 or %g1, 0x100, %g1 ! 40010d00 <_Linker_set__Sysinit_bsp_work_area_initialize>
4000a30c: e4 07 a0 5c ld [ %fp + 0x5c ], %l2
4000a310: e6 07 a0 60 ld [ %fp + 0x60 ], %l3
4000a314: e2 07 a0 68 ld [ %fp + 0x68 ], %l1
4000a318: ea 0f a0 67 ldub [ %fp + 0x67 ], %l5
memset(
4000a31c: 94 02 bf f0 add %o2, -16, %o2
4000a320: 21 10 00 43 sethi %hi(0x40010c00), %l0
4000a324: 92 10 20 00 clr %o1
4000a328: a0 14 21 00 or %l0, 0x100, %l0
4000a32c: 90 06 60 10 add %i1, 0x10, %o0
4000a330: 40 00 11 83 call 4000e93c <memset>
4000a334: 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 ) {
4000a338: 03 10 00 3f sethi %hi(0x4000fc00), %g1
4000a33c: de 00 62 68 ld [ %g1 + 0x268 ], %o7 ! 4000fe68 <_Thread_Control_add_on_count>
4000a340: 80 a3 e0 00 cmp %o7, 0
4000a344: 02 80 00 0e be 4000a37c <_Thread_Initialize+0x88>
<== NEVER TAKEN
4000a348: 80 a6 e0 00 cmp %i3, 0
4000a34c: 03 10 00 3f sethi %hi(0x4000fc00), %g1
4000a350: 86 10 20 00 clr %g3
4000a354: 82 10 62 6c or %g1, 0x26c, %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;
4000a358: c4 00 60 04 ld [ %g1 + 4 ], %g2
*(void **) ( (char *) the_thread + add_on->destination_offset ) =
4000a35c: c8 00 40 00 ld [ %g1 ], %g4
(char *) the_thread + add_on->source_offset;
4000a360: 84 06 40 02 add %i1, %g2, %g2
*(void **) ( (char *) the_thread + add_on->destination_offset ) =
4000a364: c4 26 40 04 st %g2, [ %i1 + %g4 ]
for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) {
4000a368: 86 00 e0 01 inc %g3
4000a36c: 80 a0 c0 0f cmp %g3, %o7
4000a370: 12 bf ff fa bne 4000a358 <_Thread_Initialize+0x64>
4000a374: 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 ) {
4000a378: 80 a6 e0 00 cmp %i3, 0
4000a37c: 02 80 00 93 be 4000a5c8 <_Thread_Initialize+0x2d4>
<== ALWAYS TAKEN
4000a380: 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;
4000a384: c0 2e 60 c8 clrb [ %i1 + 0xc8 ]
<== NOT EXECUTED
4000a388: ac 06 20 3c add %i0, 0x3c, %l6
the_stack->area = starting_address;
4000a38c: f6 26 60 d0 st %i3, [ %i1 + 0xd0 ]
);
scheduler_index = 0;
/* Thread-local storage (TLS) area allocation */
if ( tls_size > 0 ) {
4000a390: 80 a4 20 00 cmp %l0, 0
4000a394: 12 80 00 6a bne 4000a53c <_Thread_Initialize+0x248>
<== NEVER TAKEN
4000a398: 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 ) {
4000a39c: 80 a7 60 00 cmp %i5, 0
4000a3a0: 12 80 00 79 bne 4000a584 <_Thread_Initialize+0x290>
4000a3a4: b8 10 20 00 clr %i4
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
if ( !fp_area )
goto failed;
}
the_thread->fp_context = fp_area;
4000a3a8: f8 26 61 50 st %i4, [ %i1 + 0x150 ]
the_thread->Start.fp_context = fp_area;
4000a3ac: f8 26 60 d4 st %i4, [ %i1 + 0xd4 ]
return information->auto_extend ? information->allocation_size : 0;
4000a3b0: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
4000a3b4: 80 a0 60 00 cmp %g1, 0
4000a3b8: 12 80 00 5f bne 4000a534 <_Thread_Initialize+0x240>
4000a3bc: 94 10 20 00 clr %o2
#endif
/*
* Get thread queue heads
*/
the_thread->Wait.spare_heads = _Freechain_Get(
4000a3c0: 96 10 20 48 mov 0x48, %o3
4000a3c4: 90 10 00 16 mov %l6, %o0
4000a3c8: 13 10 00 31 sethi %hi(0x4000c400), %o1
4000a3cc: 7f ff f1 f9 call 40006bb0 <_Freechain_Get>
4000a3d0: 92 12 60 e0 or %o1, 0xe0, %o1 ! 4000c4e0 <_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 ) {
4000a3d4: 80 a2 20 00 cmp %o0, 0
4000a3d8: 02 80 00 48 be 4000a4f8 <_Thread_Initialize+0x204>
<== NEVER TAKEN
4000a3dc: d0 26 60 5c st %o0, [ %i1 + 0x5c ]
return &the_chain->Tail.Node;
4000a3e0: 82 02 20 34 add %o0, 0x34, %g1
head->previous = NULL;
4000a3e4: c0 22 20 34 clr [ %o0 + 0x34 ]
return &the_chain->Tail.Node;
4000a3e8: 84 02 20 30 add %o0, 0x30, %g2
head->next = tail;
4000a3ec: 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 ) {
4000a3f0: 80 a4 60 02 cmp %l1, 2
tail->previous = head;
4000a3f4: c4 22 20 38 st %g2, [ %o0 + 0x38 ]
the_thread->Start.isr_level = isr_level;
4000a3f8: c2 07 a0 70 ld [ %fp + 0x70 ], %g1
4000a3fc: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ]
the_thread->Start.budget_callout = budget_callout;
4000a400: c2 07 a0 6c ld [ %fp + 0x6c ], %g1
4000a404: 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 ];
4000a408: 03 10 00 4e sethi %hi(0x40013800), %g1
4000a40c: 82 10 61 b8 or %g1, 0x1b8, %g1 ! 400139b8 <_Per_CPU_Information+0x38>
the_thread->is_fp = is_fp;
4000a410: fa 2e 60 8a stb %i5, [ %i1 + 0x8a ]
4000a414: 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;
4000a418: 82 10 20 02 mov 2, %g1
the_thread->Start.is_preemptible = is_preemptible;
4000a41c: ea 2e 60 ac stb %l5, [ %i1 + 0xac ]
the_thread->Start.budget_algorithm = budget_algorithm;
4000a420: e2 26 60 b0 st %l1, [ %i1 + 0xb0 ]
switch ( budget_algorithm ) {
4000a424: 12 80 00 05 bne 4000a438 <_Thread_Initialize+0x144>
<== ALWAYS TAKEN
4000a428: 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();
4000a42c: 03 10 00 3f sethi %hi(0x4000fc00), %g1
<== NOT EXECUTED
the_thread->cpu_time_budget =
4000a430: c2 00 62 44 ld [ %g1 + 0x244 ], %g1 ! 4000fe44 <Configuration+0x18>
<== NOT EXECUTED
4000a434: c2 26 60 8c st %g1, [ %i1 + 0x8c ]
<== NOT EXECUTED
( *scheduler->Operations.node_initialize )(
4000a438: 96 10 00 12 mov %l2, %o3
4000a43c: fa 06 60 38 ld [ %i1 + 0x38 ], %i5
4000a440: c2 06 a0 24 ld [ %i2 + 0x24 ], %g1
4000a444: 98 10 00 13 mov %l3, %o4
4000a448: 94 10 00 19 mov %i1, %o2
4000a44c: 92 10 00 1d mov %i5, %o1
4000a450: 9f c0 40 00 call %g1
4000a454: 90 10 00 1a mov %i2, %o0
RTEMS_INLINE_ROUTINE void _Priority_Node_initialize(
Priority_Node *node,
Priority_Control priority
)
{
node->priority = priority;
4000a458: 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 );
4000a45c: 82 06 60 20 add %i1, 0x20, %g1
node->priority = priority;
4000a460: 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;
4000a464: 05 20 00 00 sethi %hi(0x80000000), %g2
RB_ROOT( the_rbtree ) = the_node;
4000a468: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
return &the_chain->Tail.Node;
4000a46c: 86 06 60 e0 add %i1, 0xe0, %g3
4000a470: c4 26 60 1c st %g2, [ %i1 + 0x1c ]
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4000a474: 05 10 00 42 sethi %hi(0x40010800), %g2
4000a478: 84 10 a0 50 or %g2, 0x50, %g2 ! 40010850 <_Thread_queue_Operations_default>
information->local_table[ index ] = the_object;
4000a47c: c2 16 60 0a lduh [ %i1 + 0xa ], %g1
4000a480: c4 26 60 58 st %g2, [ %i1 + 0x58 ]
4000a484: 88 06 60 e4 add %i1, 0xe4, %g4
4000a488: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
RB_PARENT( the_node, Node ) = NULL;
4000a48c: c0 26 60 28 clr [ %i1 + 0x28 ]
4000a490: 83 28 60 02 sll %g1, 2, %g1
RB_LEFT( the_node, Node ) = NULL;
4000a494: c0 26 60 20 clr [ %i1 + 0x20 ]
_User_extensions_Iterate(
4000a498: 94 10 20 00 clr %o2
RB_RIGHT( the_node, Node ) = NULL;
4000a49c: c0 26 60 24 clr [ %i1 + 0x24 ]
4000a4a0: 13 10 00 2f sethi %hi(0x4000bc00), %o1
RB_COLOR( the_node, Node ) = RB_BLACK;
4000a4a4: c0 26 60 2c clr [ %i1 + 0x2c ]
4000a4a8: 92 12 61 b8 or %o1, 0x1b8, %o1
the_thread->Start.initial_priority = priority;
4000a4ac: e4 3e 60 c0 std %l2, [ %i1 + 0xc0 ]
4000a4b0: 90 07 bf f8 add %fp, -8, %o0
RB_INIT( the_rbtree );
4000a4b4: c0 26 61 60 clr [ %i1 + 0x160 ]
head->next = tail;
4000a4b8: c8 26 60 e0 st %g4, [ %i1 + 0xe0 ]
head->previous = NULL;
4000a4bc: c0 26 60 e4 clr [ %i1 + 0xe4 ]
tail->previous = head;
4000a4c0: c6 26 60 e8 st %g3, [ %i1 + 0xe8 ]
the_object->name = name;
4000a4c4: e8 26 60 0c st %l4, [ %i1 + 0xc ]
information->local_table[ index ] = the_object;
4000a4c8: f2 20 80 01 st %i1, [ %g2 + %g1 ]
User_extensions_Thread_create_context ctx = { created, true };
4000a4cc: 82 10 20 01 mov 1, %g1
4000a4d0: f2 27 bf f8 st %i1, [ %fp + -8 ]
_User_extensions_Iterate(
4000a4d4: 40 00 06 89 call 4000bef8 <_User_extensions_Iterate>
4000a4d8: 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 )
4000a4dc: f0 0f bf fc ldub [ %fp + -4 ], %i0
4000a4e0: 80 a6 20 00 cmp %i0, 0
4000a4e4: 12 80 00 0f bne 4000a520 <_Thread_Initialize+0x22c>
<== ALWAYS TAKEN
4000a4e8: 92 10 00 1d mov %i5, %o1
( *scheduler->Operations.node_destroy )( scheduler, node );
4000a4ec: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
<== NOT EXECUTED
4000a4f0: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000a4f4: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
4000a4f8: d0 06 60 dc ld [ %i1 + 0xdc ], %o0
<== NOT EXECUTED
if ( scheduler_index > 0 ) {
_Scheduler_Node_destroy( scheduler, scheduler_node );
}
#endif
_Workspace_Free( the_thread->Start.tls_area );
4000a4fc: 40 00 08 09 call 4000c520 <_Workspace_Free>
<== NOT EXECUTED
4000a500: b0 10 20 00 clr %i0
<== NOT EXECUTED
_Freechain_Put(
4000a504: d2 06 60 5c ld [ %i1 + 0x5c ], %o1
<== NOT EXECUTED
4000a508: 7f ff f1 c8 call 40006c28 <_Freechain_Put>
<== NOT EXECUTED
4000a50c: 90 10 00 16 mov %l6, %o0
<== NOT EXECUTED
&information->Free_thread_queue_heads,
the_thread->Wait.spare_heads
);
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
4000a510: 40 00 08 04 call 4000c520 <_Workspace_Free>
<== NOT EXECUTED
4000a514: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
#endif
_Thread_Stack_Free( the_thread );
4000a518: 40 00 05 ae call 4000bbd0 <_Thread_Stack_Free>
<== NOT EXECUTED
4000a51c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
return false;
4000a520: 81 c7 e0 08 ret
4000a524: 81 e8 00 00 restore
4000a528: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000a52c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a530: 81 e8 00 00 restore
<== NOT EXECUTED
4000a534: 10 bf ff a3 b 4000a3c0 <_Thread_Initialize+0xcc>
4000a538: d4 16 20 14 lduh [ %i0 + 0x14 ], %o2
return (val + msk) & ~msk;
4000a53c: 90 04 20 07 add %l0, 7, %o0
<== NOT EXECUTED
4000a540: 13 00 00 00 sethi %hi(0), %o1
<== NOT EXECUTED
4000a544: 90 0a 3f f8 and %o0, -8, %o0
<== NOT EXECUTED
4000a548: 92 12 60 01 or %o1, 1, %o1
<== NOT EXECUTED
4000a54c: 92 02 60 07 add %o1, 7, %o1
<== NOT EXECUTED
4000a550: 92 0a 7f f8 and %o1, -8, %o1
<== NOT EXECUTED
sizeof(TLS_Thread_control_block) : alignment;
4000a554: 80 a2 60 08 cmp %o1, 8
<== NOT EXECUTED
4000a558: 0a 80 00 12 bcs 4000a5a0 <_Thread_Initialize+0x2ac>
<== NOT EXECUTED
4000a55c: 82 10 00 09 mov %o1, %g1
<== NOT EXECUTED
allocation_size += _TLS_Get_thread_control_block_area_size( alignment );
4000a560: 90 02 00 01 add %o0, %g1, %o0
<== NOT EXECUTED
_Workspace_Allocate_aligned( tls_alloc, tls_align );
4000a564: 40 00 07 e7 call 4000c500 <_Workspace_Allocate_aligned>
<== NOT EXECUTED
4000a568: 90 02 20 08 add %o0, 8, %o0
<== NOT EXECUTED
the_thread->Start.tls_area =
4000a56c: d0 26 60 dc st %o0, [ %i1 + 0xdc ]
<== NOT EXECUTED
if ( the_thread->Start.tls_area == NULL ) {
4000a570: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000a574: 12 bf ff 8a bne 4000a39c <_Thread_Initialize+0xa8>
<== NOT EXECUTED
4000a578: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
failed:
4000a57c: 10 bf ff e0 b 4000a4fc <_Thread_Initialize+0x208>
<== NOT EXECUTED
4000a580: 90 10 20 00 clr %o0
<== NOT EXECUTED
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
4000a584: 40 00 07 d7 call 4000c4e0 <_Workspace_Allocate>
4000a588: 90 10 20 88 mov 0x88, %o0
if ( !fp_area )
4000a58c: b8 92 20 00 orcc %o0, 0, %i4
4000a590: 32 bf ff 87 bne,a 4000a3ac <_Thread_Initialize+0xb8>
<== ALWAYS TAKEN
4000a594: f8 26 61 50 st %i4, [ %i1 + 0x150 ]
failed:
4000a598: 10 bf ff d9 b 4000a4fc <_Thread_Initialize+0x208>
<== NOT EXECUTED
4000a59c: d0 06 60 dc ld [ %i1 + 0xdc ], %o0
<== NOT EXECUTED
sizeof(TLS_Thread_control_block) : alignment;
4000a5a0: 82 10 20 08 mov 8, %g1
<== NOT EXECUTED
allocation_size += _TLS_Get_thread_control_block_area_size( alignment );
4000a5a4: 90 02 00 01 add %o0, %g1, %o0
<== NOT EXECUTED
_Workspace_Allocate_aligned( tls_alloc, tls_align );
4000a5a8: 40 00 07 d6 call 4000c500 <_Workspace_Allocate_aligned>
<== NOT EXECUTED
4000a5ac: 90 02 20 08 add %o0, 8, %o0
<== NOT EXECUTED
the_thread->Start.tls_area =
4000a5b0: d0 26 60 dc st %o0, [ %i1 + 0xdc ]
<== NOT EXECUTED
if ( the_thread->Start.tls_area == NULL ) {
4000a5b4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000a5b8: 12 bf ff 79 bne 4000a39c <_Thread_Initialize+0xa8>
<== NOT EXECUTED
4000a5bc: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
4000a5c0: 10 bf ff cf b 4000a4fc <_Thread_Initialize+0x208>
<== NOT EXECUTED
4000a5c4: 90 10 20 00 clr %o0
<== NOT EXECUTED
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
4000a5c8: 40 00 05 72 call 4000bb90 <_Thread_Stack_Allocate>
4000a5cc: 90 10 00 19 mov %i1, %o0
if ( !actual_stack_size || actual_stack_size < stack_size )
4000a5d0: 80 a2 20 00 cmp %o0, 0
4000a5d4: 02 bf ff d5 be 4000a528 <_Thread_Initialize+0x234>
<== NEVER TAKEN
4000a5d8: 80 a2 00 1c cmp %o0, %i4
4000a5dc: 0a bf ff d3 bcs 4000a528 <_Thread_Initialize+0x234>
<== NEVER TAKEN
4000a5e0: 82 10 20 01 mov 1, %g1
stack = the_thread->Start.stack;
4000a5e4: f6 06 60 d8 ld [ %i1 + 0xd8 ], %i3
the_thread->Start.core_allocated_stack = true;
4000a5e8: c2 2e 60 c8 stb %g1, [ %i1 + 0xc8 ]
4000a5ec: 10 bf ff 67 b 4000a388 <_Thread_Initialize+0x94>
4000a5f0: b8 10 00 08 mov %o0, %i4
40013a78 <_Thread_Iterate>:
void _Thread_Iterate(
Thread_Visitor visitor,
void *arg
)
{
40013a78: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
40013a7c: 37 10 00 bb sethi %hi(0x4002ec00), %i3
<== NOT EXECUTED
40013a80: b6 16 e2 f0 or %i3, 0x2f0, %i3 ! 4002eef0 <_Objects_Information_table>
<== NOT EXECUTED
40013a84: 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 ];
40013a88: c2 06 e0 04 ld [ %i3 + 4 ], %g1
<== NOT EXECUTED
40013a8c: f8 00 60 04 ld [ %g1 + 4 ], %i4
<== NOT EXECUTED
if ( information == NULL ) {
40013a90: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
40013a94: 22 80 00 1d be,a 40013b08 <_Thread_Iterate+0x90>
<== NOT EXECUTED
40013a98: b6 06 e0 04 add %i3, 4, %i3
<== NOT EXECUTED
continue;
}
for ( i = 1 ; i <= information->maximum ; ++i ) {
40013a9c: c4 17 20 10 lduh [ %i4 + 0x10 ], %g2
<== NOT EXECUTED
40013aa0: 82 90 a0 00 orcc %g2, 0, %g1
<== NOT EXECUTED
40013aa4: 02 80 00 18 be 40013b04 <_Thread_Iterate+0x8c>
<== NOT EXECUTED
40013aa8: ba 10 20 01 mov 1, %i5
<== NOT EXECUTED
Thread_Control *the_thread;
the_thread = (Thread_Control *) information->local_table[ i ];
40013aac: 10 80 00 09 b 40013ad0 <_Thread_Iterate+0x58>
<== NOT EXECUTED
40013ab0: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
<== NOT EXECUTED
for ( i = 1 ; i <= information->maximum ; ++i ) {
40013ab4: ba 07 60 01 inc %i5
<== NOT EXECUTED
40013ab8: 83 28 a0 10 sll %g2, 0x10, %g1
<== NOT EXECUTED
40013abc: 87 2f 60 10 sll %i5, 0x10, %g3
<== NOT EXECUTED
40013ac0: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
40013ac4: 38 80 00 11 bgu,a 40013b08 <_Thread_Iterate+0x90>
<== NOT EXECUTED
40013ac8: b6 06 e0 04 add %i3, 4, %i3
<== NOT EXECUTED
the_thread = (Thread_Control *) information->local_table[ i ];
40013acc: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
<== NOT EXECUTED
40013ad0: 83 2f 60 10 sll %i5, 0x10, %g1
<== NOT EXECUTED
40013ad4: 83 30 60 0e srl %g1, 0xe, %g1
<== NOT EXECUTED
40013ad8: d0 00 c0 01 ld [ %g3 + %g1 ], %o0
<== NOT EXECUTED
if ( the_thread != NULL ) {
40013adc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40013ae0: 22 bf ff f6 be,a 40013ab8 <_Thread_Iterate+0x40>
<== NOT EXECUTED
40013ae4: ba 07 60 01 inc %i5
<== NOT EXECUTED
bool done;
done = (* visitor )( the_thread, arg );
40013ae8: 9f c6 00 00 call %i0
<== NOT EXECUTED
40013aec: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
if ( done ) {
40013af0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40013af4: 22 bf ff f0 be,a 40013ab4 <_Thread_Iterate+0x3c>
<== NOT EXECUTED
40013af8: c4 17 20 10 lduh [ %i4 + 0x10 ], %g2
<== NOT EXECUTED
return;
}
}
}
}
}
40013afc: 81 c7 e0 08 ret
<== NOT EXECUTED
40013b00: 81 e8 00 00 restore
<== NOT EXECUTED
40013b04: b6 06 e0 04 add %i3, 4, %i3
<== NOT EXECUTED
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; ++api_index ) {
40013b08: 80 a6 80 1b cmp %i2, %i3
<== NOT EXECUTED
40013b0c: 32 bf ff e0 bne,a 40013a8c <_Thread_Iterate+0x14>
<== NOT EXECUTED
40013b10: c2 06 e0 04 ld [ %i3 + 4 ], %g1
<== NOT EXECUTED
}
40013b14: 81 c7 e0 08 ret
<== NOT EXECUTED
40013b18: 81 e8 00 00 restore
<== NOT EXECUTED
4000b6f0 <_Thread_Kill_zombies>:
{
4000b6f0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b6f4: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000b6f8: 05 10 00 48 sethi %hi(0x40012000), %g2
4000b6fc: fa 00 a0 34 ld [ %g2 + 0x34 ], %i5 ! 40012034 <_Thread_Zombies>
4000b700: b8 10 a0 34 or %g2, 0x34, %i4
if ( !_Chain_Is_empty(the_chain))
4000b704: b0 07 20 04 add %i4, 4, %i0
4000b708: 80 a7 40 18 cmp %i5, %i0
4000b70c: 02 80 00 3d be 4000b800 <_Thread_Kill_zombies+0x110>
4000b710: 33 10 00 2f sethi %hi(0x4000bc00), %i1
new_first = old_first->next;
4000b714: c6 07 40 00 ld [ %i5 ], %g3
<== NOT EXECUTED
head->next = new_first;
4000b718: c6 20 a0 34 st %g3, [ %g2 + 0x34 ]
<== NOT EXECUTED
new_first->previous = head;
4000b71c: f8 20 e0 04 st %i4, [ %g3 + 4 ]
<== NOT EXECUTED
4000b720: 35 10 00 3f sethi %hi(0x4000fc00), %i2
<== NOT EXECUTED
_User_extensions_Iterate(
4000b724: b2 16 61 f4 or %i1, 0x1f4, %i1
<== NOT EXECUTED
4000b728: b4 16 a3 10 or %i2, 0x310, %i2
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b72c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b730: 01 00 00 00 nop
Thread_Information *information = (Thread_Information *)
4000b734: 7f ff f5 4e call 40008c6c <_Objects_Get_information_id>
4000b738: d0 07 60 08 ld [ %i5 + 8 ], %o0
4000b73c: 94 10 20 01 mov 1, %o2
4000b740: b6 10 00 08 mov %o0, %i3
4000b744: 92 10 00 19 mov %i1, %o1
4000b748: 40 00 01 ec call 4000bef8 <_User_extensions_Iterate>
4000b74c: 90 10 00 1d mov %i5, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b750: 91 d0 20 09 ta 9
<== NOT EXECUTED
iter = the_thread->last_user_extensions_iterator;
4000b754: c4 07 61 88 ld [ %i5 + 0x188 ], %g2
while ( iter != NULL ) {
4000b758: 80 a0 a0 00 cmp %g2, 0
4000b75c: 02 80 00 0a be 4000b784 <_Thread_Kill_zombies+0x94>
<== ALWAYS TAKEN
4000b760: 01 00 00 00 nop
next = the_node->next;
4000b764: c8 00 80 00 ld [ %g2 ], %g4
<== NOT EXECUTED
previous = the_node->previous;
4000b768: c6 00 a0 04 ld [ %g2 + 4 ], %g3
<== NOT EXECUTED
next->previous = previous;
4000b76c: c6 21 20 04 st %g3, [ %g4 + 4 ]
<== NOT EXECUTED
previous->next = next;
4000b770: c8 20 c0 00 st %g4, [ %g3 ]
<== NOT EXECUTED
iter = iter->previous;
4000b774: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
<== NOT EXECUTED
while ( iter != NULL ) {
4000b778: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000b77c: 32 bf ff fb bne,a 4000b768 <_Thread_Kill_zombies+0x78>
<== NOT EXECUTED
4000b780: c8 00 80 00 ld [ %g2 ], %g4
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b784: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b788: 01 00 00 00 nop
4000b78c: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
4000b790: d2 07 60 38 ld [ %i5 + 0x38 ], %o1
4000b794: 9f c0 40 00 call %g1
4000b798: 90 10 00 1a mov %i2, %o0
_Workspace_Free( the_thread->Start.fp_context );
4000b79c: 40 00 03 61 call 4000c520 <_Workspace_Free>
4000b7a0: d0 07 60 d4 ld [ %i5 + 0xd4 ], %o0
_Freechain_Put(
4000b7a4: d2 07 60 5c ld [ %i5 + 0x5c ], %o1
4000b7a8: 7f ff ed 20 call 40006c28 <_Freechain_Put>
4000b7ac: 90 06 e0 3c add %i3, 0x3c, %o0
_Thread_Stack_Free( the_thread );
4000b7b0: 40 00 01 08 call 4000bbd0 <_Thread_Stack_Free>
4000b7b4: 90 10 00 1d mov %i5, %o0
_Workspace_Free( the_thread->Start.tls_area );
4000b7b8: 40 00 03 5a call 4000c520 <_Workspace_Free>
4000b7bc: d0 07 60 dc ld [ %i5 + 0xdc ], %o0
_Context_Destroy( the_thread, &the_thread->Registers );
4000b7c0: c4 01 a0 04 ld [ %g6 + 4 ], %g2
4000b7c4: 80 a0 80 1d cmp %g2, %i5
4000b7c8: 22 80 00 02 be,a 4000b7d0 <_Thread_Kill_zombies+0xe0>
<== NEVER TAKEN
4000b7cc: c0 21 a0 04 clr [ %g6 + 4 ]
<== NOT EXECUTED
_Objects_Free( &information->Objects, &the_thread->Object );
4000b7d0: 92 10 00 1d mov %i5, %o1
4000b7d4: 7f ff f4 fa call 40008bbc <_Objects_Free>
4000b7d8: 90 10 00 1b mov %i3, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b7dc: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000b7e0: fa 07 00 00 ld [ %i4 ], %i5
if ( !_Chain_Is_empty(the_chain))
4000b7e4: 80 a7 40 18 cmp %i5, %i0
4000b7e8: 02 80 00 06 be 4000b800 <_Thread_Kill_zombies+0x110>
4000b7ec: 01 00 00 00 nop
new_first = old_first->next;
4000b7f0: c4 07 40 00 ld [ %i5 ], %g2
head->next = new_first;
4000b7f4: c4 27 00 00 st %g2, [ %i4 ]
new_first->previous = head;
4000b7f8: 10 bf ff cd b 4000b72c <_Thread_Kill_zombies+0x3c>
4000b7fc: f8 20 a0 04 st %i4, [ %g2 + 4 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b800: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b804: 01 00 00 00 nop
}
4000b808: 81 c7 e0 08 ret
4000b80c: 81 e8 00 00 restore
400132a8 <_Thread_Priority_add>:
Thread_Control *the_thread,
Priority_Node *priority_node,
Thread_queue_Context *queue_context
)
{
_Thread_Priority_apply(
400132a8: 98 10 20 00 clr %o4
<== NOT EXECUTED
400132ac: 96 10 20 00 clr %o3
<== NOT EXECUTED
400132b0: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400132b4: 7f ff ff e7 call 40013250 <_Thread_Priority_apply>
<== NOT EXECUTED
400132b8: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000e1c8 <_Thread_Priority_perform_actions>:
void _Thread_Priority_perform_actions(
Thread_Control *start_of_path,
Thread_queue_Context *queue_context
)
{
4000e1c8: 9d e3 bf a0 save %sp, -96, %sp
4000e1cc: f8 06 60 14 ld [ %i1 + 0x14 ], %i4
4000e1d0: 10 80 00 03 b 4000e1dc <_Thread_Priority_perform_actions+0x14>
4000e1d4: 90 10 00 18 mov %i0, %o0
queue_context->Priority.update_count = update_count;
4000e1d8: f8 26 60 14 st %i4, [ %i1 + 0x14 ]
<== NOT EXECUTED
while ( true ) {
Thread_queue_Queue *queue;
queue = the_thread->Wait.queue;
_Thread_Priority_do_perform_actions(
4000e1dc: 98 10 00 19 mov %i1, %o4
queue = the_thread->Wait.queue;
4000e1e0: fa 02 20 54 ld [ %o0 + 0x54 ], %i5
_Thread_Priority_do_perform_actions(
4000e1e4: d4 02 20 58 ld [ %o0 + 0x58 ], %o2
4000e1e8: 96 10 20 00 clr %o3
4000e1ec: 7f ff ff 51 call 4000df30 <_Thread_Priority_do_perform_actions.isra.14>
4000e1f0: 92 10 00 1d mov %i5, %o1
the_thread->Wait.operations,
false,
queue_context
);
if ( _Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) {
4000e1f4: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000e1f8: 80 a0 60 00 cmp %g1, 0
4000e1fc: 32 bf ff f7 bne,a 4000e1d8 <_Thread_Priority_perform_actions+0x10>
<== NEVER TAKEN
4000e200: d0 07 60 04 ld [ %i5 + 4 ], %o0
<== NOT EXECUTED
_Thread_queue_Context_restore_priority_updates(
queue_context,
update_count
);
}
}
4000e204: 81 c7 e0 08 ret
4000e208: 81 e8 00 00 restore
400132bc <_Thread_Priority_remove>:
Thread_Control *the_thread,
Priority_Node *priority_node,
Thread_queue_Context *queue_context
)
{
_Thread_Priority_apply(
400132bc: 98 10 20 02 mov 2, %o4
<== NOT EXECUTED
400132c0: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
400132c4: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400132c8: 7f ff ff e2 call 40013250 <_Thread_Priority_apply>
<== NOT EXECUTED
400132cc: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000e280 <_Thread_Priority_update>:
replacement_node
);
}
void _Thread_Priority_update( Thread_queue_Context *queue_context )
{
4000e280: 9d e3 bf 98 save %sp, -104, %sp
size_t i;
size_t n;
n = queue_context->Priority.update_count;
4000e284: fa 06 20 14 ld [ %i0 + 0x14 ], %i5
/*
* Update the priority of all threads of the set. Do not care to clear the
* set, since the thread queue context will soon get destroyed anyway.
*/
for ( i = 0; i < n ; ++i ) {
4000e288: 80 a7 60 00 cmp %i5, 0
4000e28c: 02 80 00 13 be 4000e2d8 <_Thread_Priority_update+0x58>
4000e290: 39 10 00 3f sethi %hi(0x4000fc00), %i4
4000e294: b8 17 23 10 or %i4, 0x310, %i4 ! 4000ff10 <_Scheduler_Table>
<== NOT EXECUTED
( *scheduler->Operations.update_priority )(
4000e298: f6 07 20 18 ld [ %i4 + 0x18 ], %i3
<== NOT EXECUTED
4000e29c: bb 2f 60 02 sll %i5, 2, %i5
<== NOT EXECUTED
4000e2a0: 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 ];
4000e2a4: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e2a8: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000e2ac: c2 27 bf fc st %g1, [ %fp + -4 ]
4000e2b0: d4 02 60 38 ld [ %o1 + 0x38 ], %o2
4000e2b4: 9f c6 c0 00 call %i3
4000e2b8: 90 10 00 1c mov %i4, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e2bc: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e2c0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e2c4: 01 00 00 00 nop
4000e2c8: b0 06 20 04 add %i0, 4, %i0
for ( i = 0; i < n ; ++i ) {
4000e2cc: 80 a6 00 1d cmp %i0, %i5
4000e2d0: 32 bf ff f6 bne,a 4000e2a8 <_Thread_Priority_update+0x28>
<== NEVER TAKEN
4000e2d4: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
<== NOT EXECUTED
_Thread_State_acquire( the_thread, &lock_context );
_Scheduler_Update_priority( the_thread );
_Thread_State_release( the_thread, &lock_context );
}
}
4000e2d8: 81 c7 e0 08 ret
4000e2dc: 81 e8 00 00 restore
4000bb44 <_Thread_Set_state>:
States_Control _Thread_Set_state(
Thread_Control *the_thread,
States_Control state
)
{
4000bb44: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
4000bb48: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000bb4c: 91 d0 20 09 ta 9
<== NOT EXECUTED
previous_state = the_thread->current_state;
4000bb50: f0 06 20 1c ld [ %i0 + 0x1c ], %i0
4000bb54: b2 16 40 18 or %i1, %i0, %i1
if ( _States_Is_ready( previous_state ) ) {
4000bb58: 80 a6 20 00 cmp %i0, 0
4000bb5c: 12 80 00 09 bne 4000bb80 <_Thread_Set_state+0x3c>
<== NEVER TAKEN
4000bb60: f2 22 60 1c st %i1, [ %o1 + 0x1c ]
4000bb64: d4 02 60 38 ld [ %o1 + 0x38 ], %o2
4000bb68: 11 10 00 3f sethi %hi(0x4000fc00), %o0
4000bb6c: 90 12 23 10 or %o0, 0x310, %o0 ! 4000ff10 <_Scheduler_Table>
4000bb70: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
4000bb74: 9f c0 80 00 call %g2
4000bb78: c2 27 bf fc st %g1, [ %fp + -4 ]
4000bb7c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000bb80: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000bb84: 01 00 00 00 nop
_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;
}
4000bb88: 81 c7 e0 08 ret
4000bb8c: 81 e8 00 00 restore
4000bb0c <_Thread_Set_state_locked>:
States_Control _Thread_Set_state_locked(
Thread_Control *the_thread,
States_Control state
)
{
4000bb0c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
4000bb10: 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;
4000bb14: 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);
4000bb18: 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 ) ) {
4000bb1c: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4000bb20: 12 80 00 07 bne 4000bb3c <_Thread_Set_state_locked+0x30>
<== NOT EXECUTED
4000bb24: f2 22 60 1c st %i1, [ %o1 + 0x1c ]
<== NOT EXECUTED
( *scheduler->Operations.block )(
4000bb28: 11 10 00 3f sethi %hi(0x4000fc00), %o0
<== NOT EXECUTED
4000bb2c: 90 12 23 10 or %o0, 0x310, %o0 ! 4000ff10 <_Scheduler_Table>
<== NOT EXECUTED
4000bb30: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
<== NOT EXECUTED
4000bb34: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000bb38: d4 02 60 38 ld [ %o1 + 0x38 ], %o2
<== NOT EXECUTED
_Scheduler_Block( the_thread );
}
return previous_state;
}
4000bb3c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000bb40: 81 e8 00 00 restore
<== NOT EXECUTED
4000bbd0 <_Thread_Stack_Free>:
#include <rtems/config.h>
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
4000bbd0: 9d e3 bf a0 save %sp, -96, %sp
#if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
/*
* If the API provided the stack space, then don't free it.
*/
if ( !the_thread->Start.core_allocated_stack )
4000bbd4: c2 0e 20 c8 ldub [ %i0 + 0xc8 ], %g1
4000bbd8: 80 a0 60 00 cmp %g1, 0
rtems_stack_free_hook stack_free_hook =
4000bbdc: 03 10 00 3f sethi %hi(0x4000fc00), %g1
if ( !the_thread->Start.core_allocated_stack )
4000bbe0: 02 80 00 04 be 4000bbf0 <_Thread_Stack_Free+0x20>
<== NEVER TAKEN
4000bbe4: c2 00 62 58 ld [ %g1 + 0x258 ], %g1 ! 4000fe58 <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 );
4000bbe8: 9f c0 40 00 call %g1
4000bbec: d0 06 20 d0 ld [ %i0 + 0xd0 ], %o0
}
4000bbf0: 81 c7 e0 08 ret
4000bbf4: 81 e8 00 00 restore
4000bc14 <_Thread_Start>:
bool _Thread_Start(
Thread_Control *the_thread,
const Thread_Entry_information *entry,
ISR_lock_Context *lock_context
)
{
4000bc14: 9d e3 bf 98 save %sp, -104, %sp
Per_CPU_Control *cpu_self;
_Thread_State_acquire_critical( the_thread, lock_context );
if ( !_States_Is_dormant( the_thread->current_state ) ) {
4000bc18: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4000bc1c: 80 a0 60 00 cmp %g1, 0
4000bc20: 26 80 00 09 bl,a 4000bc44 <_Thread_Start+0x30>
<== ALWAYS TAKEN
4000bc24: c2 06 40 00 ld [ %i1 ], %g1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000bc28: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000bc2c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000bc30: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_State_release( the_thread, lock_context );
return false;
4000bc34: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
_User_extensions_Thread_start( the_thread );
_Thread_Dispatch_enable( cpu_self );
return true;
}
4000bc38: b0 0e 20 01 and %i0, 1, %i0
4000bc3c: 81 c7 e0 08 ret
4000bc40: 81 e8 00 00 restore
the_thread->Start.Entry = *entry;
4000bc44: c2 26 20 a0 st %g1, [ %i0 + 0xa0 ]
_Thread_Load_environment( the_thread );
4000bc48: 90 10 00 18 mov %i0, %o0
the_thread->Start.Entry = *entry;
4000bc4c: c2 06 60 04 ld [ %i1 + 4 ], %g1
4000bc50: c2 26 20 a4 st %g1, [ %i0 + 0xa4 ]
4000bc54: c2 06 60 08 ld [ %i1 + 8 ], %g1
_Thread_Load_environment( the_thread );
4000bc58: 7f ff fa 67 call 4000a5f4 <_Thread_Load_environment>
4000bc5c: c2 26 20 a8 st %g1, [ %i0 + 0xa8 ]
_Thread_Clear_state_locked( the_thread, STATES_ALL_SET );
4000bc60: 92 10 3f ff mov -1, %o1
4000bc64: 40 00 09 a8 call 4000e304 <_Thread_Clear_state_locked>
4000bc68: 90 10 00 18 mov %i0, %o0
disable_level = cpu_self->thread_dispatch_disable_level;
4000bc6c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000bc70: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000bc74: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000bc78: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000bc7c: c2 06 80 00 ld [ %i2 ], %g1
<== 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_Iterate(
4000bc88: 94 10 20 00 clr %o2 ! 0 <PROM_START>
4000bc8c: 90 10 00 18 mov %i0, %o0
4000bc90: 13 10 00 2f sethi %hi(0x4000bc00), %o1
4000bc94: 40 00 00 99 call 4000bef8 <_User_extensions_Iterate>
4000bc98: 92 12 62 18 or %o1, 0x218, %o1 ! 4000be18 <_User_extensions_Thread_start_visitor>
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000bc9c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
if ( disable_level == 1 ) {
4000bca0: 80 a0 60 01 cmp %g1, 1
4000bca4: 02 80 00 07 be 4000bcc0 <_Thread_Start+0xac>
4000bca8: 82 00 7f ff add %g1, -1, %g1
return true;
4000bcac: b0 10 20 01 mov 1, %i0
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000bcb0: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
}
4000bcb4: b0 0e 20 01 and %i0, 1, %i0
4000bcb8: 81 c7 e0 08 ret
4000bcbc: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000bcc0: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000bcc4: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
4000bcc8: 80 a0 a0 00 cmp %g2, 0
4000bccc: 12 80 00 07 bne 4000bce8 <_Thread_Start+0xd4>
4000bcd0: 92 10 00 01 mov %g1, %o1
cpu_self->thread_dispatch_disable_level = 0;
4000bcd4: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000bcd8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000bcdc: 01 00 00 00 nop
return true;
4000bce0: 10 bf ff d6 b 4000bc38 <_Thread_Start+0x24>
4000bce4: b0 10 20 01 mov 1, %i0 ! 1 <_TLS_Alignment>
_Thread_Do_dispatch( cpu_self, level );
4000bce8: c2 27 bf fc st %g1, [ %fp + -4 ]
4000bcec: 7f ff f8 e6 call 4000a084 <_Thread_Do_dispatch>
4000bcf0: 90 10 00 1d mov %i5, %o0
4000bcf4: 10 bf ff f9 b 4000bcd8 <_Thread_Start+0xc4>
4000bcf8: c2 07 bf fc ld [ %fp + -4 ], %g1
4000bbf8 <_Thread_Start_multitasking>:
#include <rtems/score/threadimpl.h>
#include <rtems/score/assert.h>
void _Thread_Start_multitasking( void )
{
4000bbf8: 9d e3 bf a0 save %sp, -96, %sp
heir = cpu_self->heir;
4000bbfc: c4 01 a0 24 ld [ %g6 + 0x24 ], %g2
cpu_self->dispatch_necessary = false;
4000bc00: c0 29 a0 1c clrb [ %g6 + 0x1c ]
_CPU_Context_Set_is_executing( &trash, true );
_CPU_Context_switch( &trash, &heir->Registers );
RTEMS_UNREACHABLE();
}
#else
_CPU_Context_Restart_self( &heir->Registers );
4000bc04: 90 00 a0 f0 add %g2, 0xf0, %o0
4000bc08: 40 00 03 89 call 4000ca2c <_CPU_Context_restore>
4000bc0c: c4 21 a0 20 st %g2, [ %g6 + 0x20 ]
4000bc10: 01 00 00 00 nop
<== NOT EXECUTED
4000bcfc <_Thread_Yield>:
#include <rtems/score/threadimpl.h>
#include <rtems/score/schedulerimpl.h>
void _Thread_Yield( Thread_Control *executing )
{
4000bcfc: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000bd00: 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 ) ) {
4000bd04: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
<== NOT EXECUTED
4000bd08: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000bd0c: 12 80 00 09 bne 4000bd30 <_Thread_Yield+0x34>
<== NOT EXECUTED
4000bd10: 11 10 00 3f sethi %hi(0x4000fc00), %o0
<== NOT EXECUTED
( *scheduler->Operations.yield )(
4000bd14: d4 06 20 38 ld [ %i0 + 0x38 ], %o2
<== NOT EXECUTED
4000bd18: 90 12 23 10 or %o0, 0x310, %o0
<== NOT EXECUTED
4000bd1c: c4 02 20 0c ld [ %o0 + 0xc ], %g2
<== NOT EXECUTED
4000bd20: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
4000bd24: 9f c0 80 00 call %g2
<== NOT EXECUTED
4000bd28: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4000bd2c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000bd30: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000bd34: 01 00 00 00 nop
<== NOT EXECUTED
_Scheduler_Yield( executing );
}
_Thread_State_release( executing, &lock_context );
}
4000bd38: 81 c7 e0 08 ret
<== NOT EXECUTED
4000bd3c: 81 e8 00 00 restore
<== NOT EXECUTED
40014e0c <_Thread_queue_Add_timeout_realtime_timespec>:
Thread_queue_Queue *queue,
Thread_Control *the_thread,
Per_CPU_Control *cpu_self,
Thread_queue_Context *queue_context
)
{
40014e0c: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
struct timespec now;
_Timecounter_Getnanotime( &now );
40014e10: 7f ff f0 f0 call 400111d0 <_Timecounter_Getnanotime>
<== NOT EXECUTED
40014e14: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
_Thread_queue_Add_timeout_timespec(
40014e18: d2 06 e0 0c ld [ %i3 + 0xc ], %o1
<== NOT EXECUTED
40014e1c: 98 07 bf f8 add %fp, -8, %o4
<== NOT EXECUTED
40014e20: 96 07 bf f0 add %fp, -16, %o3
<== NOT EXECUTED
40014e24: 94 06 a0 40 add %i2, 0x40, %o2
<== NOT EXECUTED
40014e28: 7f ff ff 99 call 40014c8c <_Thread_queue_Add_timeout_timespec.isra.5>
<== NOT EXECUTED
40014e2c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
cpu_self,
queue_context,
&cpu_self->Watchdog.Header[ PER_CPU_WATCHDOG_REALTIME ],
&now
);
}
40014e30: 81 c7 e0 08 ret
<== NOT EXECUTED
40014e34: 81 e8 00 00 restore
<== NOT EXECUTED
40014d78 <_Thread_queue_Add_timeout_ticks>:
{
40014d78: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
ticks = queue_context->Timeout.ticks;
40014d7c: c4 06 e0 0c ld [ %i3 + 0xc ], %g2
<== NOT EXECUTED
if ( ticks != WATCHDOG_NO_TIMEOUT ) {
40014d80: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40014d84: 12 80 00 04 bne 40014d94 <_Thread_queue_Add_timeout_ticks+0x1c>
<== NOT EXECUTED
40014d88: 01 00 00 00 nop
<== NOT EXECUTED
}
40014d8c: 81 c7 e0 08 ret
<== NOT EXECUTED
40014d90: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40014d94: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
40014d98: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
the_thread->Timer.Watchdog.routine = _Thread_Timeout;
40014d9c: 07 10 00 56 sethi %hi(0x40015800), %g3
<== NOT EXECUTED
expire = ticks + cpu->Watchdog.ticks;
40014da0: d4 1e a0 30 ldd [ %i2 + 0x30 ], %o2
<== NOT EXECUTED
&cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ];
40014da4: 90 06 a0 38 add %i2, 0x38, %o0
<== NOT EXECUTED
the_thread->Timer.Watchdog.routine = _Thread_Timeout;
40014da8: 86 10 e0 54 or %g3, 0x54, %g3
<== NOT EXECUTED
the_thread->Timer.header =
40014dac: d0 26 60 60 st %o0, [ %i1 + 0x60 ]
<== NOT EXECUTED
_Watchdog_Insert(header, the_watchdog, expire);
40014db0: b6 82 c0 02 addcc %o3, %g2, %i3
<== NOT EXECUTED
the_thread->Timer.Watchdog.routine = _Thread_Timeout;
40014db4: c6 26 60 78 st %g3, [ %i1 + 0x78 ]
<== NOT EXECUTED
40014db8: b4 42 a0 00 addx %o2, 0, %i2
<== NOT EXECUTED
40014dbc: 92 06 60 68 add %i1, 0x68, %o1
<== NOT EXECUTED
40014dc0: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
40014dc4: 40 00 03 e4 call 40015d54 <_Watchdog_Insert>
<== NOT EXECUTED
40014dc8: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40014dcc: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40014dd0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40014dd4: 01 00 00 00 nop
<== NOT EXECUTED
40014dd8: 81 c7 e0 08 ret
<== NOT EXECUTED
40014ddc: 81 e8 00 00 restore
<== NOT EXECUTED
4000a7b4 <_Thread_queue_Deadlock_fatal>:
{
4000a7b4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_Internal_error( INTERNAL_ERROR_THREAD_QUEUE_DEADLOCK );
4000a7b8: 7f ff f2 cd call 400072ec <_Internal_error>
<== NOT EXECUTED
4000a7bc: 90 10 20 1c mov 0x1c, %o0
<== NOT EXECUTED
4000a7c0: 01 00 00 00 nop
<== NOT EXECUTED
40013cdc <_Thread_queue_Deadlock_status>:
the_thread->Wait.return_code = STATUS_DEADLOCK;
40013cdc: 03 00 00 0b sethi %hi(0x2c00), %g1
<== NOT EXECUTED
40013ce0: 82 10 61 0e or %g1, 0x10e, %g1 ! 2d0e <_Configuration_Interrupt_stack_size+0x1d0e>
<== NOT EXECUTED
}
40013ce4: 81 c3 e0 08 retl
<== NOT EXECUTED
40013ce8: c2 22 20 4c st %g1, [ %o0 + 0x4c ]
<== NOT EXECUTED
4000a7c4 <_Thread_queue_Enqueue>:
{
4000a7c4: 9d e3 bf 98 save %sp, -104, %sp
the_thread->Wait.queue = queue;
4000a7c8: f0 26 a0 54 st %i0, [ %i2 + 0x54 ]
4000a7cc: 10 80 00 08 b 4000a7ec <_Thread_queue_Enqueue+0x28>
4000a7d0: 82 10 00 18 mov %i0, %g1
if ( owner == the_thread ) {
4000a7d4: 22 80 00 44 be,a 4000a8e4 <_Thread_queue_Enqueue+0x120>
<== NEVER TAKEN
4000a7d8: c0 26 a0 54 clr [ %i2 + 0x54 ]
<== NOT EXECUTED
queue = owner->Wait.queue;
4000a7dc: c2 00 60 54 ld [ %g1 + 0x54 ], %g1
} while ( queue != NULL );
4000a7e0: 80 a0 60 00 cmp %g1, 0
4000a7e4: 22 80 00 07 be,a 4000a800 <_Thread_queue_Enqueue+0x3c>
<== ALWAYS TAKEN
4000a7e8: c0 26 e0 14 clr [ %i3 + 0x14 ]
owner = queue->owner;
4000a7ec: c2 00 60 04 ld [ %g1 + 4 ], %g1
if ( owner == NULL ) {
4000a7f0: 80 a0 60 00 cmp %g1, 0
4000a7f4: 12 bf ff f8 bne 4000a7d4 <_Thread_queue_Enqueue+0x10>
4000a7f8: 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;
4000a7fc: c0 26 e0 14 clr [ %i3 + 0x14 ]
( *operations->enqueue )( queue, the_thread, queue_context );
4000a800: 94 10 00 1b mov %i3, %o2
the_thread->Wait.operations = operations;
4000a804: f2 26 a0 58 st %i1, [ %i2 + 0x58 ]
4000a808: 92 10 00 1a mov %i2, %o1
4000a80c: c2 06 60 04 ld [ %i1 + 4 ], %g1
4000a810: 9f c0 40 00 call %g1
4000a814: 90 10 00 18 mov %i0, %o0
the_thread->Wait.flags = flags;
4000a818: 84 10 24 01 mov 0x401, %g2
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000a81c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
the_thread->Wait.return_code = STATUS_SUCCESSFUL;
4000a820: c0 26 a0 4c clr [ %i2 + 0x4c ]
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000a824: 82 00 60 01 inc %g1
<== NOT EXECUTED
4000a828: c4 26 a0 50 st %g2, [ %i2 + 0x50 ]
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000a82c: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000a830: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a834: c2 06 c0 00 ld [ %i3 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a838: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000a83c: 01 00 00 00 nop
( *queue_context->enqueue_callout )(
4000a840: c2 06 e0 08 ld [ %i3 + 8 ], %g1
4000a844: 96 10 00 1b mov %i3, %o3
4000a848: 94 10 00 06 mov %g6, %o2
4000a84c: 92 10 00 1a mov %i2, %o1
4000a850: 9f c0 40 00 call %g1
4000a854: 90 10 00 18 mov %i0, %o0
_Thread_Set_state( the_thread, queue_context->thread_state );
4000a858: d2 06 e0 04 ld [ %i3 + 4 ], %o1
4000a85c: 40 00 04 ba call 4000bb44 <_Thread_Set_state>
4000a860: 90 10 00 1a mov %i2, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000a864: 91 d0 20 09 ta 9
<== NOT EXECUTED
bool success = ( the_thread->Wait.flags == expected_flags );
4000a868: c4 06 a0 50 ld [ %i2 + 0x50 ], %g2
if ( success ) {
4000a86c: 80 a0 a4 01 cmp %g2, 0x401
4000a870: 02 80 00 28 be 4000a910 <_Thread_queue_Enqueue+0x14c>
<== ALWAYS TAKEN
4000a874: 86 10 24 02 mov 0x402, %g3
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a878: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000a87c: 01 00 00 00 nop
<== NOT EXECUTED
if ( !success ) {
4000a880: 80 a0 a4 01 cmp %g2, 0x401
<== NOT EXECUTED
4000a884: 12 80 00 07 bne 4000a8a0 <_Thread_queue_Enqueue+0xdc>
<== NOT EXECUTED
4000a888: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( queue_context );
4000a88c: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
4000a890: 40 00 0e 7c call 4000e280 <_Thread_Priority_update>
4000a894: b0 10 00 1d mov %i5, %i0
_Thread_Dispatch_direct( cpu_self );
4000a898: 7f ff fe 43 call 4000a1a4 <_Thread_Dispatch_direct>
4000a89c: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000a8a0: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000a8a4: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
4000a8a8: d0 06 a0 60 ld [ %i2 + 0x60 ], %o0
<== NOT EXECUTED
4000a8ac: 40 00 06 12 call 4000c0f4 <_Watchdog_Remove>
<== NOT EXECUTED
4000a8b0: 92 06 a0 68 add %i2, 0x68, %o1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a8b4: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a8b8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000a8bc: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4000a8c0: 13 0c 00 57 sethi %hi(0x30015c00), %o1
<== NOT EXECUTED
4000a8c4: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
4000a8c8: 40 00 0e 9b call 4000e334 <_Thread_Clear_state>
<== NOT EXECUTED
4000a8cc: 92 12 63 ff or %o1, 0x3ff, %o1
<== NOT EXECUTED
_Thread_Priority_update( queue_context );
4000a8d0: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
4000a8d4: 40 00 0e 6b call 4000e280 <_Thread_Priority_update>
<== NOT EXECUTED
4000a8d8: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
_Thread_Dispatch_direct( cpu_self );
4000a8dc: 7f ff fe 32 call 4000a1a4 <_Thread_Dispatch_direct>
<== NOT EXECUTED
4000a8e0: 81 e8 00 00 restore
<== NOT EXECUTED
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4000a8e4: 03 10 00 42 sethi %hi(0x40010800), %g1
<== NOT EXECUTED
4000a8e8: 82 10 60 50 or %g1, 0x50, %g1 ! 40010850 <_Thread_queue_Operations_default>
<== NOT EXECUTED
4000a8ec: c2 26 a0 58 st %g1, [ %i2 + 0x58 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a8f0: c2 06 c0 00 ld [ %i3 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a8f4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000a8f8: 01 00 00 00 nop
<== NOT EXECUTED
( *queue_context->deadlock_callout )( the_thread );
4000a8fc: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1
<== NOT EXECUTED
4000a900: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000a904: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
}
4000a908: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a90c: 81 e8 00 00 restore
<== NOT EXECUTED
the_thread->Wait.flags = desired_flags;
4000a910: c6 26 a0 50 st %g3, [ %i2 + 0x50 ]
<== NOT EXECUTED
4000a914: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000a918: 01 00 00 00 nop
if ( !success ) {
4000a91c: 80 a0 a4 01 cmp %g2, 0x401
4000a920: 22 bf ff dc be,a 4000a890 <_Thread_queue_Enqueue+0xcc>
<== ALWAYS TAKEN
4000a924: 90 10 00 1b mov %i3, %o0
4000a928: 30 bf ff de b,a 4000a8a0 <_Thread_queue_Enqueue+0xdc>
<== NOT EXECUTED
4000a99c <_Thread_queue_Extract>:
&queue_context->Lock_context.Lock_context
);
}
void _Thread_queue_Extract( Thread_Control *the_thread )
{
4000a99c: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
4000a9a0: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000a9a4: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
4000a9a8: 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;
4000a9ac: d0 06 20 54 ld [ %i0 + 0x54 ], %o0
if ( queue != NULL ) {
4000a9b0: 80 a2 20 00 cmp %o0, 0
4000a9b4: 02 80 00 1c be 4000aa24 <_Thread_queue_Extract+0x88>
<== ALWAYS TAKEN
4000a9b8: 92 10 00 18 mov %i0, %o1
( *operations->extract )( queue, the_thread, queue_context );
4000a9bc: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
<== NOT EXECUTED
4000a9c0: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
4000a9c4: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000a9c8: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
if ( success ) {
4000a9cc: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
<== NOT EXECUTED
4000a9d0: 80 a0 64 01 cmp %g1, 0x401
<== NOT EXECUTED
the_thread->Wait.queue = NULL;
4000a9d4: c0 26 20 54 clr [ %i0 + 0x54 ]
<== NOT EXECUTED
the_thread->Wait.flags = desired_flags;
4000a9d8: 82 10 24 04 mov 0x404, %g1
<== NOT EXECUTED
if ( success ) {
4000a9dc: 02 80 00 0a be 4000aa04 <_Thread_queue_Extract+0x68>
<== NOT EXECUTED
4000a9e0: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
<== NOT EXECUTED
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4000a9e4: 03 10 00 42 sethi %hi(0x40010800), %g1
<== NOT EXECUTED
4000a9e8: 82 10 60 50 or %g1, 0x50, %g1 ! 40010850 <_Thread_queue_Operations_default>
<== NOT EXECUTED
4000a9ec: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
<== NOT EXECUTED
4000a9f0: 92 07 bf dc add %fp, -36, %o1
<== NOT EXECUTED
4000a9f4: 7f ff ff 44 call 4000a704 <_Thread_queue_Unblock_critical.part.33>
<== NOT EXECUTED
4000a9f8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
&queue_context.Lock_context.Lock_context
);
} else {
_Thread_Wait_release( the_thread, &queue_context );
}
}
4000a9fc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000aa00: 81 e8 00 00 restore
<== NOT EXECUTED
4000aa04: 03 10 00 42 sethi %hi(0x40010800), %g1
<== NOT EXECUTED
4000aa08: 82 10 60 50 or %g1, 0x50, %g1 ! 40010850 <_Thread_queue_Operations_default>
<== NOT EXECUTED
4000aa0c: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000aa10: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000aa14: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000aa18: 01 00 00 00 nop
<== NOT EXECUTED
4000aa1c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000aa20: 81 e8 00 00 restore
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000aa24: c2 07 bf dc ld [ %fp + -36 ], %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
4000aa30: 81 c7 e0 08 ret
4000aa34: 81 e8 00 00 restore
40013ed4 <_Thread_queue_Extract_critical>:
Thread_queue_Queue *queue,
const Thread_queue_Operations *operations,
Thread_Control *the_thread,
Thread_queue_Context *queue_context
)
{
40013ed4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
( *operations->extract )( queue, the_thread, queue_context );
40013ed8: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
40013edc: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
40013ee0: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
40013ee4: 9f c0 40 00 call %g1
<== NOT EXECUTED
40013ee8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( success ) {
40013eec: c2 06 a0 50 ld [ %i2 + 0x50 ], %g1
<== NOT EXECUTED
40013ef0: 80 a0 64 01 cmp %g1, 0x401
<== NOT EXECUTED
the_thread->Wait.queue = NULL;
40013ef4: c0 26 a0 54 clr [ %i2 + 0x54 ]
<== NOT EXECUTED
the_thread->Wait.flags = desired_flags;
40013ef8: 82 10 24 04 mov 0x404, %g1
<== NOT EXECUTED
if ( success ) {
40013efc: 02 80 00 08 be 40013f1c <_Thread_queue_Extract_critical+0x48>
<== NOT EXECUTED
40013f00: c2 26 a0 50 st %g1, [ %i2 + 0x50 ]
<== NOT EXECUTED
the_thread->Wait.operations = &_Thread_queue_Operations_default;
40013f04: 03 10 00 bb sethi %hi(0x4002ec00), %g1
<== NOT EXECUTED
40013f08: 82 10 63 98 or %g1, 0x398, %g1 ! 4002ef98 <_Thread_queue_Operations_default>
<== NOT EXECUTED
40013f0c: c2 26 a0 58 st %g1, [ %i2 + 0x58 ]
<== NOT EXECUTED
40013f10: b2 10 00 1b mov %i3, %i1
<== NOT EXECUTED
40013f14: 7f ff ff 46 call 40013c2c <_Thread_queue_Unblock_critical.part.33>
<== NOT EXECUTED
40013f18: 91 e8 00 1a restore %g0, %i2, %o0
<== NOT EXECUTED
40013f1c: 03 10 00 bb sethi %hi(0x4002ec00), %g1
<== NOT EXECUTED
40013f20: 82 10 63 98 or %g1, 0x398, %g1 ! 4002ef98 <_Thread_queue_Operations_default>
<== NOT EXECUTED
40013f24: c2 26 a0 58 st %g1, [ %i2 + 0x58 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40013f28: c2 06 c0 00 ld [ %i3 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40013f2c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40013f30: 01 00 00 00 nop
<== NOT EXECUTED
unblock,
queue,
the_thread,
&queue_context->Lock_context.Lock_context
);
}
40013f34: 81 c7 e0 08 ret
<== NOT EXECUTED
40013f38: 81 e8 00 00 restore
<== NOT EXECUTED
4000a92c <_Thread_queue_Extract_locked>:
{
4000a92c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
( *operations->extract )( queue, the_thread, queue_context );
4000a930: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
4000a934: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
4000a938: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4000a93c: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000a940: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( success ) {
4000a944: c2 06 a0 50 ld [ %i2 + 0x50 ], %g1
<== NOT EXECUTED
4000a948: 80 a0 64 01 cmp %g1, 0x401
<== NOT EXECUTED
4000a94c: 02 80 00 0b be 4000a978 <_Thread_queue_Extract_locked+0x4c>
<== NOT EXECUTED
4000a950: 82 10 24 04 mov 0x404, %g1
<== NOT EXECUTED
unblock = true;
4000a954: b0 10 20 01 mov 1, %i0
<== NOT EXECUTED
the_thread->Wait.flags = flags;
4000a958: c2 26 a0 50 st %g1, [ %i2 + 0x50 ]
<== NOT EXECUTED
return _Thread_queue_Make_ready_again( the_thread );
4000a95c: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
the_thread->Wait.queue = NULL;
4000a960: c0 26 a0 54 clr [ %i2 + 0x54 ]
<== NOT EXECUTED
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4000a964: 03 10 00 42 sethi %hi(0x40010800), %g1
<== NOT EXECUTED
4000a968: 82 10 60 50 or %g1, 0x50, %g1 ! 40010850 <_Thread_queue_Operations_default>
<== NOT EXECUTED
4000a96c: c2 26 a0 58 st %g1, [ %i2 + 0x58 ]
<== NOT EXECUTED
}
4000a970: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a974: 81 e8 00 00 restore
<== NOT EXECUTED
unblock = false;
4000a978: b0 10 20 00 clr %i0
<== NOT EXECUTED
the_thread->Wait.flags = desired_flags;
4000a97c: c2 26 a0 50 st %g1, [ %i2 + 0x50 ]
<== NOT EXECUTED
return _Thread_queue_Make_ready_again( the_thread );
4000a980: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
the_thread->Wait.queue = NULL;
4000a984: c0 26 a0 54 clr [ %i2 + 0x54 ]
<== NOT EXECUTED
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4000a988: 03 10 00 42 sethi %hi(0x40010800), %g1
<== NOT EXECUTED
4000a98c: 82 10 60 50 or %g1, 0x50, %g1 ! 40010850 <_Thread_queue_Operations_default>
<== NOT EXECUTED
4000a990: c2 26 a0 58 st %g1, [ %i2 + 0x58 ]
<== NOT EXECUTED
}
4000a994: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a998: 81 e8 00 00 restore
<== NOT EXECUTED
4000e398 <_Thread_queue_Flush_critical>:
Thread_queue_Queue *queue,
const Thread_queue_Operations *operations,
Thread_queue_Flush_filter filter,
Thread_queue_Context *queue_context
)
{
4000e398: 9d e3 bf 88 save %sp, -120, %sp
head->next = tail;
4000e39c: a0 07 bf f8 add %fp, -8, %l0
tail->previous = head;
4000e3a0: 82 07 bf f4 add %fp, -12, %g1
head->previous = NULL;
4000e3a4: c0 27 bf f8 clr [ %fp + -8 ]
4000e3a8: b8 10 00 18 mov %i0, %i4
head->next = tail;
4000e3ac: e0 27 bf f4 st %l0, [ %fp + -12 ]
tail->previous = head;
4000e3b0: c2 27 bf fc st %g1, [ %fp + -4 ]
while ( true ) {
Thread_queue_Heads *heads;
Thread_Control *first;
bool do_unblock;
heads = queue->heads;
4000e3b4: d0 06 00 00 ld [ %i0 ], %o0
owner = queue->owner;
4000e3b8: e2 06 20 04 ld [ %i0 + 4 ], %l1
if ( heads == NULL ) {
4000e3bc: 80 a2 20 00 cmp %o0, 0
4000e3c0: 12 80 00 16 bne 4000e418 <_Thread_queue_Flush_critical+0x80>
<== NEVER TAKEN
4000e3c4: b0 10 20 00 clr %i0
4000e3c8: 30 80 00 59 b,a 4000e52c <_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(
4000e3cc: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
4000e3d0: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
4000e3d4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000e3d8: 7f ff f1 55 call 4000a92c <_Thread_queue_Extract_locked>
<== NOT EXECUTED
4000e3dc: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
queue,
operations,
first,
queue_context
);
if ( do_unblock ) {
4000e3e0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e3e4: 22 80 00 0a be,a 4000e40c <_Thread_queue_Flush_critical+0x74>
<== NOT EXECUTED
4000e3e8: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
4000e3ec: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
<== NOT EXECUTED
old_last = tail->previous;
4000e3f0: c4 07 bf fc ld [ %fp + -4 ], %g2
<== NOT EXECUTED
the_node->next = tail;
4000e3f4: e0 20 60 08 st %l0, [ %g1 + 8 ]
<== NOT EXECUTED
Scheduler_Node *scheduler_node;
scheduler_node = _Thread_Scheduler_get_home_node( first );
_Chain_Append_unprotected(
4000e3f8: 86 00 60 08 add %g1, 8, %g3
<== NOT EXECUTED
tail->previous = the_node;
4000e3fc: c6 27 bf fc st %g3, [ %fp + -4 ]
<== NOT EXECUTED
old_last->next = the_node;
4000e400: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
the_node->previous = old_last;
4000e404: c4 20 60 0c st %g2, [ %g1 + 0xc ]
<== NOT EXECUTED
heads = queue->heads;
4000e408: d0 07 00 00 ld [ %i4 ], %o0
<== NOT EXECUTED
if ( heads == NULL ) {
4000e40c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e410: 02 80 00 0b be 4000e43c <_Thread_queue_Flush_critical+0xa4>
<== NOT EXECUTED
4000e414: b0 06 20 01 inc %i0
<== NOT EXECUTED
first = ( *operations->first )( heads );
4000e418: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
<== NOT EXECUTED
4000e41c: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e420: 01 00 00 00 nop
<== NOT EXECUTED
first = ( *filter )( first, queue, queue_context );
4000e424: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
4000e428: 9f c6 80 00 call %i2
<== NOT EXECUTED
4000e42c: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
if ( first == NULL ) {
4000e430: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4000e434: 32 bf ff e6 bne,a 4000e3cc <_Thread_queue_Flush_critical+0x34>
<== NOT EXECUTED
4000e438: c0 26 e0 14 clr [ %i3 + 0x14 ]
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000e43c: c4 07 bf f4 ld [ %fp + -12 ], %g2
<== NOT EXECUTED
}
node = _Chain_First( &unblock );
tail = _Chain_Tail( &unblock );
if ( node != tail ) {
4000e440: 80 a0 80 10 cmp %g2, %l0
<== NOT EXECUTED
4000e444: 02 80 00 3a be 4000e52c <_Thread_queue_Flush_critical+0x194>
<== NOT EXECUTED
4000e448: 01 00 00 00 nop
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000e44c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000e450: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000e454: b4 10 00 06 mov %g6, %i2
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000e458: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e45c: c2 06 c0 00 ld [ %i3 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e460: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e464: 01 00 00 00 nop
<== NOT EXECUTED
4000e468: 37 0c 00 57 sethi %hi(0x30015c00), %i3
<== NOT EXECUTED
4000e46c: b6 16 e3 ff or %i3, 0x3ff, %i3 ! 30015fff <RAM_SIZE+0x2fc15fff>
<== NOT EXECUTED
4000e470: f8 00 80 00 ld [ %g2 ], %i4
<== NOT EXECUTED
4000e474: fa 00 bf f8 ld [ %g2 + -8 ], %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e478: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000e47c: c2 27 bf ec st %g1, [ %fp + -20 ]
<== NOT EXECUTED
4000e480: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
<== NOT EXECUTED
4000e484: 7f ff f7 1c call 4000c0f4 <_Watchdog_Remove>
<== NOT EXECUTED
4000e488: 92 07 60 68 add %i5, 0x68, %o1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e48c: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e490: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e494: 01 00 00 00 nop
<== NOT EXECUTED
4000e498: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4000e49c: 7f ff ff a6 call 4000e334 <_Thread_Clear_state>
<== NOT EXECUTED
4000e4a0: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
scheduler_node = SCHEDULER_NODE_OF_WAIT_PRIORITY_NODE( node );
the_thread = _Scheduler_Node_get_owner( scheduler_node );
_Thread_Remove_timer_and_unblock( the_thread, queue );
node = next;
} while ( node != tail );
4000e4a4: 80 a7 00 10 cmp %i4, %l0
<== NOT EXECUTED
4000e4a8: 12 bf ff f2 bne 4000e470 <_Thread_queue_Flush_critical+0xd8>
<== NOT EXECUTED
4000e4ac: 84 10 00 1c mov %i4, %g2
<== NOT EXECUTED
if ( owner != NULL ) {
4000e4b0: 80 a4 60 00 cmp %l1, 0
<== NOT EXECUTED
4000e4b4: 02 80 00 0d be 4000e4e8 <_Thread_queue_Flush_critical+0x150>
<== NOT EXECUTED
4000e4b8: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e4bc: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000e4c0: c2 27 bf ec st %g1, [ %fp + -20 ]
<== NOT EXECUTED
( *scheduler->Operations.update_priority )(
4000e4c4: 11 10 00 3f sethi %hi(0x4000fc00), %o0
<== NOT EXECUTED
4000e4c8: d4 04 60 38 ld [ %l1 + 0x38 ], %o2
<== NOT EXECUTED
4000e4cc: 90 12 23 10 or %o0, 0x310, %o0
<== NOT EXECUTED
4000e4d0: c4 02 20 18 ld [ %o0 + 0x18 ], %g2
<== NOT EXECUTED
4000e4d4: 9f c0 80 00 call %g2
<== NOT EXECUTED
4000e4d8: 92 10 00 11 mov %l1, %o1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e4dc: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e4e0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e4e4: 01 00 00 00 nop
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000e4e8: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000e4ec: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000e4f0: 02 80 00 05 be 4000e504 <_Thread_queue_Flush_critical+0x16c>
<== NOT EXECUTED
4000e4f4: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000e4f8: c2 26 a0 18 st %g1, [ %i2 + 0x18 ]
<== NOT EXECUTED
4000e4fc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e500: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e504: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000e508: c4 0e a0 1c ldub [ %i2 + 0x1c ], %g2
<== NOT EXECUTED
4000e50c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000e510: 12 80 00 0c bne 4000e540 <_Thread_queue_Flush_critical+0x1a8>
<== NOT EXECUTED
4000e514: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4000e518: c0 26 a0 18 clr [ %i2 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e51c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e520: 01 00 00 00 nop
<== NOT EXECUTED
4000e524: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e528: 81 e8 00 00 restore
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e52c: c2 06 c0 00 ld [ %i3 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e530: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e534: 01 00 00 00 nop
} else {
_Thread_queue_Queue_release( queue, &queue_context->Lock_context.Lock_context );
}
return flushed;
}
4000e538: 81 c7 e0 08 ret
4000e53c: 81 e8 00 00 restore
_Thread_Do_dispatch( cpu_self, level );
4000e540: c2 27 bf ec st %g1, [ %fp + -20 ]
<== NOT EXECUTED
4000e544: 7f ff ee d0 call 4000a084 <_Thread_Do_dispatch>
<== NOT EXECUTED
4000e548: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
4000e54c: 10 bf ff f4 b 4000e51c <_Thread_queue_Flush_critical+0x184>
<== NOT EXECUTED
4000e550: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
40014100 <_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;
40014100: 03 00 00 05 sethi %hi(0x1400), %g1
<== NOT EXECUTED
40014104: 82 10 62 07 or %g1, 0x207, %g1 ! 1607 <_Configuration_Interrupt_stack_size+0x607>
<== NOT EXECUTED
(void) queue;
(void) queue_context;
return the_thread;
}
40014108: 81 c3 e0 08 retl
<== NOT EXECUTED
4001410c: c2 22 20 4c st %g1, [ %o0 + 0x4c ]
<== NOT EXECUTED
400142cc <_Thread_queue_Object_initialize>:
queue->name = name;
400142cc: 03 10 00 bb sethi %hi(0x4002ec00), %g1
<== NOT EXECUTED
queue->heads = NULL;
400142d0: c0 22 00 00 clr [ %o0 ]
<== NOT EXECUTED
queue->name = name;
400142d4: 82 10 63 58 or %g1, 0x358, %g1
<== NOT EXECUTED
queue->owner = NULL;
400142d8: 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 );
}
400142dc: 81 c3 e0 08 retl
<== NOT EXECUTED
400142e0: c2 22 20 08 st %g1, [ %o0 + 8 ]
<== NOT EXECUTED
4002ef58 <_Thread_queue_Object_name>:
4002ef58: 00 00 00 00 ....
4002ef84 <_Thread_queue_Operations_FIFO>:
4002ef84: 40 01 43 50 40 01 44 30 40 01 46 14 40 01 45 7c @.CP@.D0@.F.@.E|
4002ef94: 40 01 44 4c @.DL
40010850 <_Thread_queue_Operations_default>:
40010850: 40 00 ab 60 00 00 00 00 40 00 ab 68 00 00 00 00 @..`....@..h....
...
40010868: 0a 0a 2a 2a 2a 20 42 45 47 49 4e 20 4f 46 20 54 ..*** BEGIN OF T
40010878: 45 53 54 20 25 73 20 2a 2a 2a 0a 2a 2a 2a 20 54 EST %s ***.*** T
40010888: 45 53 54 20 56 45 52 53 49 4f 4e 3a 20 25 73 0a EST VERSION: %s.
40010898: 2a 2a 2a 20 54 45 53 54 20 53 54 41 54 45 3a 20 *** TEST STATE:
400108a8: 25 73 0a 2a 2a 2a 20 54 45 53 54 20 42 55 49 4c %s.*** TEST BUIL
400108b8: 44 3a 20 52 54 45 4d 53 5f 4e 45 54 57 4f 52 4b D: RTEMS_NETWORK
400108c8: 49 4e 47 20 52 54 45 4d 53 5f 50 4f 53 49 58 5f ING RTEMS_POSIX_
400108d8: 41 50 49 0a 2a 2a 2a 20 54 45 53 54 20 54 4f 4f API.*** TEST TOO
400108e8: 4c 53 3a 20 37 2e 33 2e 30 20 32 30 31 38 30 31 LS: 7.3.0 201801
400108f8: 32 35 20 28 52 54 45 4d 53 20 35 2c 20 52 53 42 25 (RTEMS 5, RSB
40010908: 20 32 35 66 34 64 62 30 39 63 38 35 61 35 32 66 25f4db09c85a52f
40010918: 62 31 36 34 30 61 32 39 66 39 62 64 63 32 64 65 b1640a29f9bdc2de
40010928: 38 63 32 37 36 38 39 38 38 2c 20 4e 65 77 6c 69 8c2768988, Newli
40010938: 62 20 33 2e 30 2e 30 29 0a 00 00 00 00 00 00 00 b 3.0.0)........
40010948: 0a 2a 2a 2a 20 45 4e 44 20 4f 46 20 54 45 53 54 .*** END OF TEST
40010958: 20 25 73 20 2a 2a 2a 0a 0a 00 00 00 00 00 00 00 %s ***.........
40010968: 45 58 50 45 43 54 45 44 2d 50 41 53 53 00 00 00 EXPECTED-PASS...
40010978: 45 58 50 45 43 54 45 44 2d 46 41 49 4c 00 00 00 EXPECTED-FAIL...
40010988: 55 53 45 52 5f 49 4e 50 55 54 00 00 00 00 00 00 USER_INPUT......
40010998: 49 4e 44 45 54 45 52 4d 49 4e 41 54 45 00 00 00 INDETERMINATE...
400109a8: 42 45 4e 43 48 4d 41 52 4b 00 00 00 BENCHMARK...
4001083c <_Thread_queue_Operations_priority>:
4001083c: 40 00 af 2c 40 00 ac 20 40 00 ad 1c 40 00 ac c0 @..,@.. @...@...
4001084c: 40 00 ac 58 @..X
40010828 <_Thread_queue_Operations_priority_inherit>:
40010828: 40 00 b0 6c 40 00 ac 3c 40 00 ad 64 40 00 b1 78 @..l@..<@..d@..x
40010838: 40 00 ac 58 @..X
400142e4 <_Thread_queue_Queue_get_name_and_id>:
const Thread_queue_Queue *queue,
char *buffer,
size_t buffer_size,
Objects_Id *id
)
{
400142e4: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
const char *name;
name = queue->name;
400142e8: c4 06 20 08 ld [ %i0 + 8 ], %g2
<== NOT EXECUTED
if ( name == _Thread_queue_Object_name ) {
400142ec: 03 10 00 bb sethi %hi(0x4002ec00), %g1
<== NOT EXECUTED
400142f0: 82 10 63 58 or %g1, 0x358, %g1 ! 4002ef58 <_Thread_queue_Object_name>
<== NOT EXECUTED
400142f4: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
400142f8: 02 80 00 0c be 40014328 <_Thread_queue_Queue_get_name_and_id+0x44>
<== NOT EXECUTED
400142fc: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
false,
buffer,
buffer_size
);
} else {
if ( name == NULL ) {
40014300: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40014304: 02 80 00 05 be 40014318 <_Thread_queue_Queue_get_name_and_id+0x34>
<== NOT EXECUTED
40014308: c0 26 c0 00 clr [ %i3 ]
<== NOT EXECUTED
name = _Thread_queue_Object_name;
}
*id = 0;
return strlcpy( buffer, name, buffer_size );
4001430c: b2 10 00 02 mov %g2, %i1
<== NOT EXECUTED
40014310: 40 00 2e 8a call 4001fd38 <strlcpy>
<== NOT EXECUTED
40014314: 91 e8 00 0a restore %g0, %o2, %o0
<== NOT EXECUTED
name = _Thread_queue_Object_name;
40014318: 84 10 00 01 mov %g1, %g2
<== NOT EXECUTED
return strlcpy( buffer, name, buffer_size );
4001431c: b0 10 00 0a mov %o2, %i0
<== NOT EXECUTED
40014320: 40 00 2e 86 call 4001fd38 <strlcpy>
<== NOT EXECUTED
40014324: 93 e8 00 02 restore %g0, %g2, %o1
<== NOT EXECUTED
*id = queue_object->Object.id;
40014328: c4 06 3f f8 ld [ %i0 + -8 ], %g2
<== NOT EXECUTED
4001432c: c4 26 c0 00 st %g2, [ %i3 ]
<== NOT EXECUTED
return _Objects_Name_to_string(
40014330: 96 10 00 1a mov %i2, %o3
<== NOT EXECUTED
40014334: c2 06 3f fc ld [ %i0 + -4 ], %g1
<== NOT EXECUTED
40014338: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
4001433c: 92 10 20 00 clr %o1
<== NOT EXECUTED
40014340: 40 00 19 58 call 4001a8a0 <_Objects_Name_to_string>
<== NOT EXECUTED
40014344: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
}
}
40014348: 81 c7 e0 08 ret
<== NOT EXECUTED
4001434c: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000aa38 <_Thread_queue_Surrender>:
Thread_queue_Heads *heads,
Thread_Control *previous_owner,
Thread_queue_Context *queue_context,
const Thread_queue_Operations *operations
)
{
4000aa38: 9d e3 bf 98 save %sp, -104, %sp
4000aa3c: c0 26 e0 14 clr [ %i3 + 0x14 ]
Per_CPU_Control *cpu_self;
_Assert( heads != NULL );
_Thread_queue_Context_clear_priority_updates( queue_context );
new_owner = ( *operations->surrender )(
4000aa40: 96 10 00 1b mov %i3, %o3
4000aa44: c2 07 20 0c ld [ %i4 + 0xc ], %g1
4000aa48: 94 10 00 1a mov %i2, %o2
4000aa4c: 92 10 00 19 mov %i1, %o1
4000aa50: 9f c0 40 00 call %g1
4000aa54: 90 10 00 18 mov %i0, %o0
queue,
heads,
previous_owner,
queue_context
);
queue->owner = new_owner;
4000aa58: d0 26 20 04 st %o0, [ %i0 + 4 ]
if ( success ) {
4000aa5c: c2 02 20 50 ld [ %o0 + 0x50 ], %g1
4000aa60: 80 a0 64 01 cmp %g1, 0x401
4000aa64: 02 80 00 1c be 4000aad4 <_Thread_queue_Surrender+0x9c>
<== NEVER TAKEN
4000aa68: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
the_thread->Wait.flags = flags;
4000aa6c: 82 10 24 04 mov 0x404, %g1
<== NOT EXECUTED
4000aa70: c2 22 20 50 st %g1, [ %o0 + 0x50 ]
<== NOT EXECUTED
unblock = true;
4000aa74: b4 10 20 01 mov 1, %i2
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000aa78: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
the_thread->Wait.queue = NULL;
4000aa7c: c0 27 60 54 clr [ %i5 + 0x54 ]
<== NOT EXECUTED
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4000aa80: 05 10 00 42 sethi %hi(0x40010800), %g2
<== NOT EXECUTED
4000aa84: 84 10 a0 50 or %g2, 0x50, %g2 ! 40010850 <_Thread_queue_Operations_default>
<== NOT EXECUTED
4000aa88: c4 27 60 58 st %g2, [ %i5 + 0x58 ]
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000aa8c: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000aa90: b8 10 00 06 mov %g6, %i4
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000aa94: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000aa98: c2 06 c0 00 ld [ %i3 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000aa9c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000aaa0: 01 00 00 00 nop
_Thread_queue_Queue_release(
queue,
&queue_context->Lock_context.Lock_context
);
_Thread_Priority_update( queue_context );
4000aaa4: 40 00 0d f7 call 4000e280 <_Thread_Priority_update>
4000aaa8: 90 10 00 1b mov %i3, %o0
if ( unblock ) {
4000aaac: 80 8e a0 ff btst 0xff, %i2
4000aab0: 12 80 00 0d bne 4000aae4 <_Thread_queue_Surrender+0xac>
<== ALWAYS TAKEN
4000aab4: 01 00 00 00 nop
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000aab8: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000aabc: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000aac0: 02 80 00 19 be 4000ab24 <_Thread_queue_Surrender+0xec>
<== NOT EXECUTED
4000aac4: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000aac8: c2 27 20 18 st %g1, [ %i4 + 0x18 ]
<== NOT EXECUTED
_Thread_Remove_timer_and_unblock( new_owner, queue );
}
_Thread_Dispatch_enable( cpu_self );
}
4000aacc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000aad0: 81 e8 00 00 restore
<== NOT EXECUTED
the_thread->Wait.flags = desired_flags;
4000aad4: 82 10 24 04 mov 0x404, %g1
<== NOT EXECUTED
unblock = false;
4000aad8: b4 10 20 00 clr %i2
<== NOT EXECUTED
4000aadc: 10 bf ff e7 b 4000aa78 <_Thread_queue_Surrender+0x40>
<== NOT EXECUTED
4000aae0: c2 22 20 50 st %g1, [ %o0 + 0x50 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000aae4: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000aae8: c2 27 bf fc st %g1, [ %fp + -4 ]
4000aaec: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
4000aaf0: 40 00 05 81 call 4000c0f4 <_Watchdog_Remove>
4000aaf4: 92 07 60 68 add %i5, 0x68, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000aaf8: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000aafc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ab00: 01 00 00 00 nop
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4000ab04: 13 0c 00 57 sethi %hi(0x30015c00), %o1
4000ab08: 90 10 00 1d mov %i5, %o0
4000ab0c: 40 00 0e 0a call 4000e334 <_Thread_Clear_state>
4000ab10: 92 12 63 ff or %o1, 0x3ff, %o1
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000ab14: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
if ( disable_level == 1 ) {
4000ab18: 80 a0 60 01 cmp %g1, 1
4000ab1c: 12 bf ff eb bne 4000aac8 <_Thread_queue_Surrender+0x90>
<== NEVER TAKEN
4000ab20: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000ab24: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000ab28: c4 0f 20 1c ldub [ %i4 + 0x1c ], %g2
4000ab2c: 80 a0 a0 00 cmp %g2, 0
4000ab30: 32 80 00 07 bne,a 4000ab4c <_Thread_queue_Surrender+0x114>
<== ALWAYS TAKEN
4000ab34: 92 10 00 01 mov %g1, %o1
cpu_self->thread_dispatch_disable_level = 0;
4000ab38: c0 27 20 18 clr [ %i4 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ab3c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ab40: 01 00 00 00 nop
4000ab44: 81 c7 e0 08 ret
4000ab48: 81 e8 00 00 restore
_Thread_Do_dispatch( cpu_self, level );
4000ab4c: c2 27 bf fc st %g1, [ %fp + -4 ]
4000ab50: 7f ff fd 4d call 4000a084 <_Thread_Do_dispatch>
4000ab54: 90 10 00 1c mov %i4, %o0
4000ab58: 10 bf ff f9 b 4000ab3c <_Thread_queue_Surrender+0x104>
4000ab5c: c2 07 bf fc ld [ %fp + -4 ], %g1
4000836c <_Timecounter_Bintime>:
{
4000836c: 9d e3 bf a0 save %sp, -96, %sp
40008370: 33 10 00 47 sethi %hi(0x40011c00), %i1
40008374: b2 16 63 78 or %i1, 0x378, %i1 ! 40011f78 <timehands>
th = timehands;
40008378: fa 06 40 00 ld [ %i1 ], %i5
4000837c: f4 07 60 70 ld [ %i5 + 0x70 ], %i2
*bt = th->th_bintime;
40008380: c4 1f 60 30 ldd [ %i5 + 0x30 ], %g2
40008384: c4 3e 00 00 std %g2, [ %i0 ]
40008388: c4 1f 60 38 ldd [ %i5 + 0x38 ], %g2
4000838c: f6 07 40 00 ld [ %i5 ], %i3
40008390: c4 3e 20 08 std %g2, [ %i0 + 8 ]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
40008394: 90 10 00 1b mov %i3, %o0
40008398: c2 06 c0 00 ld [ %i3 ], %g1
bintime_addx(bt, th->th_scale * tc_delta(th));
4000839c: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
400083a0: 9f c0 40 00 call %g1
400083a4: e0 07 60 14 ld [ %i5 + 0x14 ], %l0
400083a8: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
400083ac: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
400083b0: f6 06 e0 08 ld [ %i3 + 8 ], %i3
400083b4: 90 22 00 01 sub %o0, %g1, %o0
400083b8: 90 0a 00 1b and %o0, %i3, %o0
bintime_addx(bt, th->th_scale * tc_delta(th));
400083bc: b8 5f 00 08 smul %i4, %o0, %i4
400083c0: 92 52 00 10 umul %o0, %l0, %o1
400083c4: 91 40 00 00 rd %y, %o0
400083c8: 90 07 00 08 add %i4, %o0, %o0
400083cc: 9a 82 40 03 addcc %o1, %g3, %o5
400083d0: 98 c2 00 02 addxcc %o0, %g2, %o4
400083d4: 0a 80 00 12 bcs 4000841c <_Timecounter_Bintime+0xb0>
<== NEVER TAKEN
400083d8: 88 10 20 00 clr %g4
if (_u > _bt->frac)
400083dc: 80 a1 20 00 cmp %g4, 0
400083e0: 02 80 00 06 be 400083f8 <_Timecounter_Bintime+0x8c>
<== ALWAYS TAKEN
400083e4: d8 3e 20 08 std %o4, [ %i0 + 8 ]
_bt->sec++;
400083e8: c4 1e 00 00 ldd [ %i0 ], %g2
<== NOT EXECUTED
400083ec: 9a 80 e0 01 addcc %g3, 1, %o5
<== NOT EXECUTED
400083f0: 98 40 a0 00 addx %g2, 0, %o4
<== NOT EXECUTED
400083f4: d8 3e 00 00 std %o4, [ %i0 ]
<== NOT EXECUTED
} while (gen == 0 || gen != th->th_generation);
400083f8: 80 a6 a0 00 cmp %i2, 0
400083fc: 02 bf ff df be 40008378 <_Timecounter_Bintime+0xc>
<== NEVER TAKEN
40008400: 01 00 00 00 nop
40008404: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
40008408: 80 a0 40 1a cmp %g1, %i2
4000840c: 12 bf ff db bne 40008378 <_Timecounter_Bintime+0xc>
40008410: 01 00 00 00 nop
}
40008414: 81 c7 e0 08 ret
40008418: 81 e8 00 00 restore
4000841c: 10 bf ff f0 b 400083dc <_Timecounter_Bintime+0x70>
<== NOT EXECUTED
40008420: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
40010ecc <_Timecounter_Binuptime>:
{
40010ecc: 9d e3 bf a0 save %sp, -96, %sp
40010ed0: 33 10 00 cb sethi %hi(0x40032c00), %i1
40010ed4: b2 16 61 e0 or %i1, 0x1e0, %i1 ! 40032de0 <timehands>
th = timehands;
40010ed8: fa 06 40 00 ld [ %i1 ], %i5
40010edc: f4 07 60 70 ld [ %i5 + 0x70 ], %i2
*bt = th->th_offset;
40010ee0: c4 1f 60 20 ldd [ %i5 + 0x20 ], %g2
40010ee4: c4 3e 00 00 std %g2, [ %i0 ]
40010ee8: c4 1f 60 28 ldd [ %i5 + 0x28 ], %g2
40010eec: f6 07 40 00 ld [ %i5 ], %i3
40010ef0: c4 3e 20 08 std %g2, [ %i0 + 8 ]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
40010ef4: 90 10 00 1b mov %i3, %o0
40010ef8: c2 06 c0 00 ld [ %i3 ], %g1
bintime_addx(bt, th->th_scale * tc_delta(th));
40010efc: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
40010f00: 9f c0 40 00 call %g1
40010f04: e0 07 60 14 ld [ %i5 + 0x14 ], %l0
40010f08: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
40010f0c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
40010f10: f6 06 e0 08 ld [ %i3 + 8 ], %i3
40010f14: 90 22 00 01 sub %o0, %g1, %o0
40010f18: 90 0a 00 1b and %o0, %i3, %o0
bintime_addx(bt, th->th_scale * tc_delta(th));
40010f1c: b8 5f 00 08 smul %i4, %o0, %i4
40010f20: 92 52 00 10 umul %o0, %l0, %o1
40010f24: 91 40 00 00 rd %y, %o0
40010f28: 90 07 00 08 add %i4, %o0, %o0
40010f2c: 9a 82 40 03 addcc %o1, %g3, %o5
40010f30: 98 c2 00 02 addxcc %o0, %g2, %o4
40010f34: 0a 80 00 12 bcs 40010f7c <_Timecounter_Binuptime+0xb0>
<== NEVER TAKEN
40010f38: 88 10 20 00 clr %g4
if (_u > _bt->frac)
40010f3c: 80 a1 20 00 cmp %g4, 0
40010f40: 02 80 00 06 be 40010f58 <_Timecounter_Binuptime+0x8c>
<== ALWAYS TAKEN
40010f44: d8 3e 20 08 std %o4, [ %i0 + 8 ]
_bt->sec++;
40010f48: c4 1e 00 00 ldd [ %i0 ], %g2
<== NOT EXECUTED
40010f4c: 9a 80 e0 01 addcc %g3, 1, %o5
<== NOT EXECUTED
40010f50: 98 40 a0 00 addx %g2, 0, %o4
<== NOT EXECUTED
40010f54: d8 3e 00 00 std %o4, [ %i0 ]
<== NOT EXECUTED
} while (gen == 0 || gen != th->th_generation);
40010f58: 80 a6 a0 00 cmp %i2, 0
40010f5c: 02 bf ff df be 40010ed8 <_Timecounter_Binuptime+0xc>
<== NEVER TAKEN
40010f60: 01 00 00 00 nop
40010f64: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
40010f68: 80 a0 40 1a cmp %g1, %i2
40010f6c: 12 bf ff db bne 40010ed8 <_Timecounter_Binuptime+0xc>
40010f70: 01 00 00 00 nop
}
40010f74: 81 c7 e0 08 ret
40010f78: 81 e8 00 00 restore
40010f7c: 10 bf ff f0 b 40010f3c <_Timecounter_Binuptime+0x70>
<== NOT EXECUTED
40010f80: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
400084ac <_Timecounter_Getbintime>:
{
400084ac: 07 10 00 47 sethi %hi(0x40011c00), %g3
400084b0: 86 10 e3 78 or %g3, 0x378, %g3 ! 40011f78 <timehands>
th = timehands;
400084b4: c2 00 c0 00 ld [ %g3 ], %g1
400084b8: c4 00 60 70 ld [ %g1 + 0x70 ], %g2
*bt = th->th_bintime;
400084bc: d8 18 60 30 ldd [ %g1 + 0x30 ], %o4
400084c0: d8 3a 00 00 std %o4, [ %o0 ]
400084c4: d8 18 60 38 ldd [ %g1 + 0x38 ], %o4
400084c8: d8 3a 20 08 std %o4, [ %o0 + 8 ]
} while (gen == 0 || gen != th->th_generation);
400084cc: 80 a0 a0 00 cmp %g2, 0
400084d0: 02 bf ff f9 be 400084b4 <_Timecounter_Getbintime+0x8>
<== NEVER TAKEN
400084d4: 01 00 00 00 nop
400084d8: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
400084dc: 80 a0 40 02 cmp %g1, %g2
400084e0: 12 bf ff f5 bne 400084b4 <_Timecounter_Getbintime+0x8>
<== NEVER TAKEN
400084e4: 01 00 00 00 nop
}
400084e8: 81 c3 e0 08 retl
400084ec: 01 00 00 00 nop
400084f0 <_Timecounter_Getnanotime>:
{
400084f0: 07 10 00 47 sethi %hi(0x40011c00), %g3
<== NOT EXECUTED
400084f4: 86 10 e3 78 or %g3, 0x378, %g3 ! 40011f78 <timehands>
<== NOT EXECUTED
th = timehands;
400084f8: c2 00 c0 00 ld [ %g3 ], %g1
<== NOT EXECUTED
400084fc: c4 00 60 70 ld [ %g1 + 0x70 ], %g2
<== NOT EXECUTED
*tsp = th->th_nanotime;
40008500: d8 18 60 50 ldd [ %g1 + 0x50 ], %o4
<== NOT EXECUTED
40008504: d8 3a 00 00 std %o4, [ %o0 ]
<== NOT EXECUTED
40008508: d8 18 60 58 ldd [ %g1 + 0x58 ], %o4
<== NOT EXECUTED
4000850c: d8 3a 20 08 std %o4, [ %o0 + 8 ]
<== NOT EXECUTED
} while (gen == 0 || gen != th->th_generation);
40008510: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40008514: 02 bf ff f9 be 400084f8 <_Timecounter_Getnanotime+0x8>
<== NOT EXECUTED
40008518: 01 00 00 00 nop
<== NOT EXECUTED
4000851c: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
<== NOT EXECUTED
40008520: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40008524: 12 bf ff f5 bne 400084f8 <_Timecounter_Getnanotime+0x8>
<== NOT EXECUTED
40008528: 01 00 00 00 nop
<== NOT EXECUTED
}
4000852c: 81 c3 e0 08 retl
<== NOT EXECUTED
40008530: 01 00 00 00 nop
<== NOT EXECUTED
40008458 <_Timecounter_Getnanouptime>:
{
40008458: 19 10 00 47 sethi %hi(0x40011c00), %o4
_ts->tv_nsec = ((uint64_t)1000000000 *
4000845c: 1b 0e e6 b2 sethi %hi(0x3b9ac800), %o5
40008460: 98 13 23 78 or %o4, 0x378, %o4
40008464: 9a 13 62 00 or %o5, 0x200, %o5
th = timehands;
40008468: c2 03 00 00 ld [ %o4 ], %g1
4000846c: c8 00 60 70 ld [ %g1 + 0x70 ], %g4
_ts->tv_sec = _bt->sec;
40008470: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
40008474: c4 3a 00 00 std %g2, [ %o0 ]
(uint32_t)(_bt->frac >> 32)) >> 32;
40008478: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
_ts->tv_nsec = ((uint64_t)1000000000 *
4000847c: 86 50 80 0d umul %g2, %o5, %g3
40008480: 85 40 00 00 rd %y, %g2
40008484: c4 22 20 08 st %g2, [ %o0 + 8 ]
} while (gen == 0 || gen != th->th_generation);
40008488: 80 a1 20 00 cmp %g4, 0
4000848c: 02 bf ff f7 be 40008468 <_Timecounter_Getnanouptime+0x10>
<== NEVER TAKEN
40008490: 01 00 00 00 nop
40008494: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
40008498: 80 a0 40 04 cmp %g1, %g4
4000849c: 12 bf ff f3 bne 40008468 <_Timecounter_Getnanouptime+0x10>
<== NEVER TAKEN
400084a0: 01 00 00 00 nop
}
400084a4: 81 c3 e0 08 retl
400084a8: 01 00 00 00 nop
40008534 <_Timecounter_Install>:
{
40008534: 9d e3 bf 98 save %sp, -104, %sp
tc->tc_next = timecounters;
40008538: 03 10 00 47 sethi %hi(0x40011c00), %g1
4000853c: c4 00 63 70 ld [ %g1 + 0x370 ], %g2 ! 40011f70 <timecounters>
40008540: c4 26 20 28 st %g2, [ %i0 + 0x28 ]
(void)tc->tc_get_timecount(tc);
40008544: 90 10 00 18 mov %i0, %o0
40008548: c4 06 00 00 ld [ %i0 ], %g2
4000854c: 9f c0 80 00 call %g2
40008550: f0 20 63 70 st %i0, [ %g1 + 0x370 ]
(void)tc->tc_get_timecount(tc);
40008554: c2 06 00 00 ld [ %i0 ], %g1
40008558: 9f c0 40 00 call %g1
4000855c: 90 10 00 18 mov %i0, %o0
timecounter = tc;
40008560: 03 10 00 47 sethi %hi(0x40011c00), %g1
<== NOT EXECUTED
40008564: f0 20 63 74 st %i0, [ %g1 + 0x374 ] ! 40011f74 <_Timecounter>
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008568: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Timecounter_Acquire(&lock_context);
4000856c: c2 27 bf fc st %g1, [ %fp + -4 ]
_Timecounter_Windup(new_boottimebin, &lock_context);
40008570: 90 10 20 00 clr %o0
40008574: 7f ff fe a6 call 4000800c <_Timecounter_Windup>
40008578: 92 07 bf fc add %fp, -4, %o1
}
4000857c: 81 c7 e0 08 ret
40008580: 81 e8 00 00 restore
400082d8 <_Timecounter_Sbinuptime>:
{
400082d8: 9d e3 bf a0 save %sp, -96, %sp
400082dc: 33 10 00 47 sethi %hi(0x40011c00), %i1
400082e0: b2 16 63 78 or %i1, 0x378, %i1 ! 40011f78 <timehands>
th = timehands;
400082e4: fa 06 40 00 ld [ %i1 ], %i5
400082e8: f6 07 60 70 ld [ %i5 + 0x70 ], %i3
RTEMS_COMPILER_MEMORY_BARRIER();
400082ec: f8 07 40 00 ld [ %i5 ], %i4
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
400082f0: c2 07 00 00 ld [ %i4 ], %g1
400082f4: e2 07 60 24 ld [ %i5 + 0x24 ], %l1
400082f8: e0 07 60 28 ld [ %i5 + 0x28 ], %l0
sbt += (th->th_scale * tc_delta(th)) >> 32;
400082fc: f4 07 60 10 ld [ %i5 + 0x10 ], %i2
40008300: e4 07 60 14 ld [ %i5 + 0x14 ], %l2
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
40008304: 9f c0 40 00 call %g1
40008308: 90 10 00 1c mov %i4, %o0
4000830c: c4 07 60 18 ld [ %i5 + 0x18 ], %g2
tc->tc_counter_mask);
40008310: c2 07 20 08 ld [ %i4 + 8 ], %g1
} while (gen == 0 || gen != th->th_generation);
40008314: 80 a6 e0 00 cmp %i3, 0
40008318: 02 bf ff f3 be 400082e4 <_Timecounter_Sbinuptime+0xc>
<== NEVER TAKEN
4000831c: 01 00 00 00 nop
40008320: c6 07 60 70 ld [ %i5 + 0x70 ], %g3
40008324: 80 a0 c0 1b cmp %g3, %i3
40008328: 12 bf ff ef bne 400082e4 <_Timecounter_Sbinuptime+0xc>
<== NEVER TAKEN
4000832c: 84 22 00 02 sub %o0, %g2, %g2
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
40008330: 84 08 80 01 and %g2, %g1, %g2
sbt += (th->th_scale * tc_delta(th)) >> 32;
40008334: b4 5e 80 02 smul %i2, %g2, %i2
40008338: 86 50 80 12 umul %g2, %l2, %g3
4000833c: 85 40 00 00 rd %y, %g2
return (((sbintime_t)_bt.sec << 32) + (_bt.frac >> 32));
40008340: 9a 10 20 00 clr %o5
40008344: ba 06 80 02 add %i2, %g2, %i5
40008348: b2 83 40 10 addcc %o5, %l0, %i1
4000834c: 84 10 20 00 clr %g2
40008350: b0 44 40 02 addx %l1, %g2, %i0
40008354: b8 10 20 00 clr %i4
}
40008358: 86 87 40 19 addcc %i5, %i1, %g3
4000835c: 84 47 00 18 addx %i4, %i0, %g2
40008360: b2 10 00 03 mov %g3, %i1
40008364: 81 c7 e0 08 ret
40008368: 91 e8 00 02 restore %g0, %g2, %o0
4001bc68 <_Timecounter_Set_clock>:
{
4001bc68: 9d e3 bf 80 save %sp, -128, %sp
bt = *_bt;
4001bc6c: f8 1e 00 00 ldd [ %i0 ], %i4
4001bc70: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
4001bc74: f8 3f bf e0 std %i4, [ %fp + -32 ]
binuptime(&bt2);
4001bc78: 90 07 bf f0 add %fp, -16, %o0
4001bc7c: 7f ff ff 15 call 4001b8d0 <_Timecounter_Binuptime>
4001bc80: c4 3f bf e8 std %g2, [ %fp + -24 ]
4001bc84: c4 1f bf f8 ldd [ %fp + -8 ], %g2
4001bc88: f8 1f bf e8 ldd [ %fp + -24 ], %i4
4001bc8c: b6 a7 40 03 subcc %i5, %g3, %i3
4001bc90: b4 e7 00 02 subxcc %i4, %g2, %i2
4001bc94: 0a 80 00 12 bcs 4001bcdc <_Timecounter_Set_clock+0x74>
<== ALWAYS TAKEN
4001bc98: 82 10 20 00 clr %g1
_bt->frac -= _bt2->frac;
4001bc9c: f4 3f bf e8 std %i2, [ %fp + -24 ]
if (_u < _bt->frac)
4001bca0: 80 a0 60 00 cmp %g1, 0
4001bca4: 02 80 00 05 be 4001bcb8 <_Timecounter_Set_clock+0x50>
<== NEVER TAKEN
4001bca8: f4 1f bf e0 ldd [ %fp + -32 ], %i2
_bt->sec--;
4001bcac: c4 1f bf e0 ldd [ %fp + -32 ], %g2
4001bcb0: b6 80 ff ff addcc %g3, -1, %i3
4001bcb4: b4 40 bf ff addx %g2, -1, %i2
_bt->sec -= _bt2->sec;
4001bcb8: f8 1f bf f0 ldd [ %fp + -16 ], %i4
4001bcbc: 86 a6 c0 1d subcc %i3, %i5, %g3
4001bcc0: 84 66 80 1c subx %i2, %i4, %g2
_Timecounter_Windup(&bt, lock_context);
4001bcc4: 92 10 00 19 mov %i1, %o1
4001bcc8: c4 3f bf e0 std %g2, [ %fp + -32 ]
4001bccc: 7f ff fe 4e call 4001b604 <_Timecounter_Windup>
4001bcd0: 90 07 bf e0 add %fp, -32, %o0
}
4001bcd4: 81 c7 e0 08 ret
4001bcd8: 81 e8 00 00 restore
4001bcdc: 10 bf ff f0 b 4001bc9c <_Timecounter_Set_clock+0x34>
4001bce0: 82 10 20 01 mov 1, %g1
40008584 <_Timecounter_Tick>:
}
}
#else /* __rtems__ */
void
_Timecounter_Tick(void)
{
40008584: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
Per_CPU_Control *cpu_self = _Per_CPU_Get();
40008588: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
4000858c: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Timecounter_Acquire(&lock_context);
40008590: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
_Timecounter_Windup(new_boottimebin, &lock_context);
40008594: 90 10 20 00 clr %o0
<== NOT EXECUTED
40008598: 7f ff fe 9d call 4000800c <_Timecounter_Windup>
<== NOT EXECUTED
4000859c: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
if (_Per_CPU_Is_boot_processor(cpu_self)) {
tc_windup(NULL);
}
_Watchdog_Tick(cpu_self);
400085a0: 40 00 0f 1f call 4000c21c <_Watchdog_Tick>
<== NOT EXECUTED
400085a4: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
}
400085a8: 81 c7 e0 08 ret
<== NOT EXECUTED
400085ac: 81 e8 00 00 restore
<== NOT EXECUTED
400085b0 <_Timecounter_Tick_simple>:
void
_Timecounter_Tick_simple(uint32_t delta, uint32_t offset,
ISR_lock_Context *lock_context)
{
400085b0: 9d e3 bf a0 save %sp, -96, %sp
struct bintime bt;
struct timehands *th;
uint32_t ogen;
th = timehands;
400085b4: 03 10 00 47 sethi %hi(0x40011c00), %g1
400085b8: c2 00 63 78 ld [ %g1 + 0x378 ], %g1 ! 40011f78 <timehands>
ogen = th->th_generation;
th->th_offset_count = offset;
400085bc: f2 20 60 18 st %i1, [ %g1 + 0x18 ]
bintime_addx(&th->th_offset, th->th_scale * delta);
400085c0: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
400085c4: f8 18 60 28 ldd [ %g1 + 0x28 ], %i4
400085c8: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
400085cc: 86 58 c0 18 smul %g3, %i0, %g3
ogen = th->th_generation;
400085d0: c8 00 60 70 ld [ %g1 + 0x70 ], %g4
bintime_addx(&th->th_offset, th->th_scale * delta);
400085d4: b2 50 80 18 umul %g2, %i0, %i1
400085d8: b1 40 00 00 rd %y, %i0
400085dc: b0 00 c0 18 add %g3, %i0, %i0
400085e0: 96 86 40 1d addcc %i1, %i5, %o3
400085e4: 94 c6 00 1c addxcc %i0, %i4, %o2
400085e8: 0a 80 00 30 bcs 400086a8 <_Timecounter_Tick_simple+0xf8>
400085ec: 84 10 20 00 clr %g2
if (_u > _bt->frac)
400085f0: 80 a0 a0 00 cmp %g2, 0
400085f4: 12 80 00 28 bne 40008694 <_Timecounter_Tick_simple+0xe4>
400085f8: d4 38 60 28 std %o2, [ %g1 + 0x28 ]
400085fc: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4
40008600: c4 18 60 68 ldd [ %g1 + 0x68 ], %g2
40008604: b2 80 c0 0b addcc %g3, %o3, %i1
40008608: b0 c0 80 0a addxcc %g2, %o2, %i0
_bt->sec++;
4000860c: 0a 80 00 29 bcs 400086b0 <_Timecounter_Tick_simple+0x100>
40008610: 96 83 60 01 addcc %o5, 1, %o3
bt = th->th_offset;
40008614: 94 10 00 0c mov %o4, %o2
40008618: 96 10 00 0d mov %o5, %o3
_bt->sec += _bt2->sec;
4000861c: c4 18 60 60 ldd [ %g1 + 0x60 ], %g2
40008620: 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;
40008624: f0 38 60 38 std %i0, [ %g1 + 0x38 ]
40008628: b8 42 80 02 addx %o2, %g2, %i4
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
4000862c: 15 00 03 d0 sethi %hi(0xf4000), %o2
_ts->tv_nsec = ((uint64_t)1000000000 *
40008630: 05 0e e6 b2 sethi %hi(0x3b9ac800), %g2
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
40008634: 94 12 a2 40 or %o2, 0x240, %o2
_ts->tv_nsec = ((uint64_t)1000000000 *
40008638: 84 10 a2 00 or %g2, 0x200, %g2
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
4000863c: 96 56 00 0a umul %i0, %o2, %o3
40008640: 95 40 00 00 rd %y, %o2
_ts->tv_nsec = ((uint64_t)1000000000 *
40008644: 86 56 00 02 umul %i0, %g2, %g3
40008648: 85 40 00 00 rd %y, %g2
4000864c: 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)
40008650: 88 81 20 01 inccc %g4
_tv->tv_sec = _bt->sec;
40008654: f8 38 60 40 std %i4, [ %g1 + 0x40 ]
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
40008658: d4 20 60 48 st %o2, [ %g1 + 0x48 ]
_ts->tv_sec = _bt->sec;
4000865c: f8 38 60 50 std %i4, [ %g1 + 0x50 ]
40008660: 12 80 00 03 bne 4000866c <_Timecounter_Tick_simple+0xbc>
<== ALWAYS TAKEN
40008664: c4 20 60 58 st %g2, [ %g1 + 0x58 ]
ogen = 1;
40008668: 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;
4000866c: 05 10 00 47 sethi %hi(0x40011c00), %g2
<== NOT EXECUTED
40008670: f8 38 a3 68 std %i4, [ %g2 + 0x368 ] ! 40011f68 <_Timecounter_Time_second>
<== NOT EXECUTED
th->th_generation = ogen;
40008674: c8 20 60 70 st %g4, [ %g1 + 0x70 ]
<== NOT EXECUTED
time_uptime = th->th_offset.sec;
40008678: 03 10 00 47 sethi %hi(0x40011c00), %g1
<== NOT EXECUTED
4000867c: da 20 63 60 st %o5, [ %g1 + 0x360 ] ! 40011f60 <_Timecounter_Time_uptime>
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008680: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008684: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008688: 01 00 00 00 nop
_Timecounter_Release(lock_context);
_Watchdog_Tick(_Per_CPU_Get_snapshot());
4000868c: 40 00 0e e4 call 4000c21c <_Watchdog_Tick>
40008690: 91 e8 00 06 restore %g0, %g6, %o0
_bt->sec++;
40008694: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
40008698: 9a 80 e0 01 addcc %g3, 1, %o5
4000869c: 98 40 a0 00 addx %g2, 0, %o4
400086a0: 10 bf ff d8 b 40008600 <_Timecounter_Tick_simple+0x50>
400086a4: d8 38 60 20 std %o4, [ %g1 + 0x20 ]
400086a8: 10 bf ff d2 b 400085f0 <_Timecounter_Tick_simple+0x40>
400086ac: 84 10 20 01 mov 1, %g2
_bt->sec++;
400086b0: 10 bf ff db b 4000861c <_Timecounter_Tick_simple+0x6c>
400086b4: 94 43 20 00 addx %o4, 0, %o2
40045370 <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
40045370: 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;
40045374: de 06 60 08 ld [ %i1 + 8 ], %o7
<== NOT EXECUTED
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
40045378: c8 06 40 00 ld [ %i1 ], %g4
<== NOT EXECUTED
4004537c: c4 06 60 04 ld [ %i1 + 4 ], %g2
<== NOT EXECUTED
40045380: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1
<== NOT EXECUTED
right += rhs->tv_nsec;
40045384: b9 3b e0 1f sra %o7, 0x1f, %i4
<== NOT EXECUTED
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
40045388: 82 10 62 00 or %g1, 0x200, %g1
<== NOT EXECUTED
4004538c: 86 50 80 01 umul %g2, %g1, %g3
<== NOT EXECUTED
40045390: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
40045394: 88 59 00 01 smul %g4, %g1, %g4
<== NOT EXECUTED
right += rhs->tv_nsec;
40045398: 96 83 c0 03 addcc %o7, %g3, %o3
<== NOT EXECUTED
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
4004539c: 84 01 00 02 add %g4, %g2, %g2
<== NOT EXECUTED
right += rhs->tv_nsec;
400453a0: 94 47 00 02 addx %i4, %g2, %o2
<== NOT EXECUTED
if ( right == 0 ) {
400453a4: 80 92 80 0b orcc %o2, %o3, %g0
<== NOT EXECUTED
400453a8: 02 80 00 20 be 40045428 <_Timespec_Divide+0xb8>
<== NOT EXECUTED
400453ac: 11 00 00 61 sethi %hi(0x18400), %o0
<== NOT EXECUTED
left += lhs->tv_nsec;
400453b0: f2 06 20 08 ld [ %i0 + 8 ], %i1
<== NOT EXECUTED
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
400453b4: c8 06 00 00 ld [ %i0 ], %g4
<== NOT EXECUTED
400453b8: c4 06 20 04 ld [ %i0 + 4 ], %g2
<== NOT EXECUTED
400453bc: 86 50 80 01 umul %g2, %g1, %g3
<== NOT EXECUTED
400453c0: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
400453c4: 88 59 00 01 smul %g4, %g1, %g4
<== NOT EXECUTED
left += lhs->tv_nsec;
400453c8: b9 3e 60 1f sra %i1, 0x1f, %i4
<== NOT EXECUTED
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
400453cc: 84 01 00 02 add %g4, %g2, %g2
<== NOT EXECUTED
left += lhs->tv_nsec;
400453d0: b2 86 40 03 addcc %i1, %g3, %i1
<== NOT EXECUTED
400453d4: b0 47 00 02 addx %i4, %g2, %i0
<== NOT EXECUTED
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
400453d8: 90 12 22 a0 or %o0, 0x2a0, %o0
<== NOT EXECUTED
400453dc: 82 5e 00 08 smul %i0, %o0, %g1
<== NOT EXECUTED
400453e0: 92 56 40 08 umul %i1, %o0, %o1
<== NOT EXECUTED
400453e4: 91 40 00 00 rd %y, %o0
<== NOT EXECUTED
400453e8: 40 00 d2 fa call 40079fd0 <__udivdi3>
<== NOT EXECUTED
400453ec: 90 00 40 08 add %g1, %o0, %o0
<== NOT EXECUTED
*ival_percentage = answer / 1000;
400453f0: 94 10 20 00 clr %o2
<== NOT EXECUTED
answer = (left * 100000) / right;
400453f4: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
400453f8: ba 10 00 09 mov %o1, %i5
<== NOT EXECUTED
*ival_percentage = answer / 1000;
400453fc: 40 00 d2 f5 call 40079fd0 <__udivdi3>
<== NOT EXECUTED
40045400: 96 10 23 e8 mov 0x3e8, %o3
<== NOT EXECUTED
40045404: d2 26 80 00 st %o1, [ %i2 ]
<== NOT EXECUTED
*fval_percentage = answer % 1000;
40045408: 94 10 20 00 clr %o2
<== NOT EXECUTED
4004540c: 96 10 23 e8 mov 0x3e8, %o3
<== NOT EXECUTED
40045410: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40045414: 40 00 d3 68 call 4007a1b4 <__umoddi3>
<== NOT EXECUTED
40045418: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4004541c: d2 26 c0 00 st %o1, [ %i3 ]
<== NOT EXECUTED
}
40045420: 81 c7 e0 08 ret
<== NOT EXECUTED
40045424: 81 e8 00 00 restore
<== NOT EXECUTED
*ival_percentage = 0;
40045428: c0 26 80 00 clr [ %i2 ]
<== NOT EXECUTED
*fval_percentage = 0;
4004542c: c0 26 c0 00 clr [ %i3 ]
<== NOT EXECUTED
return;
40045430: 81 c7 e0 08 ret
<== NOT EXECUTED
40045434: 81 e8 00 00 restore
<== NOT EXECUTED
400452e8 <_Timespec_Divide_by_integer>:
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
400452e8: 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;
400452ec: fa 06 20 08 ld [ %i0 + 8 ], %i5
<== NOT EXECUTED
t = time->tv_sec;
400452f0: c6 06 00 00 ld [ %i0 ], %g3
<== NOT EXECUTED
400452f4: c4 06 20 04 ld [ %i0 + 4 ], %g2
<== NOT EXECUTED
t += time->tv_nsec;
400452f8: 91 3f 60 1f sra %i5, 0x1f, %o0
<== NOT EXECUTED
t *= TOD_NANOSECONDS_PER_SECOND;
400452fc: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1
<== NOT EXECUTED
40045300: 82 10 62 00 or %g1, 0x200, %g1 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
<== NOT EXECUTED
40045304: 88 58 c0 01 smul %g3, %g1, %g4
<== NOT EXECUTED
40045308: 86 50 80 01 umul %g2, %g1, %g3
<== NOT EXECUTED
4004530c: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
40045310: ba 87 40 03 addcc %i5, %g3, %i5
<== NOT EXECUTED
t *= TOD_NANOSECONDS_PER_SECOND;
40045314: 84 01 00 02 add %g4, %g2, %g2
<== NOT EXECUTED
t /= iterations;
40045318: 94 10 20 00 clr %o2
<== NOT EXECUTED
4004531c: b8 42 00 02 addx %o0, %g2, %i4
<== NOT EXECUTED
40045320: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
40045324: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40045328: 40 00 d3 2a call 40079fd0 <__udivdi3>
<== NOT EXECUTED
4004532c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
40045330: 94 10 20 00 clr %o2
<== NOT EXECUTED
t /= iterations;
40045334: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
40045338: ba 10 00 09 mov %o1, %i5
<== NOT EXECUTED
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
4004533c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
<== NOT EXECUTED
40045340: 40 00 d3 24 call 40079fd0 <__udivdi3>
<== NOT EXECUTED
40045344: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
<== NOT EXECUTED
40045348: d0 3e 80 00 std %o0, [ %i2 ]
<== NOT EXECUTED
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
4004534c: 94 10 20 00 clr %o2
<== NOT EXECUTED
40045350: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
<== NOT EXECUTED
40045354: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40045358: 96 12 e2 00 or %o3, 0x200, %o3
<== NOT EXECUTED
4004535c: 40 00 d3 96 call 4007a1b4 <__umoddi3>
<== NOT EXECUTED
40045360: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40045364: d2 26 a0 08 st %o1, [ %i2 + 8 ]
<== NOT EXECUTED
}
40045368: 81 c7 e0 08 ret
<== NOT EXECUTED
4004536c: 81 e8 00 00 restore
<== NOT EXECUTED
400158b4 <_Timespec_Get_as_nanoseconds>:
#include <rtems/score/todimpl.h>
uint64_t _Timespec_Get_as_nanoseconds(
const struct timespec *time
)
{
400158b4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
return ( ((uint64_t) time->tv_sec) * 1000000000ULL ) + time->tv_nsec;
400158b8: fa 06 20 08 ld [ %i0 + 8 ], %i5
<== NOT EXECUTED
400158bc: c8 06 00 00 ld [ %i0 ], %g4
<== NOT EXECUTED
400158c0: c4 06 20 04 ld [ %i0 + 4 ], %g2
<== NOT EXECUTED
400158c4: b1 3f 60 1f sra %i5, 0x1f, %i0
<== NOT EXECUTED
400158c8: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1
<== NOT EXECUTED
400158cc: 82 10 62 00 or %g1, 0x200, %g1 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
<== NOT EXECUTED
400158d0: 86 50 80 01 umul %g2, %g1, %g3
<== NOT EXECUTED
400158d4: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
400158d8: 88 59 00 01 smul %g4, %g1, %g4
<== NOT EXECUTED
}
400158dc: 9a 80 c0 1d addcc %g3, %i5, %o5
<== NOT EXECUTED
return ( ((uint64_t) time->tv_sec) * 1000000000ULL ) + time->tv_nsec;
400158e0: 84 01 00 02 add %g4, %g2, %g2
<== NOT EXECUTED
}
400158e4: b2 10 00 0d mov %o5, %i1
<== NOT EXECUTED
400158e8: 98 40 80 18 addx %g2, %i0, %o4
<== NOT EXECUTED
400158ec: 81 c7 e0 08 ret
<== NOT EXECUTED
400158f0: 91 e8 00 0c restore %g0, %o4, %o0
<== NOT EXECUTED
4002c3fc <_Timespec_Less_than>:
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
4002c3fc: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
4002c400: c2 02 40 00 ld [ %o1 ], %g1
<== NOT EXECUTED
4002c404: c8 02 20 04 ld [ %o0 + 4 ], %g4
<== NOT EXECUTED
4002c408: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4002c40c: 14 80 00 13 bg 4002c458 <_Timespec_Less_than+0x5c>
<== NOT EXECUTED
4002c410: c6 02 60 04 ld [ %o1 + 4 ], %g3
<== NOT EXECUTED
4002c414: 02 80 00 0f be 4002c450 <_Timespec_Less_than+0x54>
<== NOT EXECUTED
4002c418: 80 a0 c0 04 cmp %g3, %g4
<== NOT EXECUTED
return true;
if ( lhs->tv_sec > rhs->tv_sec )
4002c41c: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4002c420: 34 80 00 0a bg,a 4002c448 <_Timespec_Less_than+0x4c>
<== NOT EXECUTED
4002c424: 90 10 20 00 clr %o0
<== NOT EXECUTED
4002c428: 02 80 00 0f be 4002c464 <_Timespec_Less_than+0x68>
<== NOT EXECUTED
4002c42c: 80 a1 00 03 cmp %g4, %g3
<== NOT EXECUTED
return false;
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
4002c430: c4 02 20 08 ld [ %o0 + 8 ], %g2
<== NOT EXECUTED
4002c434: c2 02 60 08 ld [ %o1 + 8 ], %g1
<== NOT EXECUTED
4002c438: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4002c43c: 06 80 00 03 bl 4002c448 <_Timespec_Less_than+0x4c>
<== NOT EXECUTED
4002c440: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
return false;
4002c444: 90 10 20 00 clr %o0
<== NOT EXECUTED
return true;
return false;
}
4002c448: 81 c3 e0 08 retl
<== NOT EXECUTED
4002c44c: 90 0a 20 01 and %o0, 1, %o0
<== NOT EXECUTED
if ( lhs->tv_sec < rhs->tv_sec )
4002c450: 08 bf ff f4 bleu 4002c420 <_Timespec_Less_than+0x24>
<== NOT EXECUTED
4002c454: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
return true;
4002c458: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
}
4002c45c: 81 c3 e0 08 retl
<== NOT EXECUTED
4002c460: 90 0a 20 01 and %o0, 1, %o0
<== NOT EXECUTED
if ( lhs->tv_sec > rhs->tv_sec )
4002c464: 28 bf ff f4 bleu,a 4002c434 <_Timespec_Less_than+0x38>
<== NOT EXECUTED
4002c468: c4 02 20 08 ld [ %o0 + 8 ], %g2
<== NOT EXECUTED
return false;
4002c46c: 10 bf ff f7 b 4002c448 <_Timespec_Less_than+0x4c>
<== NOT EXECUTED
4002c470: 90 10 20 00 clr %o0
<== NOT EXECUTED
4002c474 <_Timespec_Subtract>:
void _Timespec_Subtract(
const struct timespec *start,
const struct timespec *end,
struct timespec *result
)
{
4002c474: 9d e3 bf a0 save %sp, -96, %sp
4002c478: d8 1e 00 00 ldd [ %i0 ], %o4
4002c47c: d4 1e 40 00 ldd [ %i1 ], %o2
4002c480: ba a2 c0 0d subcc %o3, %o5, %i5
if (end->tv_nsec < start->tv_nsec) {
4002c484: c2 06 60 08 ld [ %i1 + 8 ], %g1
4002c488: c4 06 20 08 ld [ %i0 + 8 ], %g2
4002c48c: b8 62 80 0c subx %o2, %o4, %i4
4002c490: 80 a0 40 02 cmp %g1, %g2
4002c494: 26 80 00 07 bl,a 4002c4b0 <_Timespec_Subtract+0x3c>
<== NEVER TAKEN
4002c498: b2 87 7f ff addcc %i5, -1, %i1
<== NOT EXECUTED
result->tv_sec = end->tv_sec - start->tv_sec - 1;
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
} else {
result->tv_sec = end->tv_sec - start->tv_sec;
result->tv_nsec = end->tv_nsec - start->tv_nsec;
4002c49c: 82 20 40 02 sub %g1, %g2, %g1
result->tv_sec = end->tv_sec - start->tv_sec;
4002c4a0: f8 3e 80 00 std %i4, [ %i2 ]
result->tv_nsec = end->tv_nsec - start->tv_nsec;
4002c4a4: c2 26 a0 08 st %g1, [ %i2 + 8 ]
}
}
4002c4a8: 81 c7 e0 08 ret
4002c4ac: 81 e8 00 00 restore
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
4002c4b0: 82 20 40 02 sub %g1, %g2, %g1
<== NOT EXECUTED
result->tv_sec = end->tv_sec - start->tv_sec - 1;
4002c4b4: b0 47 3f ff addx %i4, -1, %i0
<== NOT EXECUTED
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
4002c4b8: 05 0e e6 b2 sethi %hi(0x3b9ac800), %g2
<== NOT EXECUTED
result->tv_sec = end->tv_sec - start->tv_sec - 1;
4002c4bc: f0 3e 80 00 std %i0, [ %i2 ]
<== NOT EXECUTED
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
4002c4c0: 84 10 a2 00 or %g2, 0x200, %g2
<== NOT EXECUTED
4002c4c4: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
result->tv_nsec =
4002c4c8: c2 26 a0 08 st %g1, [ %i2 + 8 ]
<== NOT EXECUTED
4002c4cc: 81 c7 e0 08 ret
<== NOT EXECUTED
4002c4d0: 81 e8 00 00 restore
<== NOT EXECUTED
4001aa60 <_Timespec_To_ticks>:
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
4001aa60: 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) )
4001aa64: c2 06 00 00 ld [ %i0 ], %g1
<== NOT EXECUTED
4001aa68: fa 06 20 04 ld [ %i0 + 4 ], %i5
<== NOT EXECUTED
4001aa6c: 80 90 40 1d orcc %g1, %i5, %g0
<== NOT EXECUTED
4001aa70: 12 80 00 06 bne 4001aa88 <_Timespec_To_ticks+0x28>
<== NOT EXECUTED
4001aa74: 01 00 00 00 nop
<== NOT EXECUTED
4001aa78: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
4001aa7c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001aa80: 02 80 00 11 be 4001aac4 <_Timespec_To_ticks+0x64>
<== NOT EXECUTED
4001aa84: 90 10 20 00 clr %o0
<== NOT EXECUTED
/**
* We should ensure the ticks not be truncated by integer division. We
* need to have it be greater than or equal to the requested time. It
* should not be shorter.
*/
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
4001aa88: 40 00 04 63 call 4001bc14 <TOD_TICKS_PER_SECOND_method>
<== NOT EXECUTED
4001aa8c: 01 00 00 00 nop
<== NOT EXECUTED
nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick();
ticks += time->tv_nsec / nanoseconds_per_tick;
4001aa90: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick();
4001aa94: 05 10 00 b4 sethi %hi(0x4002d000), %g2
<== NOT EXECUTED
4001aa98: c4 00 a3 58 ld [ %g2 + 0x358 ], %g2 ! 4002d358 <_Watchdog_Nanoseconds_per_tick>
<== NOT EXECUTED
ticks += time->tv_nsec / nanoseconds_per_tick;
4001aa9c: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
4001aaa0: 01 00 00 00 nop
<== NOT EXECUTED
4001aaa4: 01 00 00 00 nop
<== NOT EXECUTED
4001aaa8: 01 00 00 00 nop
<== NOT EXECUTED
4001aaac: b0 70 40 02 udiv %g1, %g2, %i0
<== NOT EXECUTED
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
4001aab0: 90 5a 00 1d smul %o0, %i5, %o0
<== NOT EXECUTED
if ( (time->tv_nsec % nanoseconds_per_tick) != 0 )
4001aab4: 84 5e 00 02 smul %i0, %g2, %g2
<== NOT EXECUTED
4001aab8: 82 20 40 02 sub %g1, %g2, %g1
<== NOT EXECUTED
ticks += 1;
4001aabc: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
4001aac0: 90 42 00 18 addx %o0, %i0, %o0
<== NOT EXECUTED
return ticks;
}
4001aac4: 81 c7 e0 08 ret
<== NOT EXECUTED
4001aac8: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000bd40 <_User_extensions_Add_set>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000bd40: 91 d0 20 09 ta 9
<== NOT EXECUTED
old_last = tail->previous;
4000bd44: 05 10 00 48 sethi %hi(0x40012000), %g2
<== NOT EXECUTED
4000bd48: 84 10 a0 40 or %g2, 0x40, %g2 ! 40012040 <_User_extensions_List>
<== NOT EXECUTED
4000bd4c: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
the_node->next = tail;
4000bd50: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
4000bd54: c8 22 00 00 st %g4, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
4000bd58: d0 20 a0 08 st %o0, [ %g2 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
4000bd5c: d0 20 c0 00 st %o0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
4000bd60: c6 22 20 04 st %g3, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000bd64: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000bd68: 01 00 00 00 nop
/*
* If a switch handler is present, append it to the switch chain.
*/
if ( the_extension->Callouts.thread_switch != NULL ) {
4000bd6c: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
4000bd70: 80 a0 60 00 cmp %g1, 0
4000bd74: 02 80 00 0f be 4000bdb0 <_User_extensions_Add_set+0x70>
<== ALWAYS TAKEN
4000bd78: 01 00 00 00 nop
ISR_Level level;
the_extension->Switch.thread_switch =
4000bd7c: c2 22 20 10 st %g1, [ %o0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000bd80: 91 d0 20 09 ta 9
<== NOT EXECUTED
old_last = tail->previous;
4000bd84: 05 10 00 48 sethi %hi(0x40012000), %g2
<== NOT EXECUTED
4000bd88: 84 10 a0 28 or %g2, 0x28, %g2 ! 40012028 <_User_extensions_Switches_list>
<== NOT EXECUTED
4000bd8c: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
the_node->next = tail;
4000bd90: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
4000bd94: 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 );
4000bd98: 88 02 20 08 add %o0, 8, %g4
<== NOT EXECUTED
tail->previous = the_node;
4000bd9c: c8 20 a0 08 st %g4, [ %g2 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
4000bda0: c8 20 c0 00 st %g4, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
4000bda4: c6 22 20 0c st %g3, [ %o0 + 0xc ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000bda8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000bdac: 01 00 00 00 nop
<== NOT EXECUTED
&_User_extensions_Switches_list,
&the_extension->Switch.Node
);
_Per_CPU_Release_all( level );
}
}
4000bdb0: 81 c3 e0 08 retl
4000bdb4: 01 00 00 00 nop
4000c070 <_User_extensions_Handler_initialization>:
#include <rtems/config.h>
#include <rtems/score/userextimpl.h>
#include <rtems/score/wkspace.h>
void _User_extensions_Handler_initialization(void)
{
4000c070: 9d e3 bf a0 save %sp, -96, %sp
User_extensions_Switch_control *initial_extension_switch_controls;
const User_extensions_Table *initial_table;
uint32_t n;
uint32_t i;
n = rtems_configuration_get_number_of_initial_extensions();
4000c074: 39 10 00 3f sethi %hi(0x4000fc00), %i4
4000c078: b8 17 22 2c or %i4, 0x22c, %i4 ! 4000fe2c <Configuration>
4000c07c: f6 07 20 34 ld [ %i4 + 0x34 ], %i3
initial_extension_switch_controls = _Workspace_Allocate_or_fatal_error(
n * sizeof( *initial_extension_switch_controls )
4000c080: 87 2e e0 01 sll %i3, 1, %g3
4000c084: 86 00 c0 1b add %g3, %i3, %g3
4000c088: bb 28 e0 02 sll %g3, 2, %i5
initial_extension_switch_controls = _Workspace_Allocate_or_fatal_error(
4000c08c: 40 00 01 2b call 4000c538 <_Workspace_Allocate_or_fatal_error>
4000c090: 90 10 00 1d mov %i5, %o0
);
initial_table = rtems_configuration_get_user_extension_table();
for ( i = 0 ; i < n ; ++i ) {
4000c094: 80 a6 e0 00 cmp %i3, 0
4000c098: 02 80 00 15 be 4000c0ec <_User_extensions_Handler_initialization+0x7c>
<== NEVER TAKEN
4000c09c: c2 07 20 38 ld [ %i4 + 0x38 ], %g1
old_last = tail->previous;
4000c0a0: 09 10 00 48 sethi %hi(0x40012000), %g4
4000c0a4: 86 02 00 1d add %o0, %i5, %g3
4000c0a8: 88 11 20 28 or %g4, 0x28, %g4
4000c0ac: 82 00 60 10 add %g1, 0x10, %g1
the_node->next = tail;
4000c0b0: ba 01 20 04 add %g4, 4, %i5
User_extensions_thread_switch_extension callout;
callout = initial_table[ i ].thread_switch;
4000c0b4: c4 00 40 00 ld [ %g1 ], %g2
if ( callout != NULL ) {
4000c0b8: 80 a0 a0 00 cmp %g2, 0
4000c0bc: 22 80 00 09 be,a 4000c0e0 <_User_extensions_Handler_initialization+0x70>
4000c0c0: 90 02 20 0c add %o0, 0xc, %o0
User_extensions_Switch_control *c;
c = &initial_extension_switch_controls[ i ];
c->thread_switch = callout;
4000c0c4: c4 22 20 08 st %g2, [ %o0 + 8 ]
old_last = tail->previous;
4000c0c8: c4 01 20 08 ld [ %g4 + 8 ], %g2
the_node->next = tail;
4000c0cc: fa 22 00 00 st %i5, [ %o0 ]
tail->previous = the_node;
4000c0d0: d0 21 20 08 st %o0, [ %g4 + 8 ]
old_last->next = the_node;
4000c0d4: d0 20 80 00 st %o0, [ %g2 ]
the_node->previous = old_last;
4000c0d8: c4 22 20 04 st %g2, [ %o0 + 4 ]
4000c0dc: 90 02 20 0c add %o0, 0xc, %o0
for ( i = 0 ; i < n ; ++i ) {
4000c0e0: 80 a2 00 03 cmp %o0, %g3
4000c0e4: 12 bf ff f4 bne 4000c0b4 <_User_extensions_Handler_initialization+0x44>
4000c0e8: 82 00 60 24 add %g1, 0x24, %g1
_Chain_Initialize_node( &c->Node );
_Chain_Append_unprotected( &_User_extensions_Switches_list, &c->Node );
}
}
}
4000c0ec: 81 c7 e0 08 ret
4000c0f0: 81 e8 00 00 restore
4000bef8 <_User_extensions_Iterate>:
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor,
Chain_Iterator_direction direction
)
{
4000bef8: 9d e3 bf 88 save %sp, -120, %sp
User_extensions_Iterator iter;
ISR_lock_Context lock_context;
executing = _Thread_Get_executing();
initial_begin = rtems_configuration_get_user_extension_table();
4000befc: 03 10 00 3f sethi %hi(0x4000fc00), %g1
4000bf00: 82 10 62 2c or %g1, 0x22c, %g1 ! 4000fe2c <Configuration>
initial_end =
initial_begin + rtems_configuration_get_number_of_initial_extensions();
4000bf04: c4 00 60 34 ld [ %g1 + 0x34 ], %g2
initial_begin = rtems_configuration_get_user_extension_table();
4000bf08: e0 00 60 38 ld [ %g1 + 0x38 ], %l0
initial_begin + rtems_configuration_get_number_of_initial_extensions();
4000bf0c: bb 28 a0 03 sll %g2, 3, %i5
4000bf10: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4
4000bf14: ba 07 40 02 add %i5, %g2, %i5
if ( direction == CHAIN_ITERATOR_FORWARD ) {
4000bf18: 80 a6 a0 00 cmp %i2, 0
initial_begin + rtems_configuration_get_number_of_initial_extensions();
4000bf1c: bb 2f 60 02 sll %i5, 2, %i5
if ( direction == CHAIN_ITERATOR_FORWARD ) {
4000bf20: 12 80 00 50 bne 4000c060 <_User_extensions_Iterate+0x168>
4000bf24: ba 04 00 1d add %l0, %i5, %i5
initial_current = initial_begin;
while ( initial_current != initial_end ) {
4000bf28: 80 a4 00 1d cmp %l0, %i5
4000bf2c: 02 80 00 0a be 4000bf54 <_User_extensions_Iterate+0x5c>
<== NEVER TAKEN
4000bf30: b6 10 00 10 mov %l0, %i3
(*visitor)( executing, arg, initial_current );
4000bf34: 94 10 00 1b mov %i3, %o2
4000bf38: 92 10 00 18 mov %i0, %o1
4000bf3c: 9f c6 40 00 call %i1
4000bf40: 90 10 00 1c mov %i4, %o0
++initial_current;
4000bf44: b6 06 e0 24 add %i3, 0x24, %i3
while ( initial_current != initial_end ) {
4000bf48: 80 a7 40 1b cmp %i5, %i3
4000bf4c: 12 bf ff fb bne 4000bf38 <_User_extensions_Iterate+0x40>
4000bf50: 94 10 00 1b mov %i3, %o2
}
end = _Chain_Immutable_tail( &_User_extensions_List.Active );
4000bf54: 37 10 00 48 sethi %hi(0x40012000), %i3
<== NOT EXECUTED
4000bf58: b6 16 e0 44 or %i3, 0x44, %i3 ! 40012044 <_User_extensions_List+0x4>
<== NOT EXECUTED
4000bf5c: 84 06 ff fc add %i3, -4, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000bf60: 91 d0 20 09 ta 9
<== NOT EXECUTED
old_last = tail->previous;
4000bf64: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
tail->previous = the_node;
4000bf68: 86 07 bf ec add %fp, -20, %g3
the_node->next = tail;
4000bf6c: 9e 00 a0 10 add %g2, 0x10, %o7
tail->previous = the_node;
4000bf70: c6 20 a0 14 st %g3, [ %g2 + 0x14 ]
&the_iterator->Registry_node
);
the_iterator->direction = direction;
if ( direction == CHAIN_ITERATOR_FORWARD ) {
4000bf74: 80 a6 a0 00 cmp %i2, 0
the_node->next = tail;
4000bf78: de 27 bf ec st %o7, [ %fp + -20 ]
old_last->next = the_node;
4000bf7c: c6 21 00 00 st %g3, [ %g4 ]
the_node->previous = old_last;
4000bf80: c8 27 bf f0 st %g4, [ %fp + -16 ]
if ( direction == CHAIN_ITERATOR_FORWARD ) {
4000bf84: 02 80 00 03 be 4000bf90 <_User_extensions_Iterate+0x98>
4000bf88: f4 27 bf f4 st %i2, [ %fp + -12 ]
the_iterator->position = _Chain_Head( the_chain );
} else {
the_iterator->position = _Chain_Tail( the_chain );
4000bf8c: 84 00 a0 04 add %g2, 4, %g2
&_User_extensions_List.Iterators,
&iter.Iterator,
direction
);
if ( executing != NULL ) {
4000bf90: 80 a7 20 00 cmp %i4, 0
4000bf94: 02 80 00 05 be 4000bfa8 <_User_extensions_Iterate+0xb0>
4000bf98: c4 27 bf f8 st %g2, [ %fp + -8 ]
iter.previous = executing->last_user_extensions_iterator;
4000bf9c: c4 07 21 88 ld [ %i4 + 0x188 ], %g2
4000bfa0: c4 27 bf fc st %g2, [ %fp + -4 ]
executing->last_user_extensions_iterator = &iter;
4000bfa4: c6 27 21 88 st %g3, [ %i4 + 0x188 ]
end = _Chain_Immutable_head( &_User_extensions_List.Active );
4000bfa8: 10 80 00 0f b 4000bfe4 <_User_extensions_Iterate+0xec>
4000bfac: 84 10 00 1a mov %i2, %g2
4000bfb0: d4 00 c0 00 ld [ %g3 ], %o2
}
while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) {
4000bfb4: 80 a6 c0 0a cmp %i3, %o2
4000bfb8: 02 80 00 13 be 4000c004 <_User_extensions_Iterate+0x10c>
4000bfbc: 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;
4000bfc0: d4 27 bf f8 st %o2, [ %fp + -8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000bfc4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000bfc8: 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 );
4000bfcc: 94 02 a0 14 add %o2, 0x14, %o2
4000bfd0: 92 10 00 18 mov %i0, %o1
4000bfd4: 9f c6 40 00 call %i1
4000bfd8: 90 10 00 1c mov %i4, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000bfdc: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable_and_acquire(
4000bfe0: c4 07 bf f4 ld [ %fp + -12 ], %g2
if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) {
4000bfe4: 80 a0 a0 00 cmp %g2, 0
4000bfe8: 02 bf ff f2 be 4000bfb0 <_User_extensions_Iterate+0xb8>
4000bfec: c6 07 bf f8 ld [ %fp + -8 ], %g3
4000bff0: d4 00 e0 04 ld [ %g3 + 4 ], %o2
while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) {
4000bff4: 80 a6 c0 0a cmp %i3, %o2
4000bff8: 32 bf ff f3 bne,a 4000bfc4 <_User_extensions_Iterate+0xcc>
4000bffc: d4 27 bf f8 st %o2, [ %fp + -8 ]
_User_extensions_Acquire( &lock_context );
}
if ( executing != NULL ) {
4000c000: 80 a7 20 00 cmp %i4, 0
4000c004: 02 80 00 03 be 4000c010 <_User_extensions_Iterate+0x118>
4000c008: c4 07 bf fc ld [ %fp + -4 ], %g2
executing->last_user_extensions_iterator = iter.previous;
4000c00c: c4 27 21 88 st %g2, [ %i4 + 0x188 ]
<== NOT EXECUTED
next = the_node->next;
4000c010: c6 07 bf ec ld [ %fp + -20 ], %g3
<== NOT EXECUTED
previous = the_node->previous;
4000c014: c4 07 bf f0 ld [ %fp + -16 ], %g2
<== NOT EXECUTED
next->previous = previous;
4000c018: c4 20 e0 04 st %g2, [ %g3 + 4 ]
<== NOT EXECUTED
previous->next = next;
4000c01c: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c020: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c024: 01 00 00 00 nop
_Chain_Iterator_destroy( &iter.Iterator );
_User_extensions_Release( &lock_context );
if ( direction == CHAIN_ITERATOR_BACKWARD ) {
4000c028: 80 a6 a0 01 cmp %i2, 1
4000c02c: 02 80 00 09 be 4000c050 <_User_extensions_Iterate+0x158>
4000c030: 80 a4 00 1d cmp %l0, %i5
while ( initial_current != initial_begin ) {
--initial_current;
(*visitor)( executing, arg, initial_current );
}
}
}
4000c034: 81 c7 e0 08 ret
4000c038: 81 e8 00 00 restore
(*visitor)( executing, arg, initial_current );
4000c03c: 92 10 00 18 mov %i0, %o1
4000c040: 94 10 00 1d mov %i5, %o2
4000c044: 9f c6 40 00 call %i1
4000c048: 90 10 00 1c mov %i4, %o0
while ( initial_current != initial_begin ) {
4000c04c: 80 a4 00 1d cmp %l0, %i5
4000c050: 12 bf ff fb bne 4000c03c <_User_extensions_Iterate+0x144>
4000c054: ba 07 7f dc add %i5, -36, %i5
}
4000c058: 81 c7 e0 08 ret
4000c05c: 81 e8 00 00 restore
end = _Chain_Immutable_head( &_User_extensions_List.Active );
4000c060: 05 10 00 48 sethi %hi(0x40012000), %g2
4000c064: 84 10 a0 40 or %g2, 0x40, %g2 ! 40012040 <_User_extensions_List>
4000c068: 10 bf ff be b 4000bf60 <_User_extensions_Iterate+0x68>
4000c06c: b6 10 00 02 mov %g2, %i3
40015ca8 <_User_extensions_Remove_set>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40015ca8: 91 d0 20 09 ta 9
<== NOT EXECUTED
iter_node = _Chain_Head( &the_registry->Iterators );
40015cac: 05 10 00 cb sethi %hi(0x40032c00), %g2
<== NOT EXECUTED
40015cb0: 84 10 a2 d0 or %g2, 0x2d0, %g2 ! 40032ed0 <_User_extensions_List+0xc>
<== NOT EXECUTED
40015cb4: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
40015cb8: c4 00 80 00 ld [ %g2 ], %g2
<== NOT EXECUTED
while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
40015cbc: 80 a0 80 04 cmp %g2, %g4
<== NOT EXECUTED
40015cc0: 22 80 00 11 be,a 40015d04 <_User_extensions_Remove_set+0x5c>
<== NOT EXECUTED
40015cc4: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
if ( iter->position == the_node_to_extract ) {
40015cc8: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
<== NOT EXECUTED
40015ccc: 80 a2 00 03 cmp %o0, %g3
<== NOT EXECUTED
40015cd0: 32 bf ff fb bne,a 40015cbc <_User_extensions_Remove_set+0x14>
<== NOT EXECUTED
40015cd4: c4 00 80 00 ld [ %g2 ], %g2
<== NOT EXECUTED
if ( iter->direction == CHAIN_ITERATOR_FORWARD ) {
40015cd8: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
40015cdc: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40015ce0: 32 80 00 1b bne,a 40015d4c <_User_extensions_Remove_set+0xa4>
<== NOT EXECUTED
40015ce4: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
40015ce8: c6 02 20 04 ld [ %o0 + 4 ], %g3
<== NOT EXECUTED
iter->position = _Chain_Previous( the_node_to_extract );
40015cec: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
<== NOT EXECUTED
40015cf0: c4 00 80 00 ld [ %g2 ], %g2
<== NOT EXECUTED
while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
40015cf4: 80 a0 80 04 cmp %g2, %g4
<== NOT EXECUTED
40015cf8: 32 bf ff f5 bne,a 40015ccc <_User_extensions_Remove_set+0x24>
<== NOT EXECUTED
40015cfc: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
<== NOT EXECUTED
next = the_node->next;
40015d00: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
previous = the_node->previous;
40015d04: c4 02 20 04 ld [ %o0 + 4 ], %g2
<== NOT EXECUTED
next->previous = previous;
40015d08: c4 20 e0 04 st %g2, [ %g3 + 4 ]
<== NOT EXECUTED
previous->next = next;
40015d0c: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40015d10: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40015d14: 01 00 00 00 nop
<== NOT EXECUTED
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL ) {
40015d18: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
<== NOT EXECUTED
40015d1c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40015d20: 02 80 00 09 be 40015d44 <_User_extensions_Remove_set+0x9c>
<== NOT EXECUTED
40015d24: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40015d28: 91 d0 20 09 ta 9
<== NOT EXECUTED
next = the_node->next;
40015d2c: c6 02 20 08 ld [ %o0 + 8 ], %g3
<== NOT EXECUTED
previous = the_node->previous;
40015d30: c4 02 20 0c ld [ %o0 + 0xc ], %g2
<== NOT EXECUTED
next->previous = previous;
40015d34: c4 20 e0 04 st %g2, [ %g3 + 4 ]
<== NOT EXECUTED
previous->next = next;
40015d38: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40015d3c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40015d40: 01 00 00 00 nop
<== NOT EXECUTED
_Per_CPU_Acquire_all( level );
_Chain_Extract_unprotected( &the_extension->Switch.Node );
_Per_CPU_Release_all( level );
}
}
40015d44: 81 c3 e0 08 retl
<== NOT EXECUTED
40015d48: 01 00 00 00 nop
<== NOT EXECUTED
iter->position = _Chain_Next( the_node_to_extract );
40015d4c: 10 bf ff db b 40015cb8 <_User_extensions_Remove_set+0x10>
<== NOT EXECUTED
40015d50: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
<== NOT EXECUTED
4000be60 <_User_extensions_Thread_begin_visitor>:
void _User_extensions_Thread_begin_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
4000be60: 9d e3 bf a0 save %sp, -96, %sp
User_extensions_thread_begin_extension callout = callouts->thread_begin;
4000be64: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1
if ( callout != NULL ) {
4000be68: 80 a0 60 00 cmp %g1, 0
4000be6c: 02 80 00 04 be 4000be7c <_User_extensions_Thread_begin_visitor+0x1c>
<== ALWAYS TAKEN
4000be70: 01 00 00 00 nop
(*callout)( executing );
4000be74: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000be78: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
}
4000be7c: 81 c7 e0 08 ret
4000be80: 81 e8 00 00 restore
4000bdb8 <_User_extensions_Thread_create_visitor>:
void _User_extensions_Thread_create_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
4000bdb8: 9d e3 bf a0 save %sp, -96, %sp
User_extensions_thread_create_extension callout = callouts->thread_create;
4000bdbc: c4 06 80 00 ld [ %i2 ], %g2
if ( callout != NULL ) {
4000bdc0: 80 a0 a0 00 cmp %g2, 0
4000bdc4: 02 80 00 0a be 4000bdec <_User_extensions_Thread_create_visitor+0x34>
4000bdc8: 01 00 00 00 nop
User_extensions_Thread_create_context *ctx = arg;
ctx->ok = ctx->ok && (*callout)( executing, ctx->created );
4000bdcc: d0 0e 60 04 ldub [ %i1 + 4 ], %o0
4000bdd0: 80 8a 20 ff btst 0xff, %o0
4000bdd4: 22 80 00 06 be,a 4000bdec <_User_extensions_Thread_create_visitor+0x34>
<== NEVER TAKEN
4000bdd8: d0 2e 60 04 stb %o0, [ %i1 + 4 ]
<== NOT EXECUTED
4000bddc: d2 06 40 00 ld [ %i1 ], %o1
4000bde0: 9f c0 80 00 call %g2
4000bde4: 90 10 00 18 mov %i0, %o0
4000bde8: d0 2e 60 04 stb %o0, [ %i1 + 4 ]
}
}
4000bdec: 81 c7 e0 08 ret
4000bdf0: 81 e8 00 00 restore
4000bdf4 <_User_extensions_Thread_delete_visitor>:
void _User_extensions_Thread_delete_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
4000bdf4: 9d e3 bf a0 save %sp, -96, %sp
User_extensions_thread_delete_extension callout = callouts->thread_delete;
4000bdf8: c2 06 a0 0c ld [ %i2 + 0xc ], %g1
if ( callout != NULL ) {
4000bdfc: 80 a0 60 00 cmp %g1, 0
4000be00: 02 80 00 04 be 4000be10 <_User_extensions_Thread_delete_visitor+0x1c>
<== ALWAYS TAKEN
4000be04: 92 10 00 19 mov %i1, %o1
(*callout)( executing, arg );
4000be08: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000be0c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
}
4000be10: 81 c7 e0 08 ret
4000be14: 81 e8 00 00 restore
4000be84 <_User_extensions_Thread_exitted_visitor>:
void _User_extensions_Thread_exitted_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
4000be84: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
User_extensions_thread_exitted_extension callout = callouts->thread_exitted;
4000be88: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
<== NOT EXECUTED
if ( callout != NULL ) {
4000be8c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000be90: 02 80 00 04 be 4000bea0 <_User_extensions_Thread_exitted_visitor+0x1c>
<== NOT EXECUTED
4000be94: 01 00 00 00 nop
<== NOT EXECUTED
(*callout)( executing );
4000be98: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000be9c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
}
4000bea0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000bea4: 81 e8 00 00 restore
<== NOT EXECUTED
4000be3c <_User_extensions_Thread_restart_visitor>:
void _User_extensions_Thread_restart_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
4000be3c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
User_extensions_thread_restart_extension callout = callouts->thread_restart;
4000be40: c2 06 a0 08 ld [ %i2 + 8 ], %g1
<== NOT EXECUTED
if ( callout != NULL ) {
4000be44: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000be48: 02 80 00 04 be 4000be58 <_User_extensions_Thread_restart_visitor+0x1c>
<== NOT EXECUTED
4000be4c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
(*callout)( executing, arg );
4000be50: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000be54: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
}
4000be58: 81 c7 e0 08 ret
<== NOT EXECUTED
4000be5c: 81 e8 00 00 restore
<== NOT EXECUTED
4000c16c <_Watchdog_Do_tickle>:
#ifdef RTEMS_SMP
ISR_lock_Control *lock,
#endif
ISR_lock_Context *lock_context
)
{
4000c16c: 9d e3 bf a0 save %sp, -96, %sp
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
4000c170: ba 10 20 02 mov 2, %i5
do {
if ( first->expire <= now ) {
4000c174: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
4000c178: 80 a0 40 1a cmp %g1, %i2
4000c17c: 18 80 00 26 bgu 4000c214 <_Watchdog_Do_tickle+0xa8>
<== NEVER TAKEN
4000c180: 01 00 00 00 nop
4000c184: 22 80 00 21 be,a 4000c208 <_Watchdog_Do_tickle+0x9c>
<== ALWAYS TAKEN
4000c188: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4000c18c: c4 06 60 04 ld [ %i1 + 4 ], %g2
<== NOT EXECUTED
if ( node != NULL ) {
4000c190: 80 a0 a0 00 cmp %g2, 0
4000c194: 32 80 00 05 bne,a 4000c1a8 <_Watchdog_Do_tickle+0x3c>
4000c198: c2 00 80 00 ld [ %g2 ], %g1
4000c19c: 10 80 00 19 b 4000c200 <_Watchdog_Do_tickle+0x94>
4000c1a0: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000c1a4: c2 00 80 00 ld [ %g2 ], %g1
<== NOT EXECUTED
while ( ( left = _RBTree_Left( node ) ) != NULL ) {
4000c1a8: 80 a0 60 00 cmp %g1, 0
4000c1ac: 32 bf ff fe bne,a 4000c1a4 <_Watchdog_Do_tickle+0x38>
<== NEVER TAKEN
4000c1b0: 84 10 00 01 mov %g1, %g2
<== NOT EXECUTED
header->first = node;
4000c1b4: 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 );
4000c1b8: 92 10 00 19 mov %i1, %o1
4000c1bc: 7f ff f3 85 call 40008fd0 <_RBTree_Extract>
4000c1c0: 90 10 00 18 mov %i0, %o0
_Watchdog_Set_state( first, WATCHDOG_INACTIVE );
routine = first->routine;
4000c1c4: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
<== NOT EXECUTED
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
4000c1c8: fa 26 60 0c st %i5, [ %i1 + 0xc ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000c1cc: c2 07 00 00 ld [ %i4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c1d0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c1d4: 01 00 00 00 nop
_ISR_lock_Release_and_ISR_enable( lock, lock_context );
( *routine )( first );
4000c1d8: 9f c0 80 00 call %g2
4000c1dc: 90 10 00 19 mov %i1, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000c1e0: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable_and_acquire( lock, lock_context );
4000c1e4: c2 27 00 00 st %g1, [ %i4 ]
4000c1e8: f2 06 20 04 ld [ %i0 + 4 ], %i1
} else {
break;
}
first = _Watchdog_Header_first( header );
} while ( first != NULL );
4000c1ec: 80 a6 60 00 cmp %i1, 0
4000c1f0: 32 bf ff e2 bne,a 4000c178 <_Watchdog_Do_tickle+0xc>
4000c1f4: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
}
4000c1f8: 81 c7 e0 08 ret
4000c1fc: 81 e8 00 00 restore
header->first = _RBTree_Parent( &the_watchdog->Node.RBTree );
4000c200: 10 bf ff ee b 4000c1b8 <_Watchdog_Do_tickle+0x4c>
4000c204: c2 26 20 04 st %g1, [ %i0 + 4 ]
if ( first->expire <= now ) {
4000c208: 80 a0 40 1b cmp %g1, %i3
4000c20c: 28 bf ff e1 bleu,a 4000c190 <_Watchdog_Do_tickle+0x24>
4000c210: c4 06 60 04 ld [ %i1 + 4 ], %g2
}
4000c214: 81 c7 e0 08 ret
4000c218: 81 e8 00 00 restore
40015d54 <_Watchdog_Insert>:
_Assert( _Watchdog_Get_state( the_watchdog ) == WATCHDOG_INACTIVE );
link = _RBTree_Root_reference( &header->Watchdogs );
parent = NULL;
old_first = header->first;
40015d54: d8 02 20 04 ld [ %o0 + 4 ], %o4
new_first = &the_watchdog->Node.RBTree;
the_watchdog->expire = expire;
40015d58: d4 22 60 18 st %o2, [ %o1 + 0x18 ]
link = _RBTree_Root_reference( &header->Watchdogs );
40015d5c: 84 10 00 08 mov %o0, %g2
the_watchdog->expire = expire;
40015d60: d6 22 60 1c st %o3, [ %o1 + 0x1c ]
{
40015d64: 86 10 00 09 mov %o1, %g3
while ( *link != NULL ) {
40015d68: c2 00 80 00 ld [ %g2 ], %g1
new_first = &the_watchdog->Node.RBTree;
40015d6c: 9a 10 00 09 mov %o1, %o5
while ( *link != NULL ) {
40015d70: 80 a0 60 00 cmp %g1, 0
40015d74: 02 80 00 12 be 40015dbc <_Watchdog_Insert+0x68>
40015d78: 88 10 20 00 clr %g4
Watchdog_Control *parent_watchdog;
parent = *link;
parent_watchdog = (Watchdog_Control *) parent;
if ( expire < parent_watchdog->expire ) {
40015d7c: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
40015d80: 80 a0 80 0a cmp %g2, %o2
40015d84: 18 80 00 09 bgu 40015da8 <_Watchdog_Insert+0x54>
<== NEVER TAKEN
40015d88: 84 10 00 01 mov %g1, %g2
40015d8c: 12 80 00 17 bne 40015de8 <_Watchdog_Insert+0x94>
<== NEVER TAKEN
40015d90: 84 00 60 04 add %g1, 4, %g2
40015d94: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
40015d98: 80 a0 80 0b cmp %g2, %o3
40015d9c: 08 80 00 13 bleu 40015de8 <_Watchdog_Insert+0x94>
40015da0: 84 00 60 04 add %g1, 4, %g2
return &RB_LEFT( the_node, Node );
40015da4: 84 10 00 01 mov %g1, %g2
link = _RBTree_Left_reference( parent );
} else {
link = _RBTree_Right_reference( parent );
new_first = old_first;
40015da8: 88 10 00 01 mov %g1, %g4
while ( *link != NULL ) {
40015dac: c2 00 80 00 ld [ %g2 ], %g1
40015db0: 80 a0 60 00 cmp %g1, 0
40015db4: 32 bf ff f3 bne,a 40015d80 <_Watchdog_Insert+0x2c>
40015db8: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
}
}
header->first = new_first;
40015dbc: da 22 20 04 st %o5, [ %o0 + 4 ]
RB_SET( child, parent, Node );
40015dc0: 82 10 20 01 mov 1, %g1
40015dc4: 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 );
40015dc8: 92 10 00 03 mov %g3, %o1
40015dcc: c0 20 e0 04 clr [ %g3 + 4 ]
40015dd0: c0 20 c0 00 clr [ %g3 ]
40015dd4: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
*link = child;
40015dd8: c6 20 80 00 st %g3, [ %g2 ]
40015ddc: 82 13 c0 00 mov %o7, %g1
40015de0: 7f ff f1 7d call 400123d4 <_RBTree_Insert_color>
40015de4: 9e 10 40 00 mov %g1, %o7
new_first = old_first;
40015de8: 9a 10 00 0c mov %o4, %o5
40015dec: 10 bf ff f0 b 40015dac <_Watchdog_Insert+0x58>
40015df0: 88 10 00 01 mov %g1, %g4
4000c0f4 <_Watchdog_Remove>:
void _Watchdog_Remove(
Watchdog_Header *header,
Watchdog_Control *the_watchdog
)
{
4000c0f4: 9d e3 bf a0 save %sp, -96, %sp
if ( _Watchdog_Is_scheduled( the_watchdog ) ) {
4000c0f8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000c0fc: 80 a0 60 01 cmp %g1, 1
4000c100: 28 80 00 04 bleu,a 4000c110 <_Watchdog_Remove+0x1c>
4000c104: c2 06 20 04 ld [ %i0 + 4 ], %g1
}
_RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree );
_Watchdog_Set_state( the_watchdog, WATCHDOG_INACTIVE );
}
}
4000c108: 81 c7 e0 08 ret
4000c10c: 81 e8 00 00 restore
if ( header->first == &the_watchdog->Node.RBTree ) {
4000c110: 80 a0 40 19 cmp %g1, %i1
4000c114: 22 80 00 09 be,a 4000c138 <_Watchdog_Remove+0x44>
4000c118: c4 06 60 04 ld [ %i1 + 4 ], %g2
_RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree );
4000c11c: 92 10 00 19 mov %i1, %o1
4000c120: 7f ff f3 ac call 40008fd0 <_RBTree_Extract>
4000c124: 90 10 00 18 mov %i0, %o0
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
4000c128: 82 10 20 02 mov 2, %g1
4000c12c: c2 26 60 0c st %g1, [ %i1 + 0xc ]
}
4000c130: 81 c7 e0 08 ret
4000c134: 81 e8 00 00 restore
if ( node != NULL ) {
4000c138: 80 a0 a0 00 cmp %g2, 0
4000c13c: 32 80 00 05 bne,a 4000c150 <_Watchdog_Remove+0x5c>
4000c140: c2 00 80 00 ld [ %g2 ], %g1
4000c144: 10 80 00 08 b 4000c164 <_Watchdog_Remove+0x70>
4000c148: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000c14c: c2 00 80 00 ld [ %g2 ], %g1
<== NOT EXECUTED
while ( ( left = _RBTree_Left( node ) ) != NULL ) {
4000c150: 80 a0 60 00 cmp %g1, 0
4000c154: 32 bf ff fe bne,a 4000c14c <_Watchdog_Remove+0x58>
<== NEVER TAKEN
4000c158: 84 10 00 01 mov %g1, %g2
<== NOT EXECUTED
header->first = node;
4000c15c: 10 bf ff f0 b 4000c11c <_Watchdog_Remove+0x28>
4000c160: c4 26 20 04 st %g2, [ %i0 + 4 ]
header->first = _RBTree_Parent( &the_watchdog->Node.RBTree );
4000c164: 10 bf ff ee b 4000c11c <_Watchdog_Remove+0x28>
4000c168: c2 26 20 04 st %g1, [ %i0 + 4 ]
4000c21c <_Watchdog_Tick>:
void _Watchdog_Tick( Per_CPU_Control *cpu )
{
4000c21c: 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;
4000c220: 05 10 00 4e sethi %hi(0x40013800), %g2
<== NOT EXECUTED
4000c224: c2 00 a2 1c ld [ %g2 + 0x21c ], %g1 ! 40013a1c <_Watchdog_Ticks_since_boot>
<== NOT EXECUTED
4000c228: 82 00 60 01 inc %g1
<== NOT EXECUTED
4000c22c: c2 20 a2 1c st %g1, [ %g2 + 0x21c ]
<== NOT EXECUTED
4000c230: 91 d0 20 09 ta 9
<== NOT EXECUTED
}
_ISR_lock_ISR_disable_and_acquire( &cpu->Watchdog.Lock, &lock_context );
4000c234: c2 27 bf ec st %g1, [ %fp + -20 ]
ticks = cpu->Watchdog.ticks;
4000c238: c4 1e 20 30 ldd [ %i0 + 0x30 ], %g2
_Assert( ticks < UINT64_MAX );
++ticks;
4000c23c: 96 80 e0 01 addcc %g3, 1, %o3
4000c240: 94 40 a0 00 addx %g2, 0, %o2
cpu->Watchdog.ticks = ticks;
4000c244: d4 3e 20 30 std %o2, [ %i0 + 0x30 ]
4000c248: d2 06 20 3c ld [ %i0 + 0x3c ], %o1
header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ];
first = _Watchdog_Header_first( header );
if ( first != NULL ) {
4000c24c: 80 a2 60 00 cmp %o1, 0
4000c250: 02 80 00 04 be 4000c260 <_Watchdog_Tick+0x44>
4000c254: 98 07 bf ec add %fp, -20, %o4
_Watchdog_Tickle(
4000c258: 7f ff ff c5 call 4000c16c <_Watchdog_Do_tickle>
4000c25c: 90 06 20 38 add %i0, 0x38, %o0
4000c260: fa 06 20 4c ld [ %i0 + 0x4c ], %i5
}
header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_MONOTONIC ];
first = _Watchdog_Header_first( header );
if ( first != NULL ) {
4000c264: 80 a7 60 00 cmp %i5, 0
4000c268: 22 80 00 11 be,a 4000c2ac <_Watchdog_Tick+0x90>
4000c26c: fa 06 20 44 ld [ %i0 + 0x44 ], %i5
_Timecounter_Getnanouptime( &now );
4000c270: 7f ff f0 7a call 40008458 <_Timecounter_Getnanouptime>
4000c274: 90 07 bf f0 add %fp, -16, %o0
ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS;
4000c278: c2 07 bf f0 ld [ %fp + -16 ], %g1
ticks = (uint64_t) ts->tv_sec;
4000c27c: d6 07 bf f4 ld [ %fp + -12 ], %o3
ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS;
4000c280: 83 28 60 1e sll %g1, 0x1e, %g1
4000c284: 95 32 e0 02 srl %o3, 2, %o2
_Watchdog_Tickle(
4000c288: 94 12 80 01 or %o2, %g1, %o2
4000c28c: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000c290: 97 2a e0 1e sll %o3, 0x1e, %o3
4000c294: 98 07 bf ec add %fp, -20, %o4
4000c298: 96 10 40 0b or %g1, %o3, %o3
4000c29c: 92 10 00 1d mov %i5, %o1
4000c2a0: 7f ff ff b3 call 4000c16c <_Watchdog_Do_tickle>
4000c2a4: 90 06 20 48 add %i0, 0x48, %o0
4000c2a8: fa 06 20 44 ld [ %i0 + 0x44 ], %i5
}
header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_REALTIME ];
first = _Watchdog_Header_first( header );
if ( first != NULL ) {
4000c2ac: 80 a7 60 00 cmp %i5, 0
4000c2b0: 02 80 00 10 be 4000c2f0 <_Watchdog_Tick+0xd4>
<== ALWAYS TAKEN
4000c2b4: 01 00 00 00 nop
_Timecounter_Getnanotime( &now );
4000c2b8: 7f ff f0 8e call 400084f0 <_Timecounter_Getnanotime>
<== NOT EXECUTED
4000c2bc: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
4000c2c0: c2 07 bf f0 ld [ %fp + -16 ], %g1
<== NOT EXECUTED
ticks = (uint64_t) ts->tv_sec;
4000c2c4: d6 07 bf f4 ld [ %fp + -12 ], %o3
<== NOT EXECUTED
ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS;
4000c2c8: 83 28 60 1e sll %g1, 0x1e, %g1
<== NOT EXECUTED
4000c2cc: 95 32 e0 02 srl %o3, 2, %o2
<== NOT EXECUTED
_Watchdog_Tickle(
4000c2d0: 94 12 80 01 or %o2, %g1, %o2
<== NOT EXECUTED
4000c2d4: c2 07 bf f8 ld [ %fp + -8 ], %g1
<== NOT EXECUTED
4000c2d8: 97 2a e0 1e sll %o3, 0x1e, %o3
<== NOT EXECUTED
4000c2dc: 98 07 bf ec add %fp, -20, %o4
<== NOT EXECUTED
4000c2e0: 96 10 40 0b or %g1, %o3, %o3
<== NOT EXECUTED
4000c2e4: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000c2e8: 7f ff ff a1 call 4000c16c <_Watchdog_Do_tickle>
<== NOT EXECUTED
4000c2ec: 90 06 20 40 add %i0, 0x40, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000c2f0: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c2f4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c2f8: 01 00 00 00 nop
Thread_Control *executing = cpu->executing;
4000c2fc: d2 06 20 20 ld [ %i0 + 0x20 ], %o1
if ( scheduler != NULL && executing != NULL ) {
4000c300: 80 a2 60 00 cmp %o1, 0
4000c304: 02 80 00 06 be 4000c31c <_Watchdog_Tick+0x100>
<== NEVER TAKEN
4000c308: 11 10 00 3f sethi %hi(0x4000fc00), %o0
( *scheduler->Operations.tick )( scheduler, executing );
4000c30c: 90 12 23 10 or %o0, 0x310, %o0 ! 4000ff10 <_Scheduler_Table>
4000c310: c2 02 20 34 ld [ %o0 + 0x34 ], %g1
4000c314: 9f c0 40 00 call %g1
4000c318: 01 00 00 00 nop
}
_ISR_lock_Release_and_ISR_enable( &cpu->Watchdog.Lock, &lock_context );
_Scheduler_Tick( cpu );
}
4000c31c: 81 c7 e0 08 ret
4000c320: 81 e8 00 00 restore
4000c500 <_Workspace_Allocate_aligned>:
return _Heap_Allocate_aligned_with_boundary( heap, size, alignment, 0 );
4000c500: 94 10 00 09 mov %o1, %o2
<== NOT EXECUTED
4000c504: 96 10 20 00 clr %o3
<== NOT EXECUTED
4000c508: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
4000c50c: 11 10 00 4e sethi %hi(0x40013800), %o0
<== NOT EXECUTED
4000c510: 90 12 22 20 or %o0, 0x220, %o0 ! 40013a20 <_Workspace_Area>
<== NOT EXECUTED
4000c514: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000c518: 7f ff e9 ce call 40006c50 <_Heap_Allocate_aligned_with_boundary>
<== NOT EXECUTED
4000c51c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000c538 <_Workspace_Allocate_or_fatal_error>:
}
void *_Workspace_Allocate_or_fatal_error(
size_t size
)
{
4000c538: 9d e3 bf a0 save %sp, -96, %sp
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
4000c53c: 96 10 20 00 clr %o3
4000c540: 94 10 20 00 clr %o2
4000c544: 92 10 00 18 mov %i0, %o1
4000c548: 11 10 00 4e sethi %hi(0x40013800), %o0
4000c54c: 7f ff e9 c1 call 40006c50 <_Heap_Allocate_aligned_with_boundary>
4000c550: 90 12 22 20 or %o0, 0x220, %o0 ! 40013a20 <_Workspace_Area>
__builtin_return_address( 1 ),
memory
);
#endif
if ( memory == NULL )
4000c554: 80 a2 20 00 cmp %o0, 0
4000c558: 02 80 00 04 be 4000c568 <_Workspace_Allocate_or_fatal_error+0x30>
<== NEVER TAKEN
4000c55c: b0 10 00 08 mov %o0, %i0
_Internal_error( INTERNAL_ERROR_WORKSPACE_ALLOCATION );
return memory;
}
4000c560: 81 c7 e0 08 ret
4000c564: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_WORKSPACE_ALLOCATION );
4000c568: 7f ff eb 61 call 400072ec <_Internal_error>
<== NOT EXECUTED
4000c56c: 90 10 20 03 mov 3, %o0
<== NOT EXECUTED
4000c570: 01 00 00 00 nop
<== NOT EXECUTED
...
4000c324 <_Workspace_Handler_initialization>:
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
4000c324: 9d e3 bf 98 save %sp, -104, %sp
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t remaining = rtems_configuration_get_work_space_size();
4000c328: 03 10 00 3f sethi %hi(0x4000fc00), %g1
4000c32c: 86 10 62 2c or %g1, 0x22c, %g3 ! 4000fe2c <Configuration>
4000c330: c4 08 e0 32 ldub [ %g3 + 0x32 ], %g2
4000c334: 80 a0 a0 00 cmp %g2, 0
4000c338: 12 80 00 04 bne 4000c348 <_Workspace_Handler_initialization+0x24>
<== NEVER TAKEN
4000c33c: f8 00 62 2c ld [ %g1 + 0x22c ], %i4
4000c340: c2 00 e0 04 ld [ %g3 + 4 ], %g1
4000c344: b8 07 00 01 add %i4, %g1, %i4
bool do_zero = rtems_configuration_get_do_zero_of_workspace();
4000c348: c8 08 e0 30 ldub [ %g3 + 0x30 ], %g4
bool unified = rtems_configuration_get_unified_work_area();
4000c34c: c6 08 e0 31 ldub [ %g3 + 0x31 ], %g3
bool do_zero = rtems_configuration_get_do_zero_of_workspace();
4000c350: c8 2f bf ff stb %g4, [ %fp + -1 ]
return (uintptr_t) _TLS_BSS_end - (uintptr_t) _TLS_Data_begin;
4000c354: 03 10 00 43 sethi %hi(0x40010c00), %g1
4000c358: 82 10 61 00 or %g1, 0x100, %g1 ! 40010d00 <_Linker_set__Sysinit_bsp_work_area_initialize>
4000c35c: 05 10 00 43 sethi %hi(0x40010c00), %g2
4000c360: 84 10 a1 00 or %g2, 0x100, %g2 ! 40010d00 <_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 ) {
4000c364: 82 a0 40 02 subcc %g1, %g2, %g1
4000c368: 02 80 00 1b be 4000c3d4 <_Workspace_Handler_initialization+0xb0>
<== ALWAYS TAKEN
4000c36c: c6 2f bf fe stb %g3, [ %fp + -2 ]
return (val + msk) & ~msk;
4000c370: 05 00 00 00 sethi %hi(0), %g2
<== NOT EXECUTED
4000c374: 84 10 a0 01 or %g2, 1, %g2 ! 1 <_TLS_Alignment>
<== NOT EXECUTED
4000c378: 84 00 a0 07 add %g2, 7, %g2
<== NOT EXECUTED
4000c37c: 84 08 bf f8 and %g2, -8, %g2
<== NOT EXECUTED
sizeof(TLS_Thread_control_block) : alignment;
4000c380: 80 a0 a0 08 cmp %g2, 8
<== NOT EXECUTED
4000c384: 2a 80 00 02 bcs,a 4000c38c <_Workspace_Handler_initialization+0x68>
<== NOT EXECUTED
4000c388: 84 10 20 08 mov 8, %g2
<== NOT EXECUTED
thread_count += rtems_resource_maximum_per_allocation(
4000c38c: 09 10 00 48 sethi %hi(0x40012000), %g4
<== NOT EXECUTED
if ( page_size < alignment ) {
page_size = alignment;
}
return HEAP_BLOCK_HEADER_SIZE + page_size - 1 + size;
4000c390: 85 28 a0 01 sll %g2, 1, %g2
<== NOT EXECUTED
4000c394: fa 01 22 20 ld [ %g4 + 0x220 ], %i5
<== NOT EXECUTED
4000c398: 07 10 00 47 sethi %hi(0x40011c00), %g3
<== NOT EXECUTED
4000c39c: c6 00 e1 84 ld [ %g3 + 0x184 ], %g3 ! 40011d84 <Configuration_RTEMS_API>
<== NOT EXECUTED
return (val + msk) & ~msk;
4000c3a0: 82 00 60 07 add %g1, 7, %g1
<== NOT EXECUTED
4000c3a4: 09 00 00 3f sethi %hi(0xfc00), %g4
<== NOT EXECUTED
4000c3a8: 82 08 7f f8 and %g1, -8, %g1
<== NOT EXECUTED
4000c3ac: 88 11 23 ff or %g4, 0x3ff, %g4
<== NOT EXECUTED
4000c3b0: 82 00 60 0f add %g1, 0xf, %g1
<== NOT EXECUTED
4000c3b4: 86 08 c0 04 and %g3, %g4, %g3
<== NOT EXECUTED
4000c3b8: 82 00 80 01 add %g2, %g1, %g1
<== NOT EXECUTED
4000c3bc: 84 0f 40 04 and %i5, %g4, %g2
<== NOT EXECUTED
4000c3c0: 84 00 c0 02 add %g3, %g2, %g2
<== NOT EXECUTED
4000c3c4: 84 00 a0 01 inc %g2
<== NOT EXECUTED
* size.
*/
remaining += _Heap_Min_block_size( page_size );
remaining += _Get_maximum_thread_count()
* _Heap_Size_with_overhead( page_size, tls_alloc, tls_align );
4000c3c8: 82 58 40 02 smul %g1, %g2, %g1
<== NOT EXECUTED
remaining += _Get_maximum_thread_count()
4000c3cc: 82 00 60 10 add %g1, 0x10, %g1
<== NOT EXECUTED
4000c3d0: b8 07 00 01 add %i4, %g1, %i4
<== NOT EXECUTED
}
for (i = 0; i < area_count; ++i) {
4000c3d4: 80 a6 60 00 cmp %i1, 0
4000c3d8: 02 80 00 2d be 4000c48c <_Workspace_Handler_initialization+0x168>
<== NEVER TAKEN
4000c3dc: 80 a7 20 00 cmp %i4, 0
4000c3e0: f6 0f bf ff ldub [ %fp + -1 ], %i3
if ( area->size > overhead ) {
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
4000c3e4: e2 0f bf fe ldub [ %fp + -2 ], %l1
4000c3e8: b3 2e 60 03 sll %i1, 3, %i1
for (i = 0; i < area_count; ++i) {
4000c3ec: 21 10 00 1b sethi %hi(0x40006c00), %l0
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
4000c3f0: 25 10 00 4e sethi %hi(0x40013800), %l2
4000c3f4: b2 06 00 19 add %i0, %i1, %i1
for (i = 0; i < area_count; ++i) {
4000c3f8: a0 14 23 c8 or %l0, 0x3c8, %l0
space_available = (*init_or_extend)(
4000c3fc: a4 14 a2 20 or %l2, 0x220, %l2
if ( do_zero ) {
4000c400: 80 a6 e0 00 cmp %i3, 0
4000c404: 12 80 00 26 bne 4000c49c <_Workspace_Handler_initialization+0x178>
4000c408: fa 06 20 04 ld [ %i0 + 4 ], %i5
if ( area->size > overhead ) {
4000c40c: 80 a7 60 16 cmp %i5, 0x16
4000c410: 28 80 00 1b bleu,a 4000c47c <_Workspace_Handler_initialization+0x158>
<== NEVER TAKEN
4000c414: b0 06 20 08 add %i0, 8, %i0
<== NOT EXECUTED
if ( unified ) {
4000c418: 80 a4 60 00 cmp %l1, 0
4000c41c: 12 80 00 09 bne 4000c440 <_Workspace_Handler_initialization+0x11c>
4000c420: d2 06 00 00 ld [ %i0 ], %o1
if ( remaining > 0 ) {
4000c424: 80 a7 20 00 cmp %i4, 0
4000c428: 02 80 00 23 be 4000c4b4 <_Workspace_Handler_initialization+0x190>
<== NEVER TAKEN
4000c42c: 96 10 20 08 mov 8, %o3
size = remaining < area->size - overhead ?
4000c430: 82 07 7f ea add %i5, -22, %g1
remaining + overhead : area->size;
4000c434: 80 a0 40 1c cmp %g1, %i4
4000c438: 38 80 00 02 bgu,a 4000c440 <_Workspace_Handler_initialization+0x11c>
<== ALWAYS TAKEN
4000c43c: ba 07 20 16 add %i4, 0x16, %i5
space_available = (*init_or_extend)(
4000c440: 94 10 00 1d mov %i5, %o2
4000c444: 96 10 20 08 mov 8, %o3
4000c448: 9f c4 00 00 call %l0
4000c44c: 90 10 00 12 mov %l2, %o0
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
4000c450: c4 06 00 00 ld [ %i0 ], %g2
area->size -= size;
4000c454: c2 06 20 04 ld [ %i0 + 4 ], %g1
area->begin = (char *) area->begin + size;
4000c458: 84 00 80 1d add %g2, %i5, %g2
area->size -= size;
4000c45c: ba 20 40 1d sub %g1, %i5, %i5
area->begin = (char *) area->begin + size;
4000c460: c4 26 00 00 st %g2, [ %i0 ]
if ( space_available < remaining ) {
4000c464: 80 a2 00 1c cmp %o0, %i4
4000c468: 1a 80 00 18 bcc 4000c4c8 <_Workspace_Handler_initialization+0x1a4>
<== ALWAYS TAKEN
4000c46c: fa 26 20 04 st %i5, [ %i0 + 4 ]
remaining -= space_available;
4000c470: b8 27 00 08 sub %i4, %o0, %i4
<== NOT EXECUTED
} else {
remaining = 0;
}
init_or_extend = extend;
4000c474: a0 10 00 1a mov %i2, %l0
<== NOT EXECUTED
4000c478: b0 06 20 08 add %i0, 8, %i0
for (i = 0; i < area_count; ++i) {
4000c47c: 80 a6 40 18 cmp %i1, %i0
4000c480: 12 bf ff e1 bne 4000c404 <_Workspace_Handler_initialization+0xe0>
<== NEVER TAKEN
4000c484: 80 a6 e0 00 cmp %i3, 0
}
}
if ( remaining > 0 ) {
4000c488: 80 a7 20 00 cmp %i4, 0
4000c48c: 12 80 00 12 bne 4000c4d4 <_Workspace_Handler_initialization+0x1b0>
<== NEVER TAKEN
4000c490: 01 00 00 00 nop
_Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE );
}
_Heap_Protection_set_delayed_free_fraction( &_Workspace_Area, 1 );
}
4000c494: 81 c7 e0 08 ret
4000c498: 81 e8 00 00 restore
memset( area->begin, 0, area->size );
4000c49c: d0 06 00 00 ld [ %i0 ], %o0
4000c4a0: 94 10 00 1d mov %i5, %o2
4000c4a4: 40 00 09 26 call 4000e93c <memset>
4000c4a8: 92 10 20 00 clr %o1
4000c4ac: 10 bf ff d8 b 4000c40c <_Workspace_Handler_initialization+0xe8>
4000c4b0: fa 06 20 04 ld [ %i0 + 4 ], %i5
space_available = (*init_or_extend)(
4000c4b4: 94 10 20 00 clr %o2
<== NOT EXECUTED
4000c4b8: 9f c4 00 00 call %l0
<== NOT EXECUTED
4000c4bc: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
init_or_extend = extend;
4000c4c0: 10 bf ff ee b 4000c478 <_Workspace_Handler_initialization+0x154>
<== NOT EXECUTED
4000c4c4: a0 10 00 1a mov %i2, %l0
<== NOT EXECUTED
4000c4c8: a0 10 00 1a mov %i2, %l0
remaining = 0;
4000c4cc: 10 bf ff eb b 4000c478 <_Workspace_Handler_initialization+0x154>
4000c4d0: b8 10 20 00 clr %i4
_Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE );
4000c4d4: 7f ff eb 86 call 400072ec <_Internal_error>
<== NOT EXECUTED
4000c4d8: 90 10 20 02 mov 2, %o0
<== NOT EXECUTED
4000c4dc: 01 00 00 00 nop
<== NOT EXECUTED