=============================================================================== 4001bc14 : 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 #include 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 <== 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 <== 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 <== 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 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 <== 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 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 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 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 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 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 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 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 <== 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 <== 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 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 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 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 #include 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 <== 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 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 #include 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 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 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 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 <== 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 #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 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 <== 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 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 * 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 <== 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 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 #include 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 #include 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 <== 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 <== 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 <== 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 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 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 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 <== 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 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 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 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 <== 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 <== 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 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 <== 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 <== 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 #include #include 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 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 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 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 <== 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 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