=============================================================================== 40007aa8 <_CORE_message_queue_Broadcast>: const void *buffer, size_t size, uint32_t *count, Thread_queue_Context *queue_context ) { 40007aa8: 9d e3 bf a0 save %sp, -96, %sp Thread_Control *the_thread; uint32_t number_broadcasted; if ( size > the_message_queue->maximum_message_size ) { 40007aac: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 40007ab0: 80 a0 40 1a cmp %g1, %i2 40007ab4: 0a 80 00 28 bcs 40007b54 <_CORE_message_queue_Broadcast+0xac> 40007ab8: 01 00 00 00 nop * * NOTE: This check is critical because threads can block on * send and receive and this ensures that we are broadcasting * the message to threads waiting to receive -- not to send. */ if ( the_message_queue->number_of_pending_messages != 0 ) { 40007abc: e0 06 20 14 ld [ %i0 + 0x14 ], %l0 40007ac0: 80 a4 20 00 cmp %l0, 0 40007ac4: 32 80 00 2b bne,a 40007b70 <_CORE_message_queue_Broadcast+0xc8> 40007ac8: a0 10 20 00 clr %l0 RTEMS_INLINE_ROUTINE Thread_Control *_Thread_queue_First_locked( Thread_queue_Control *the_thread_queue, const Thread_queue_Operations *operations ) { Thread_queue_Heads *heads = the_thread_queue->Queue.heads; 40007acc: d0 06 00 00 ld [ %i0 ], %o0 if ( heads != NULL ) { 40007ad0: 80 a2 20 00 cmp %o0, 0 40007ad4: 02 80 00 1a be 40007b3c <_CORE_message_queue_Broadcast+0x94> 40007ad8: c2 06 20 0c ld [ %i0 + 0xc ], %g1 return ( *operations->first )( heads ); 40007adc: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 40007ae0: 9f c0 40 00 call %g1 40007ae4: 01 00 00 00 nop memcpy(destination, source, size); 40007ae8: 92 10 00 19 mov %i1, %o1 */ the_thread = _Thread_queue_First_locked( &the_message_queue->Wait_queue, the_message_queue->operations ); if ( the_thread == NULL ) { 40007aec: ba 92 20 00 orcc %o0, 0, %i5 40007af0: 02 80 00 13 be 40007b3c <_CORE_message_queue_Broadcast+0x94> <== NEVER TAKEN 40007af4: 94 10 00 1a mov %i2, %o2 return NULL; } *(size_t *) the_thread->Wait.return_argument = size; 40007af8: c2 07 60 40 ld [ %i5 + 0x40 ], %g1 40007afc: f4 20 40 00 st %i2, [ %g1 ] 0, queue_context ) ) ) { number_broadcasted += 1; 40007b00: a0 04 20 01 inc %l0 the_thread->Wait.count = (uint32_t) submit_type; 40007b04: c0 27 60 3c clr [ %i5 + 0x3c ] memcpy(destination, source, size); 40007b08: 40 00 2c 96 call 40012d60 40007b0c: d0 07 60 44 ld [ %i5 + 0x44 ], %o0 buffer, the_thread->Wait.return_argument_second.mutable_object, size ); _Thread_queue_Extract_critical( 40007b10: d2 06 20 0c ld [ %i0 + 0xc ], %o1 40007b14: 96 10 00 1c mov %i4, %o3 40007b18: 94 10 00 1d mov %i5, %o2 40007b1c: 40 00 07 b9 call 40009a00 <_Thread_queue_Extract_critical> 40007b20: 90 10 00 18 mov %i0, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40007b24: 91 d0 20 09 ta 9 _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 40007b28: c2 27 00 00 st %g1, [ %i4 ] if ( the_message_queue->number_of_pending_messages != 0 ) { 40007b2c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40007b30: 80 a0 60 00 cmp %g1, 0 40007b34: 22 bf ff e7 be,a 40007ad0 <_CORE_message_queue_Broadcast+0x28> <== ALWAYS TAKEN 40007b38: d0 06 00 00 ld [ %i0 ], %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40007b3c: c2 07 00 00 ld [ %i4 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40007b40: 91 d0 20 0a ta 0xa 40007b44: 01 00 00 00 nop _CORE_message_queue_Acquire( the_message_queue, queue_context ); } _CORE_message_queue_Release( the_message_queue, queue_context ); *count = number_broadcasted; 40007b48: e0 26 c0 00 st %l0, [ %i3 ] return STATUS_SUCCESSFUL; } 40007b4c: 81 c7 e0 08 ret 40007b50: 91 e8 20 00 restore %g0, 0, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40007b54: c2 07 00 00 ld [ %i4 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40007b58: 91 d0 20 0a ta 0xa 40007b5c: 01 00 00 00 nop return STATUS_MESSAGE_INVALID_SIZE; 40007b60: 31 00 00 1e sethi %hi(0x7800), %i0 40007b64: b0 16 22 08 or %i0, 0x208, %i0 ! 7a08 <_ISR_Stack_size+0x6a08> 40007b68: 81 c7 e0 08 ret 40007b6c: 81 e8 00 00 restore register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40007b70: c2 07 00 00 ld [ %i4 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40007b74: 91 d0 20 0a ta 0xa 40007b78: 01 00 00 00 nop *count = number_broadcasted; 40007b7c: e0 26 c0 00 st %l0, [ %i3 ] } 40007b80: 81 c7 e0 08 ret 40007b84: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 4000e6ec <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Thread_queue_Context *queue_context ) { 4000e6ec: 9d e3 bf a0 save %sp, -96, %sp return _Chain_Immutable_head( the_chain )->next; 4000e6f0: e0 06 20 1c ld [ %i0 + 0x1c ], %l0 return &the_chain->Tail.Node; 4000e6f4: 82 06 20 20 add %i0, 0x20, %g1 if ( !_Chain_Is_empty(the_chain)) 4000e6f8: 80 a4 00 01 cmp %l0, %g1 4000e6fc: 02 80 00 32 be 4000e7c4 <_CORE_message_queue_Seize+0xd8> 4000e700: 86 06 20 1c add %i0, 0x1c, %g3 new_first = old_first->next; 4000e704: c4 04 00 00 ld [ %l0 ], %g2 head->next = new_first; 4000e708: c4 26 20 1c st %g2, [ %i0 + 0x1c ] const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 4000e70c: 92 04 20 10 add %l0, 0x10, %o1 CORE_message_queue_Buffer *the_message; the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { the_message_queue->number_of_pending_messages -= 1; 4000e710: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 new_first->previous = head; 4000e714: c6 20 a0 04 st %g3, [ %g2 + 4 ] 4000e718: 82 00 7f ff add %g1, -1, %g1 *size_p = the_message->size; 4000e71c: c4 04 20 08 ld [ %l0 + 8 ], %g2 the_message_queue->number_of_pending_messages -= 1; 4000e720: c2 26 20 14 st %g1, [ %i0 + 0x14 ] 4000e724: 90 10 00 1a mov %i2, %o0 *size_p = the_message->size; 4000e728: c4 26 c0 00 st %g2, [ %i3 ] executing->Wait.count = 4000e72c: c2 04 20 0c ld [ %l0 + 0xc ], %g1 4000e730: c2 26 60 3c st %g1, [ %i1 + 0x3c ] 4000e734: 40 00 2b 1b call 400193a0 4000e738: d4 06 c0 00 ld [ %i3 ], %o2 Thread_queue_Heads *heads = the_thread_queue->Queue.heads; 4000e73c: d0 06 00 00 ld [ %i0 ], %o0 if ( heads != NULL ) { 4000e740: 80 a2 20 00 cmp %o0, 0 4000e744: 02 80 00 15 be 4000e798 <_CORE_message_queue_Seize+0xac> 4000e748: c2 06 20 0c ld [ %i0 + 0xc ], %g1 return ( *operations->first )( heads ); 4000e74c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 4000e750: 9f c0 40 00 call %g1 4000e754: 01 00 00 00 nop */ the_thread = _Thread_queue_First_locked( &the_message_queue->Wait_queue, the_message_queue->operations ); if ( the_thread == NULL ) { 4000e758: b8 92 20 00 orcc %o0, 0, %i4 4000e75c: 02 80 00 0f be 4000e798 <_CORE_message_queue_Seize+0xac> <== NEVER TAKEN 4000e760: 92 10 00 10 mov %l0, %o1 /* * There was a thread waiting to send a message. This code * puts the messages in the message queue on behalf of the * waiting task. */ _CORE_message_queue_Insert_message( 4000e764: d8 07 20 3c ld [ %i4 + 0x3c ], %o4 4000e768: d6 07 20 48 ld [ %i4 + 0x48 ], %o3 4000e76c: d4 07 20 44 ld [ %i4 + 0x44 ], %o2 4000e770: 40 00 1a 5e call 400150e8 <_CORE_message_queue_Insert_message> 4000e774: 90 10 00 18 mov %i0, %o0 the_message, the_thread->Wait.return_argument_second.immutable_object, (size_t) the_thread->Wait.option, (CORE_message_queue_Submit_types) the_thread->Wait.count ); _Thread_queue_Extract_critical( 4000e778: d2 06 20 0c ld [ %i0 + 0xc ], %o1 4000e77c: 90 10 00 18 mov %i0, %o0 4000e780: 96 10 00 1d mov %i5, %o3 4000e784: 94 10 00 1c mov %i4, %o2 4000e788: 40 00 0d 0e call 40011bc0 <_Thread_queue_Extract_critical> 4000e78c: b0 10 20 00 clr %i0 &the_message_queue->Wait_queue.Queue, the_message_queue->operations, the_thread, queue_context ); return STATUS_SUCCESSFUL; 4000e790: 81 c7 e0 08 ret 4000e794: 81 e8 00 00 restore old_last = tail->previous; 4000e798: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 return &the_chain->Tail.Node; 4000e79c: 84 06 20 38 add %i0, 0x38, %g2 the_node->next = tail; 4000e7a0: c4 24 00 00 st %g2, [ %l0 ] tail->previous = the_node; 4000e7a4: e0 26 20 3c st %l0, [ %i0 + 0x3c ] old_last->next = the_node; 4000e7a8: e0 20 40 00 st %l0, [ %g1 ] the_node->previous = old_last; 4000e7ac: c2 24 20 04 st %g1, [ %l0 + 4 ] register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e7b0: c2 07 40 00 ld [ %i5 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e7b4: 91 d0 20 0a ta 0xa 4000e7b8: 01 00 00 00 nop return STATUS_SUCCESSFUL; 4000e7bc: 81 c7 e0 08 ret 4000e7c0: 91 e8 20 00 restore %g0, 0, %o0 } #endif } if ( !wait ) { 4000e7c4: 80 a7 20 00 cmp %i4, 0 4000e7c8: 02 80 00 0d be 4000e7fc <_CORE_message_queue_Seize+0x110> 4000e7cc: 82 10 20 10 mov 0x10, %g1 _CORE_message_queue_Release( the_message_queue, queue_context ); return STATUS_UNSATISFIED; } executing->Wait.return_argument_second.mutable_object = buffer; 4000e7d0: f4 26 60 44 st %i2, [ %i1 + 0x44 ] executing->Wait.return_argument = size_p; 4000e7d4: f6 26 60 40 st %i3, [ %i1 + 0x40 ] _Thread_queue_Context_set_thread_state( queue_context, STATES_WAITING_FOR_MESSAGE ); _Thread_queue_Enqueue( 4000e7d8: 90 10 00 18 mov %i0, %o0 queue_context->thread_state = thread_state; 4000e7dc: c2 27 60 04 st %g1, [ %i5 + 4 ] 4000e7e0: 96 10 00 1d mov %i5, %o3 4000e7e4: d2 06 20 0c ld [ %i0 + 0xc ], %o1 4000e7e8: 40 00 0c 8c call 40011a18 <_Thread_queue_Enqueue> 4000e7ec: 94 10 00 19 mov %i1, %o2 return (Status_Control) the_thread->Wait.return_code; 4000e7f0: f0 06 60 4c ld [ %i1 + 0x4c ], %i0 the_message_queue->operations, executing, queue_context ); return _Thread_Wait_get_status( executing ); } 4000e7f4: 81 c7 e0 08 ret 4000e7f8: 81 e8 00 00 restore register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e7fc: c2 07 40 00 ld [ %i5 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e800: 91 d0 20 0a ta 0xa 4000e804: 01 00 00 00 nop return STATUS_UNSATISFIED; 4000e808: 81 c7 e0 08 ret 4000e80c: 91 e8 2b 0d restore %g0, 0xb0d, %o0 =============================================================================== 4000e810 <_CORE_message_queue_Submit>: size_t size, CORE_message_queue_Submit_types submit_type, bool wait, Thread_queue_Context *queue_context ) { 4000e810: 9d e3 bf a0 save %sp, -96, %sp CORE_message_queue_Buffer *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 4000e814: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 4000e818: 80 a0 40 1b cmp %g1, %i3 4000e81c: 0a 80 00 35 bcs 4000e8f0 <_CORE_message_queue_Submit+0xe0> 4000e820: 01 00 00 00 nop * * NOTE: This check is critical because threads can block on * send and receive and this ensures that we are broadcasting * the message to threads waiting to receive -- not to send. */ if ( the_message_queue->number_of_pending_messages != 0 ) { 4000e824: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 4000e828: 80 a0 60 00 cmp %g1, 0 4000e82c: 32 80 00 1b bne,a 4000e898 <_CORE_message_queue_Submit+0x88> 4000e830: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 Thread_queue_Heads *heads = the_thread_queue->Queue.heads; 4000e834: d0 06 00 00 ld [ %i0 ], %o0 if ( heads != NULL ) { 4000e838: 80 a2 20 00 cmp %o0, 0 4000e83c: 02 80 00 16 be 4000e894 <_CORE_message_queue_Submit+0x84> 4000e840: c2 06 20 0c ld [ %i0 + 0xc ], %g1 return ( *operations->first )( heads ); 4000e844: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 4000e848: 9f c0 40 00 call %g1 4000e84c: 01 00 00 00 nop */ the_thread = _Thread_queue_First_locked( &the_message_queue->Wait_queue, the_message_queue->operations ); if ( the_thread == NULL ) { 4000e850: a0 92 20 00 orcc %o0, 0, %l0 4000e854: 02 80 00 10 be 4000e894 <_CORE_message_queue_Submit+0x84> <== NEVER TAKEN 4000e858: 92 10 00 1a mov %i2, %o1 return NULL; } *(size_t *) the_thread->Wait.return_argument = size; 4000e85c: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 4000e860: f6 20 40 00 st %i3, [ %g1 ] the_thread->Wait.count = (uint32_t) submit_type; 4000e864: f8 24 20 3c st %i4, [ %l0 + 0x3c ] memcpy(destination, source, size); 4000e868: 94 10 00 1b mov %i3, %o2 4000e86c: 40 00 2a cd call 400193a0 4000e870: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 buffer, the_thread->Wait.return_argument_second.mutable_object, size ); _Thread_queue_Extract_critical( 4000e874: d2 06 20 0c ld [ %i0 + 0xc ], %o1 4000e878: d6 07 a0 5c ld [ %fp + 0x5c ], %o3 4000e87c: 90 10 00 18 mov %i0, %o0 4000e880: 94 10 00 10 mov %l0, %o2 4000e884: 40 00 0c cf call 40011bc0 <_Thread_queue_Extract_critical> 4000e888: b0 10 20 00 clr %i0 buffer, size, submit_type, queue_context ); if ( the_thread != NULL ) { 4000e88c: 81 c7 e0 08 ret 4000e890: 81 e8 00 00 restore return _Chain_Immutable_head( the_chain )->next; 4000e894: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 return &the_chain->Tail.Node; 4000e898: 82 06 20 38 add %i0, 0x38, %g1 if ( !_Chain_Is_empty(the_chain)) 4000e89c: 80 a2 40 01 cmp %o1, %g1 4000e8a0: 02 80 00 24 be 4000e930 <_CORE_message_queue_Submit+0x120> 4000e8a4: 84 06 20 34 add %i0, 0x34, %g2 new_first = old_first->next; 4000e8a8: c2 02 40 00 ld [ %o1 ], %g1 head->next = new_first; 4000e8ac: c2 26 20 34 st %g1, [ %i0 + 0x34 ] * queue the message up for a future receive. */ the_message = _CORE_message_queue_Allocate_message_buffer( the_message_queue ); if ( the_message ) { _CORE_message_queue_Insert_message( 4000e8b0: 98 10 00 1c mov %i4, %o4 new_first->previous = head; 4000e8b4: c4 20 60 04 st %g2, [ %g1 + 4 ] 4000e8b8: 96 10 00 1b mov %i3, %o3 4000e8bc: 94 10 00 1a mov %i2, %o2 4000e8c0: 40 00 1a 0a call 400150e8 <_CORE_message_queue_Insert_message> 4000e8c4: 90 10 00 18 mov %i0, %o0 /* * According to POSIX, does this happen before or after the message * is actually enqueued. It is logical to think afterwards, because * the message is actually in the queue at this point. */ if ( 4000e8c8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 4000e8cc: 80 a0 60 01 cmp %g1, 1 4000e8d0: 22 80 00 10 be,a 4000e910 <_CORE_message_queue_Submit+0x100> 4000e8d4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e8d8: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 4000e8dc: c2 00 40 00 ld [ %g1 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e8e0: 91 d0 20 0a ta 0xa 4000e8e4: 01 00 00 00 nop } 4000e8e8: 81 c7 e0 08 ret 4000e8ec: 91 e8 20 00 restore %g0, 0, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e8f0: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 4000e8f4: c2 00 40 00 ld [ %g1 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e8f8: 91 d0 20 0a ta 0xa 4000e8fc: 01 00 00 00 nop return STATUS_MESSAGE_INVALID_SIZE; 4000e900: 31 00 00 1e sethi %hi(0x7800), %i0 4000e904: b0 16 22 08 or %i0, 0x208, %i0 ! 7a08 <_ISR_Stack_size+0x6a08> 4000e908: 81 c7 e0 08 ret 4000e90c: 81 e8 00 00 restore the_message_queue->number_of_pending_messages == 1 && the_message_queue->notify_handler != NULL 4000e910: 80 a0 60 00 cmp %g1, 0 4000e914: 02 bf ff f1 be 4000e8d8 <_CORE_message_queue_Submit+0xc8> 4000e918: d2 07 a0 5c ld [ %fp + 0x5c ], %o1 ) { ( *the_message_queue->notify_handler )( 4000e91c: 90 10 00 18 mov %i0, %o0 4000e920: 9f c0 40 00 call %g1 4000e924: b0 10 20 00 clr %i0 4000e928: 81 c7 e0 08 ret 4000e92c: 81 e8 00 00 restore /* * No message buffers were available so we may need to return an * overflow error or block the sender until the message is placed * on the queue. */ if ( !wait ) { 4000e930: 80 a7 60 00 cmp %i5, 0 4000e934: 02 80 00 13 be 4000e980 <_CORE_message_queue_Submit+0x170> 4000e938: 01 00 00 00 nop /* * Do NOT block on a send if the caller is in an ISR. It is * deadly to block in an ISR. */ if ( _ISR_Is_in_progress() ) { 4000e93c: 40 00 05 6b call 4000fee8 <_ISR_Is_in_progress> 4000e940: 01 00 00 00 nop 4000e944: 80 a2 20 00 cmp %o0, 0 4000e948: 12 80 00 14 bne 4000e998 <_CORE_message_queue_Submit+0x188> 4000e94c: 82 10 20 10 mov 0x10, %g1 * WARNING!! executing should NOT be used prior to this point. * Thus the unusual choice to open a new scope and declare * it as a variable. Doing this emphasizes how dangerous it * would be to use this variable prior to here. */ executing->Wait.return_argument_second.immutable_object = buffer; 4000e950: f4 26 60 44 st %i2, [ %i1 + 0x44 ] executing->Wait.option = (uint32_t) size; 4000e954: f6 26 60 48 st %i3, [ %i1 + 0x48 ] _Thread_queue_Context_set_thread_state( queue_context, STATES_WAITING_FOR_MESSAGE ); _Thread_queue_Enqueue( 4000e958: 90 10 00 18 mov %i0, %o0 executing->Wait.count = submit_type; 4000e95c: f8 26 60 3c st %i4, [ %i1 + 0x3c ] _Thread_queue_Enqueue( 4000e960: 94 10 00 19 mov %i1, %o2 4000e964: d6 07 a0 5c ld [ %fp + 0x5c ], %o3 queue_context->thread_state = thread_state; 4000e968: c2 22 e0 04 st %g1, [ %o3 + 4 ] 4000e96c: 40 00 0c 2b call 40011a18 <_Thread_queue_Enqueue> 4000e970: d2 06 20 0c ld [ %i0 + 0xc ], %o1 4000e974: f0 06 60 4c ld [ %i1 + 0x4c ], %i0 executing, queue_context ); return _Thread_Wait_get_status( executing ); #endif } 4000e978: 81 c7 e0 08 ret 4000e97c: 81 e8 00 00 restore register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e980: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 4000e984: c2 00 40 00 ld [ %g1 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e988: 91 d0 20 0a ta 0xa 4000e98c: 01 00 00 00 nop return STATUS_TOO_MANY; 4000e990: 81 c7 e0 08 ret 4000e994: 91 e8 2b 05 restore %g0, 0xb05, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000e998: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 4000e99c: c2 00 40 00 ld [ %g1 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000e9a0: 91 d0 20 0a ta 0xa 4000e9a4: 01 00 00 00 nop return STATUS_MESSAGE_QUEUE_WAIT_IN_ISR; 4000e9a8: 81 c7 e0 08 ret 4000e9ac: 91 e8 2b 0d restore %g0, 0xb0d, %o0 =============================================================================== 40007e40 <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 40007e40: 9d e3 bf a0 save %sp, -96, %sp Heap_Statistics *const stats = &heap->stats; 40007e44: 88 86 60 04 addcc %i1, 4, %g4 uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE - HEAP_ALLOC_BONUS; uintptr_t const page_size = heap->page_size; 40007e48: da 06 20 10 ld [ %i0 + 0x10 ], %o5 40007e4c: ba 40 20 00 addx %g0, 0, %i5 Heap_Block *block = NULL; uintptr_t alloc_begin = 0; uint32_t search_count = 0; bool search_again = false; if ( block_size_floor < alloc_size ) { 40007e50: 80 a7 60 00 cmp %i5, 0 40007e54: 12 80 00 8f bne 40008090 <_Heap_Allocate_aligned_with_boundary+0x250> 40007e58: b8 10 00 18 mov %i0, %i4 /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { 40007e5c: 80 a6 e0 00 cmp %i3, 0 40007e60: 12 80 00 86 bne 40008078 <_Heap_Allocate_aligned_with_boundary+0x238> 40007e64: 80 a6 40 1b cmp %i1, %i3 * * @return The first block of the free list. */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 40007e68: d2 07 20 08 ld [ %i4 + 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 ) { 40007e6c: 80 a7 00 09 cmp %i4, %o1 40007e70: 02 80 00 79 be 40008054 <_Heap_Allocate_aligned_with_boundary+0x214> 40007e74: 9e 10 20 04 mov 4, %o7 uintptr_t const alloc_begin_ceiling = block_end - min_block_size 40007e78: 96 03 60 07 add %o5, 7, %o3 uintptr_t alloc_begin = alloc_end - alloc_size; 40007e7c: 9e 23 c0 19 sub %o7, %i1, %o7 uintptr_t const free_size = alloc_block_begin - block_begin; 40007e80: 10 80 00 09 b 40007ea4 <_Heap_Allocate_aligned_with_boundary+0x64> 40007e84: 94 10 3f f8 mov -8, %o2 } /* Statistics */ ++search_count; if ( alloc_begin != 0 ) { 40007e88: 80 a6 20 00 cmp %i0, 0 40007e8c: 32 80 00 5c bne,a 40007ffc <_Heap_Allocate_aligned_with_boundary+0x1bc> <== ALWAYS TAKEN 40007e90: 96 10 00 19 mov %i1, %o3 break; } block = block->next; 40007e94: d2 02 60 08 ld [ %o1 + 8 ], %o1 while ( block != free_list_tail ) { 40007e98: 80 a7 00 09 cmp %i4, %o1 40007e9c: 22 80 00 6f be,a 40008058 <_Heap_Allocate_aligned_with_boundary+0x218> 40007ea0: c2 07 20 5c ld [ %i4 + 0x5c ], %g1 if ( block->size_and_flag > block_size_floor ) { 40007ea4: c2 02 60 04 ld [ %o1 + 4 ], %g1 40007ea8: 80 a0 40 04 cmp %g1, %g4 40007eac: 08 bf ff fa bleu 40007e94 <_Heap_Allocate_aligned_with_boundary+0x54> 40007eb0: ba 07 60 01 inc %i5 if ( alignment == 0 ) { 40007eb4: 80 a6 a0 00 cmp %i2, 0 40007eb8: 02 bf ff f4 be 40007e88 <_Heap_Allocate_aligned_with_boundary+0x48> 40007ebc: b0 02 60 08 add %o1, 8, %i0 alloc_begin = _Heap_Check_block( 40007ec0: d8 07 20 14 ld [ %i4 + 0x14 ], %o4 * * @return The block size. */ RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40007ec4: 82 08 7f fe and %g1, -2, %g1 uintptr_t const alloc_begin_ceiling = block_end - min_block_size 40007ec8: 84 22 c0 0c sub %o3, %o4, %g2 uintptr_t const block_end = block_begin + block_size; 40007ecc: 82 00 40 09 add %g1, %o1, %g1 uintptr_t const alloc_begin_ceiling = block_end - min_block_size 40007ed0: 84 00 80 01 add %g2, %g1, %g2 uintptr_t alloc_begin = alloc_end - alloc_size; 40007ed4: 82 03 c0 01 add %o7, %g1, %g1 return value - (value % alignment); 40007ed8: 81 80 20 00 wr %g0, %y 40007edc: 01 00 00 00 nop 40007ee0: 01 00 00 00 nop 40007ee4: 01 00 00 00 nop 40007ee8: 82 70 40 1a udiv %g1, %i2, %g1 40007eec: 86 58 40 1a smul %g1, %i2, %g3 if ( alloc_begin > alloc_begin_ceiling ) { 40007ef0: 80 a0 80 03 cmp %g2, %g3 40007ef4: 1a 80 00 08 bcc 40007f14 <_Heap_Allocate_aligned_with_boundary+0xd4> 40007ef8: 80 a6 e0 00 cmp %i3, 0 40007efc: 81 80 20 00 wr %g0, %y 40007f00: 01 00 00 00 nop 40007f04: 01 00 00 00 nop 40007f08: 01 00 00 00 nop 40007f0c: 82 70 80 1a udiv %g2, %i2, %g1 40007f10: 86 58 40 1a smul %g1, %i2, %g3 if ( boundary != 0 ) { 40007f14: 02 80 00 26 be 40007fac <_Heap_Allocate_aligned_with_boundary+0x16c> 40007f18: 80 a0 c0 18 cmp %g3, %i0 alloc_end = alloc_begin + alloc_size; 40007f1c: a0 06 40 03 add %i1, %g3, %l0 40007f20: 81 80 20 00 wr %g0, %y 40007f24: 01 00 00 00 nop 40007f28: 01 00 00 00 nop 40007f2c: 01 00 00 00 nop 40007f30: 84 74 00 1b udiv %l0, %i3, %g2 40007f34: 82 58 80 1b smul %g2, %i3, %g1 while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 40007f38: 80 a0 40 10 cmp %g1, %l0 40007f3c: 1a 80 00 1b bcc 40007fa8 <_Heap_Allocate_aligned_with_boundary+0x168> 40007f40: 90 06 40 18 add %i1, %i0, %o0 40007f44: 80 a0 c0 01 cmp %g3, %g1 40007f48: 2a 80 00 06 bcs,a 40007f60 <_Heap_Allocate_aligned_with_boundary+0x120> 40007f4c: 80 a2 00 01 cmp %o0, %g1 if ( alloc_begin >= alloc_begin_floor ) { 40007f50: 10 80 00 17 b 40007fac <_Heap_Allocate_aligned_with_boundary+0x16c> 40007f54: 80 a0 c0 18 cmp %g3, %i0 while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 40007f58: 1a 80 00 14 bcc 40007fa8 <_Heap_Allocate_aligned_with_boundary+0x168> 40007f5c: 80 a2 00 01 cmp %o0, %g1 if ( boundary_line < boundary_floor ) { 40007f60: 18 bf ff cd bgu 40007e94 <_Heap_Allocate_aligned_with_boundary+0x54> 40007f64: 82 20 40 19 sub %g1, %i1, %g1 40007f68: 81 80 20 00 wr %g0, %y 40007f6c: 01 00 00 00 nop 40007f70: 01 00 00 00 nop 40007f74: 01 00 00 00 nop 40007f78: 82 70 40 1a udiv %g1, %i2, %g1 40007f7c: 86 58 40 1a smul %g1, %i2, %g3 alloc_end = alloc_begin + alloc_size; 40007f80: 84 06 40 03 add %i1, %g3, %g2 40007f84: 81 80 20 00 wr %g0, %y 40007f88: 01 00 00 00 nop 40007f8c: 01 00 00 00 nop 40007f90: 01 00 00 00 nop 40007f94: 82 70 80 1b udiv %g2, %i3, %g1 40007f98: 82 58 40 1b smul %g1, %i3, %g1 while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 40007f9c: 80 a0 c0 01 cmp %g3, %g1 40007fa0: 0a bf ff ee bcs 40007f58 <_Heap_Allocate_aligned_with_boundary+0x118> 40007fa4: 80 a0 40 02 cmp %g1, %g2 if ( alloc_begin >= alloc_begin_floor ) { 40007fa8: 80 a0 c0 18 cmp %g3, %i0 40007fac: 2a bf ff bb bcs,a 40007e98 <_Heap_Allocate_aligned_with_boundary+0x58> 40007fb0: d2 02 60 08 ld [ %o1 + 8 ], %o1 uintptr_t const free_size = alloc_block_begin - block_begin; 40007fb4: 82 22 80 09 sub %o2, %o1, %g1 40007fb8: 81 80 20 00 wr %g0, %y 40007fbc: 01 00 00 00 nop 40007fc0: 01 00 00 00 nop 40007fc4: 01 00 00 00 nop 40007fc8: 84 70 c0 0d udiv %g3, %o5, %g2 40007fcc: 84 58 80 0d smul %g2, %o5, %g2 40007fd0: 82 00 40 02 add %g1, %g2, %g1 if ( free_size >= min_block_size || free_size == 0 ) { 40007fd4: 80 a0 40 0c cmp %g1, %o4 40007fd8: 1a 80 00 04 bcc 40007fe8 <_Heap_Allocate_aligned_with_boundary+0x1a8> 40007fdc: 80 a0 60 00 cmp %g1, 0 40007fe0: 32 bf ff ae bne,a 40007e98 <_Heap_Allocate_aligned_with_boundary+0x58> 40007fe4: d2 02 60 08 ld [ %o1 + 8 ], %o1 40007fe8: b0 10 00 03 mov %g3, %i0 if ( alloc_begin != 0 ) { 40007fec: 80 a6 20 00 cmp %i0, 0 40007ff0: 22 bf ff aa be,a 40007e98 <_Heap_Allocate_aligned_with_boundary+0x58> <== NEVER TAKEN 40007ff4: 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 ); 40007ff8: 96 10 00 19 mov %i1, %o3 40007ffc: 94 10 00 18 mov %i0, %o2 40008000: 40 00 01 0f call 4000843c <_Heap_Block_allocate> 40008004: 90 10 00 1c mov %i4, %o0 alignment, boundary ); /* Statistics */ ++stats->allocs; 40008008: f6 07 20 58 ld [ %i4 + 0x58 ], %i3 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000800c: c8 02 20 04 ld [ %o0 + 4 ], %g4 stats->searches += search_count; stats->lifetime_allocated += _Heap_Block_size( block ); 40008010: c4 1f 20 28 ldd [ %i4 + 0x28 ], %g2 stats->searches += search_count; 40008014: c2 07 20 54 ld [ %i4 + 0x54 ], %g1 ++stats->allocs; 40008018: b6 06 e0 01 inc %i3 stats->searches += search_count; 4000801c: 82 00 40 1d add %g1, %i5, %g1 ++stats->allocs; 40008020: f6 27 20 58 st %i3, [ %i4 + 0x58 ] 40008024: 88 09 3f fe and %g4, -2, %g4 stats->searches += search_count; 40008028: c2 27 20 54 st %g1, [ %i4 + 0x54 ] stats->lifetime_allocated += _Heap_Block_size( block ); 4000802c: b6 80 c0 04 addcc %g3, %g4, %i3 40008030: b4 40 a0 00 addx %g2, 0, %i2 40008034: f4 3f 20 28 std %i2, [ %i4 + 0x28 ] /* Statistics */ ++stats->failed_allocs; } /* Statistics */ if ( stats->max_search < search_count ) { 40008038: c2 07 20 50 ld [ %i4 + 0x50 ], %g1 4000803c: 80 a0 40 1d cmp %g1, %i5 40008040: 1a 80 00 0c bcc 40008070 <_Heap_Allocate_aligned_with_boundary+0x230> 40008044: 01 00 00 00 nop stats->max_search = search_count; 40008048: fa 27 20 50 st %i5, [ %i4 + 0x50 ] } return (void *) alloc_begin; 4000804c: 81 c7 e0 08 ret 40008050: 81 e8 00 00 restore ++stats->failed_allocs; 40008054: c2 07 20 5c ld [ %i4 + 0x5c ], %g1 40008058: 82 00 60 01 inc %g1 4000805c: c2 27 20 5c st %g1, [ %i4 + 0x5c ] if ( stats->max_search < search_count ) { 40008060: c2 07 20 50 ld [ %i4 + 0x50 ], %g1 40008064: 80 a0 40 1d cmp %g1, %i5 40008068: 0a bf ff f8 bcs 40008048 <_Heap_Allocate_aligned_with_boundary+0x208> 4000806c: b0 10 20 00 clr %i0 } 40008070: 81 c7 e0 08 ret 40008074: 81 e8 00 00 restore if ( boundary < alloc_size ) { 40008078: 18 80 00 06 bgu 40008090 <_Heap_Allocate_aligned_with_boundary+0x250> 4000807c: 80 a6 a0 00 cmp %i2, 0 if ( alignment == 0 ) { 40008080: 22 bf ff 7a be,a 40007e68 <_Heap_Allocate_aligned_with_boundary+0x28> 40008084: b4 10 00 0d mov %o5, %i2 return _Heap_Free_list_head(heap)->next; 40008088: 10 bf ff 79 b 40007e6c <_Heap_Allocate_aligned_with_boundary+0x2c> 4000808c: d2 07 20 08 ld [ %i4 + 8 ], %o1 return NULL; 40008090: 81 c7 e0 08 ret 40008094: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 4000b38c <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t unused RTEMS_UNUSED ) { 4000b38c: 9d e3 bf 98 save %sp, -104, %sp Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; 4000b390: c0 27 bf f8 clr [ %fp + -8 ] { 4000b394: ba 10 00 18 mov %i0, %i5 Heap_Block *extend_last_block = NULL; 4000b398: c0 27 bf fc clr [ %fp + -4 ] uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; 4000b39c: a0 10 00 19 mov %i1, %l0 uintptr_t const extend_area_end = extend_area_begin + extend_area_size; 4000b3a0: b8 86 40 1a addcc %i1, %i2, %i4 Heap_Block *const first_block = heap->first_block; 4000b3a4: 0a 80 00 b1 bcs 4000b668 <_Heap_Extend+0x2dc> 4000b3a8: e2 06 20 20 ld [ %i0 + 0x20 ], %l1 uintptr_t const page_size = heap->page_size; 4000b3ac: f6 06 20 10 ld [ %i0 + 0x10 ], %i3 if ( extend_area_end < extend_area_begin ) { return 0; } extend_area_ok = _Heap_Get_first_and_last_block( 4000b3b0: d6 06 20 14 ld [ %i0 + 0x14 ], %o3 4000b3b4: 9a 07 bf fc add %fp, -4, %o5 uintptr_t const free_size = stats->free_size; 4000b3b8: f0 06 20 3c ld [ %i0 + 0x3c ], %i0 extend_area_ok = _Heap_Get_first_and_last_block( 4000b3bc: 98 07 bf f8 add %fp, -8, %o4 4000b3c0: 94 10 00 1b mov %i3, %o2 4000b3c4: 92 10 00 1a mov %i2, %o1 4000b3c8: 7f ff f3 80 call 400081c8 <_Heap_Get_first_and_last_block> 4000b3cc: 90 10 00 19 mov %i1, %o0 page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 4000b3d0: 80 a2 20 00 cmp %o0, 0 4000b3d4: 02 80 00 a5 be 4000b668 <_Heap_Extend+0x2dc> 4000b3d8: 82 10 00 11 mov %l1, %g1 Heap_Block *link_above_block = NULL; 4000b3dc: a6 10 20 00 clr %l3 Heap_Block *link_below_block = NULL; 4000b3e0: 9e 10 20 00 clr %o7 Heap_Block *merge_above_block = NULL; 4000b3e4: b4 10 20 00 clr %i2 Heap_Block *merge_below_block = NULL; 4000b3e8: a4 10 20 00 clr %l2 return 0; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 4000b3ec: 80 a0 40 11 cmp %g1, %l1 4000b3f0: 12 80 00 14 bne 4000b440 <_Heap_Extend+0xb4> <== NEVER TAKEN 4000b3f4: 88 10 00 01 mov %g1, %g4 4000b3f8: 10 80 00 12 b 4000b440 <_Heap_Extend+0xb4> 4000b3fc: c8 07 60 18 ld [ %i5 + 0x18 ], %g4 return 0; } if ( extend_area_end == sub_area_begin ) { merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 4000b400: 2a 80 00 02 bcs,a 4000b408 <_Heap_Extend+0x7c> 4000b404: 9e 10 00 01 mov %g1, %o7 link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 4000b408: 80 a6 40 03 cmp %i1, %g3 4000b40c: 22 80 00 21 be,a 4000b490 <_Heap_Extend+0x104> 4000b410: f8 20 40 00 st %i4, [ %g1 ] start_block->prev_size = extend_area_end; merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 4000b414: 38 80 00 02 bgu,a 4000b41c <_Heap_Extend+0x90> 4000b418: a6 10 00 02 mov %g2, %l3 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000b41c: c2 00 a0 04 ld [ %g2 + 4 ], %g1 4000b420: 82 08 7f fe and %g1, -2, %g1 return (Heap_Block *) ((uintptr_t) block + offset); 4000b424: 82 00 40 02 add %g1, %g2, %g1 link_above_block = end_block; } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); 4000b428: 80 a4 40 01 cmp %l1, %g1 4000b42c: 22 80 00 20 be,a 4000b4ac <_Heap_Extend+0x120> 4000b430: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 (uintptr_t) start_block : heap->area_begin; 4000b434: 80 a0 40 11 cmp %g1, %l1 4000b438: 02 bf ff f0 be 4000b3f8 <_Heap_Extend+0x6c> <== NEVER TAKEN 4000b43c: 88 10 00 01 mov %g1, %g4 uintptr_t const sub_area_end = start_block->prev_size; 4000b440: c6 00 40 00 ld [ %g1 ], %g3 return value - (value % alignment); 4000b444: 81 80 20 00 wr %g0, %y 4000b448: 01 00 00 00 nop 4000b44c: 01 00 00 00 nop 4000b450: 01 00 00 00 nop 4000b454: 84 70 c0 1b udiv %g3, %i3, %g2 if ( 4000b458: 80 a6 40 03 cmp %i1, %g3 4000b45c: 84 58 80 1b smul %g2, %i3, %g2 4000b460: 1a 80 00 05 bcc 4000b474 <_Heap_Extend+0xe8> 4000b464: 84 00 bf f8 add %g2, -8, %g2 4000b468: 80 a1 00 1c cmp %g4, %i4 4000b46c: 0a 80 00 7f bcs 4000b668 <_Heap_Extend+0x2dc> 4000b470: 01 00 00 00 nop if ( extend_area_end == sub_area_begin ) { 4000b474: 80 a1 00 1c cmp %g4, %i4 4000b478: 12 bf ff e2 bne 4000b400 <_Heap_Extend+0x74> 4000b47c: 80 a7 00 03 cmp %i4, %g3 if ( sub_area_end == extend_area_begin ) { 4000b480: 80 a6 40 03 cmp %i1, %g3 4000b484: 12 bf ff e4 bne 4000b414 <_Heap_Extend+0x88> <== ALWAYS TAKEN 4000b488: a4 10 00 01 mov %g1, %l2 start_block->prev_size = extend_area_end; 4000b48c: f8 20 40 00 st %i4, [ %g1 ] <== NOT EXECUTED return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000b490: c2 00 a0 04 ld [ %g2 + 4 ], %g1 4000b494: 82 08 7f fe and %g1, -2, %g1 return (Heap_Block *) ((uintptr_t) block + offset); 4000b498: 82 00 40 02 add %g1, %g2, %g1 } while ( start_block != first_block ); 4000b49c: 80 a4 40 01 cmp %l1, %g1 4000b4a0: 12 bf ff e5 bne 4000b434 <_Heap_Extend+0xa8> <== NEVER TAKEN 4000b4a4: b4 10 00 02 mov %g2, %i2 if ( extend_area_begin < heap->area_begin ) { 4000b4a8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 4000b4ac: 80 a0 40 19 cmp %g1, %i1 4000b4b0: 28 80 00 75 bleu,a 4000b684 <_Heap_Extend+0x2f8> 4000b4b4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 heap->area_begin = extend_area_begin; 4000b4b8: f2 27 60 18 st %i1, [ %i5 + 0x18 ] } else if ( heap->area_end < extend_area_end ) { heap->area_end = extend_area_end; } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 4000b4bc: c2 07 bf f8 ld [ %fp + -8 ], %g1 4000b4c0: c4 07 bf fc ld [ %fp + -4 ], %g2 extend_first_block_size = 4000b4c4: 86 20 80 01 sub %g2, %g1, %g3 extend_first_block->prev_size = extend_area_end; 4000b4c8: f8 20 40 00 st %i4, [ %g1 ] extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 4000b4cc: 88 10 e0 01 or %g3, 1, %g4 extend_first_block->size_and_flag = 4000b4d0: c8 20 60 04 st %g4, [ %g1 + 4 ] _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 4000b4d4: c6 20 80 00 st %g3, [ %g2 ] extend_last_block->size_and_flag = 0; 4000b4d8: c0 20 a0 04 clr [ %g2 + 4 ] _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { 4000b4dc: c6 07 60 20 ld [ %i5 + 0x20 ], %g3 4000b4e0: 80 a0 c0 01 cmp %g3, %g1 4000b4e4: 28 80 00 63 bleu,a 4000b670 <_Heap_Extend+0x2e4> 4000b4e8: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 heap->first_block = extend_first_block; 4000b4ec: c2 27 60 20 st %g1, [ %i5 + 0x20 ] } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { heap->last_block = extend_last_block; } if ( merge_below_block != NULL ) { 4000b4f0: 80 a4 a0 00 cmp %l2, 0 4000b4f4: 02 80 00 69 be 4000b698 <_Heap_Extend+0x30c> 4000b4f8: 92 06 60 08 add %i1, 8, %o1 uintptr_t const page_size = heap->page_size; 4000b4fc: c4 07 60 10 ld [ %i5 + 0x10 ], %g2 uintptr_t remainder = value % alignment; 4000b500: 81 80 20 00 wr %g0, %y 4000b504: 01 00 00 00 nop 4000b508: 01 00 00 00 nop 4000b50c: 01 00 00 00 nop 4000b510: 82 72 40 02 udiv %o1, %g2, %g1 4000b514: 82 58 40 02 smul %g1, %g2, %g1 if ( remainder != 0 ) { 4000b518: 82 a2 40 01 subcc %o1, %g1, %g1 4000b51c: 32 80 00 7d bne,a 4000b710 <_Heap_Extend+0x384> 4000b520: 92 00 80 09 add %g2, %o1, %o1 new_first_block->prev_size = first_block->prev_size; 4000b524: c2 04 80 00 ld [ %l2 ], %g1 4000b528: c2 26 40 00 st %g1, [ %i1 ] uintptr_t const new_first_block_size = 4000b52c: a0 24 80 10 sub %l2, %l0, %l0 ++stats->used_blocks; 4000b530: c4 07 60 4c ld [ %i5 + 0x4c ], %g2 --stats->frees; 4000b534: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED; 4000b538: a0 14 20 01 or %l0, 1, %l0 4000b53c: e0 26 60 04 st %l0, [ %i1 + 4 ] ++stats->used_blocks; 4000b540: 84 00 a0 01 inc %g2 --stats->frees; 4000b544: 82 00 7f ff add %g1, -1, %g1 ++stats->used_blocks; 4000b548: c4 27 60 4c st %g2, [ %i5 + 0x4c ] _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) ); 4000b54c: 90 10 00 1d mov %i5, %o0 4000b550: 40 00 00 74 call 4000b720 <_Heap_Free> 4000b554: c2 27 60 60 st %g1, [ %i5 + 0x60 ] return _Heap_Free_list_head(heap)->next; 4000b558: c2 07 60 08 ld [ %i5 + 8 ], %g1 Heap_Block *next = block->next; 4000b55c: c4 00 60 08 ld [ %g1 + 8 ], %g2 Heap_Block *prev = block->prev; 4000b560: c6 00 60 0c ld [ %g1 + 0xc ], %g3 prev->next = next; 4000b564: c4 20 e0 08 st %g2, [ %g3 + 8 ] next->prev = prev; 4000b568: c6 20 a0 0c st %g3, [ %g2 + 0xc ] Heap_Block *prev = block_next->prev; 4000b56c: c4 07 60 0c ld [ %i5 + 0xc ], %g2 new_block->prev = prev; 4000b570: c4 20 60 0c st %g2, [ %g1 + 0xc ] new_block->next = block_next; 4000b574: fa 20 60 08 st %i5, [ %g1 + 8 ] prev->next = new_block; 4000b578: c2 20 a0 08 st %g1, [ %g2 + 8 ] block_next->prev = new_block; 4000b57c: c2 27 60 0c st %g1, [ %i5 + 0xc ] link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 4000b580: 80 a6 a0 00 cmp %i2, 0 4000b584: 02 80 00 4b be 4000b6b0 <_Heap_Extend+0x324> 4000b588: b8 07 3f f8 add %i4, -8, %i4 (last_block->size_and_flag - last_block_new_size) 4000b58c: c2 06 a0 04 ld [ %i2 + 4 ], %g1 return value - (value % alignment); 4000b590: c6 07 60 10 ld [ %i5 + 0x10 ], %g3 4000b594: 82 06 80 01 add %i2, %g1, %g1 uintptr_t const last_block_new_size = _Heap_Align_down( 4000b598: 84 27 00 1a sub %i4, %i2, %g2 (last_block->size_and_flag - last_block_new_size) 4000b59c: b8 20 40 1c sub %g1, %i4, %i4 4000b5a0: 81 80 20 00 wr %g0, %y 4000b5a4: 01 00 00 00 nop 4000b5a8: 01 00 00 00 nop 4000b5ac: 01 00 00 00 nop 4000b5b0: 82 70 80 03 udiv %g2, %g3, %g1 4000b5b4: 82 58 40 03 smul %g1, %g3, %g1 4000b5b8: 88 10 00 01 mov %g1, %g4 4000b5bc: 82 20 80 01 sub %g2, %g1, %g1 new_last_block->size_and_flag = 4000b5c0: 84 06 80 04 add %i2, %g4, %g2 (last_block->size_and_flag - last_block_new_size) 4000b5c4: 82 07 00 01 add %i4, %g1, %g1 | HEAP_PREV_BLOCK_USED; 4000b5c8: 82 10 60 01 or %g1, 1, %g1 new_last_block->size_and_flag = 4000b5cc: c2 20 a0 04 st %g1, [ %g2 + 4 ] _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) ); 4000b5d0: 92 06 a0 08 add %i2, 8, %o1 uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000b5d4: c2 06 a0 04 ld [ %i2 + 4 ], %g1 ++stats->used_blocks; 4000b5d8: c6 07 60 4c ld [ %i5 + 0x4c ], %g3 --stats->frees; 4000b5dc: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 4000b5e0: 82 08 60 01 and %g1, 1, %g1 block->size_and_flag = size | flag; 4000b5e4: 82 10 40 04 or %g1, %g4, %g1 4000b5e8: c2 26 a0 04 st %g1, [ %i2 + 4 ] ++stats->used_blocks; 4000b5ec: 86 00 e0 01 inc %g3 --stats->frees; 4000b5f0: 82 00 bf ff add %g2, -1, %g1 ++stats->used_blocks; 4000b5f4: c6 27 60 4c st %g3, [ %i5 + 0x4c ] _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) ); 4000b5f8: 90 10 00 1d mov %i5, %o0 --stats->frees; 4000b5fc: c2 27 60 60 st %g1, [ %i5 + 0x60 ] _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) ); 4000b600: 40 00 00 48 call 4000b720 <_Heap_Free> 4000b604: 01 00 00 00 nop return _Heap_Free_list_head(heap)->next; 4000b608: c2 07 60 08 ld [ %i5 + 8 ], %g1 Heap_Block *next = block->next; 4000b60c: c4 00 60 08 ld [ %g1 + 8 ], %g2 Heap_Block *prev = block->prev; 4000b610: c6 00 60 0c ld [ %g1 + 0xc ], %g3 prev->next = next; 4000b614: c4 20 e0 08 st %g2, [ %g3 + 8 ] next->prev = prev; 4000b618: c6 20 a0 0c st %g3, [ %g2 + 0xc ] Heap_Block *prev = block_next->prev; 4000b61c: c4 07 60 0c ld [ %i5 + 0xc ], %g2 new_block->prev = prev; 4000b620: c4 20 60 0c st %g2, [ %g1 + 0xc ] new_block->next = block_next; 4000b624: fa 20 60 08 st %i5, [ %g1 + 8 ] prev->next = new_block; 4000b628: c2 20 a0 08 st %g1, [ %g2 + 8 ] block_next->prev = new_block; 4000b62c: c2 27 60 0c st %g1, [ %i5 + 0xc ] _Heap_Block_set_size( 4000b630: c8 07 60 24 ld [ %i5 + 0x24 ], %g4 uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000b634: f8 01 20 04 ld [ %g4 + 4 ], %i4 _Heap_Block_set_size( 4000b638: c4 07 60 20 ld [ %i5 + 0x20 ], %g2 _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; /* Statistics */ stats->size += extended_size; 4000b63c: c6 07 60 38 ld [ %i5 + 0x38 ], %g3 extended_size = stats->free_size - free_size; 4000b640: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 4000b644: 84 20 80 04 sub %g2, %g4, %g2 uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000b648: b8 0f 20 01 and %i4, 1, %i4 block->size_and_flag = size | flag; 4000b64c: 84 10 80 1c or %g2, %i4, %g2 4000b650: c4 21 20 04 st %g2, [ %g4 + 4 ] 4000b654: b0 20 40 18 sub %g1, %i0, %i0 stats->size += extended_size; 4000b658: 82 00 c0 18 add %g3, %i0, %g1 4000b65c: c2 27 60 38 st %g1, [ %i5 + 0x38 ] return extended_size; } 4000b660: 81 c7 e0 08 ret 4000b664: 81 e8 00 00 restore return 0; 4000b668: 81 c7 e0 08 ret 4000b66c: 91 e8 20 00 restore %g0, 0, %o0 } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 4000b670: 80 a0 40 02 cmp %g1, %g2 4000b674: 2a bf ff 9f bcs,a 4000b4f0 <_Heap_Extend+0x164> 4000b678: c4 27 60 24 st %g2, [ %i5 + 0x24 ] if ( merge_below_block != NULL ) { 4000b67c: 10 bf ff 9e b 4000b4f4 <_Heap_Extend+0x168> 4000b680: 80 a4 a0 00 cmp %l2, 0 } else if ( heap->area_end < extend_area_end ) { 4000b684: 80 a0 40 1c cmp %g1, %i4 4000b688: 2a bf ff 8d bcs,a 4000b4bc <_Heap_Extend+0x130> 4000b68c: f8 27 60 1c st %i4, [ %i5 + 0x1c ] (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 4000b690: 10 bf ff 8c b 4000b4c0 <_Heap_Extend+0x134> 4000b694: c2 07 bf f8 ld [ %fp + -8 ], %g1 } else if ( link_below_block != NULL ) { 4000b698: 80 a3 e0 00 cmp %o7, 0 4000b69c: 02 bf ff b9 be 4000b580 <_Heap_Extend+0x1f4> 4000b6a0: 9e 23 c0 02 sub %o7, %g2, %o7 (link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED; 4000b6a4: 9e 13 e0 01 or %o7, 1, %o7 } 4000b6a8: 10 bf ff b6 b 4000b580 <_Heap_Extend+0x1f4> 4000b6ac: de 20 a0 04 st %o7, [ %g2 + 4 ] } else if ( link_above_block != NULL ) { 4000b6b0: 80 a4 e0 00 cmp %l3, 0 4000b6b4: 02 80 00 0b be 4000b6e0 <_Heap_Extend+0x354> 4000b6b8: c2 07 bf f8 ld [ %fp + -8 ], %g1 uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000b6bc: c4 04 e0 04 ld [ %l3 + 4 ], %g2 4000b6c0: 84 08 a0 01 and %g2, 1, %g2 _Heap_Block_set_size( link, first_block_begin - link_begin ); 4000b6c4: 82 20 40 13 sub %g1, %l3, %g1 block->size_and_flag = size | flag; 4000b6c8: 82 10 40 02 or %g1, %g2, %g1 4000b6cc: c2 24 e0 04 st %g1, [ %l3 + 4 ] _Heap_Link_above( 4000b6d0: c4 07 bf fc ld [ %fp + -4 ], %g2 last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 4000b6d4: c2 00 a0 04 ld [ %g2 + 4 ], %g1 4000b6d8: 82 10 60 01 or %g1, 1, %g1 4000b6dc: c2 20 a0 04 st %g1, [ %g2 + 4 ] if ( merge_below_block == NULL && merge_above_block == NULL ) { 4000b6e0: 80 a4 a0 00 cmp %l2, 0 4000b6e4: 12 bf ff d3 bne 4000b630 <_Heap_Extend+0x2a4> 4000b6e8: d2 07 bf f8 ld [ %fp + -8 ], %o1 ++stats->used_blocks; 4000b6ec: c4 07 60 4c ld [ %i5 + 0x4c ], %g2 --stats->frees; 4000b6f0: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 ++stats->used_blocks; 4000b6f4: 84 00 a0 01 inc %g2 --stats->frees; 4000b6f8: 82 00 7f ff add %g1, -1, %g1 ++stats->used_blocks; 4000b6fc: c4 27 60 4c st %g2, [ %i5 + 0x4c ] _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) ); 4000b700: 90 10 00 1d mov %i5, %o0 --stats->frees; 4000b704: c2 27 60 60 st %g1, [ %i5 + 0x60 ] _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) ); 4000b708: 10 bf ff be b 4000b600 <_Heap_Extend+0x274> 4000b70c: 92 02 60 08 add %o1, 8, %o1 return value - remainder + alignment; 4000b710: 92 22 40 01 sub %o1, %g1, %o1 uintptr_t const new_first_block_begin = 4000b714: a0 02 7f f8 add %o1, -8, %l0 4000b718: 10 bf ff 83 b 4000b524 <_Heap_Extend+0x198> 4000b71c: b2 10 00 10 mov %l0, %i1 =============================================================================== 4000b720 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 4000b720: 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 ) { 4000b724: 80 a6 60 00 cmp %i1, 0 4000b728: 22 80 00 63 be,a 4000b8b4 <_Heap_Free+0x194> 4000b72c: 84 10 20 01 mov 1, %g2 return value - (value % alignment); 4000b730: c6 06 20 10 ld [ %i0 + 0x10 ], %g3 return (uintptr_t) block >= (uintptr_t) heap->first_block 4000b734: c8 06 20 20 ld [ %i0 + 0x20 ], %g4 return value - (value % alignment); 4000b738: 81 80 20 00 wr %g0, %y 4000b73c: 01 00 00 00 nop 4000b740: 01 00 00 00 nop 4000b744: 01 00 00 00 nop 4000b748: 82 76 40 03 udiv %i1, %g3, %g1 4000b74c: 82 58 40 03 smul %g1, %g3, %g1 - HEAP_BLOCK_HEADER_SIZE); 4000b750: 82 00 7f f8 add %g1, -8, %g1 && (uintptr_t) block <= (uintptr_t) heap->last_block; 4000b754: 80 a0 40 04 cmp %g1, %g4 4000b758: 0a 80 00 36 bcs 4000b830 <_Heap_Free+0x110> 4000b75c: 84 10 20 00 clr %g2 4000b760: f4 06 20 24 ld [ %i0 + 0x24 ], %i2 4000b764: 80 a0 40 1a cmp %g1, %i2 4000b768: 38 80 00 33 bgu,a 4000b834 <_Heap_Free+0x114> 4000b76c: b0 08 a0 ff and %g2, 0xff, %i0 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000b770: fa 00 60 04 ld [ %g1 + 4 ], %i5 4000b774: b6 0f 7f fe and %i5, -2, %i3 return (Heap_Block *) ((uintptr_t) block + offset); 4000b778: 86 00 40 1b add %g1, %i3, %g3 && (uintptr_t) block <= (uintptr_t) heap->last_block; 4000b77c: 80 a1 00 03 cmp %g4, %g3 4000b780: 38 80 00 2d bgu,a 4000b834 <_Heap_Free+0x114> <== NEVER TAKEN 4000b784: b0 08 a0 ff and %g2, 0xff, %i0 <== NOT EXECUTED 4000b788: 80 a6 80 03 cmp %i2, %g3 4000b78c: 2a 80 00 2a bcs,a 4000b834 <_Heap_Free+0x114> 4000b790: b0 08 a0 ff and %g2, 0xff, %i0 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000b794: f8 00 e0 04 ld [ %g3 + 4 ], %i4 4000b798: b2 0f 20 01 and %i4, 1, %i1 return false; } _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_prev_used( next_block ) ) { 4000b79c: 80 a6 60 00 cmp %i1, 0 4000b7a0: 02 80 00 24 be 4000b830 <_Heap_Free+0x110> <== NEVER TAKEN 4000b7a4: 84 10 00 19 mov %i1, %g2 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000b7a8: b8 0f 3f fe and %i4, -2, %i4 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 )); 4000b7ac: 80 a6 80 03 cmp %i2, %g3 4000b7b0: 02 80 00 23 be 4000b83c <_Heap_Free+0x11c> 4000b7b4: ba 0f 60 01 and %i5, 1, %i5 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000b7b8: b2 00 c0 1c add %g3, %i4, %i1 4000b7bc: f2 06 60 04 ld [ %i1 + 4 ], %i1 4000b7c0: 80 8e 60 01 btst 1, %i1 4000b7c4: 12 80 00 1f bne 4000b840 <_Heap_Free+0x120> 4000b7c8: 80 a7 60 00 cmp %i5, 0 if ( !_Heap_Is_prev_used( block ) ) { 4000b7cc: 02 80 00 1f be 4000b848 <_Heap_Free+0x128> 4000b7d0: 9e 10 20 01 mov 1, %o7 Heap_Block *next = old_block->next; 4000b7d4: c8 00 e0 08 ld [ %g3 + 8 ], %g4 Heap_Block *prev = old_block->prev; 4000b7d8: c6 00 e0 0c ld [ %g3 + 0xc ], %g3 new_block->prev = prev; 4000b7dc: c6 20 60 0c st %g3, [ %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; 4000b7e0: b8 06 c0 1c add %i3, %i4, %i4 new_block->next = next; 4000b7e4: c8 20 60 08 st %g4, [ %g1 + 8 ] _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 4000b7e8: ba 17 20 01 or %i4, 1, %i5 next->prev = new_block; 4000b7ec: c2 21 20 0c st %g1, [ %g4 + 0xc ] prev->next = new_block; 4000b7f0: c2 20 e0 08 st %g1, [ %g3 + 8 ] 4000b7f4: fa 20 60 04 st %i5, [ %g1 + 4 ] next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 4000b7f8: f8 20 40 1c st %i4, [ %g1 + %i4 ] /* Statistics */ --stats->used_blocks; ++stats->frees; stats->free_size += block_size; stats->lifetime_freed += block_size; 4000b7fc: f8 1e 20 30 ldd [ %i0 + 0x30 ], %i4 --stats->used_blocks; 4000b800: c8 06 20 4c ld [ %i0 + 0x4c ], %g4 ++stats->frees; 4000b804: c6 06 20 60 ld [ %i0 + 0x60 ], %g3 stats->free_size += block_size; 4000b808: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 stats->lifetime_freed += block_size; 4000b80c: 9a 87 40 1b addcc %i5, %i3, %o5 --stats->used_blocks; 4000b810: 88 01 3f ff add %g4, -1, %g4 ++stats->frees; 4000b814: 86 00 e0 01 inc %g3 stats->free_size += block_size; 4000b818: 82 00 40 1b add %g1, %i3, %g1 stats->lifetime_freed += block_size; 4000b81c: 98 47 20 00 addx %i4, 0, %o4 --stats->used_blocks; 4000b820: c8 26 20 4c st %g4, [ %i0 + 0x4c ] ++stats->frees; 4000b824: c6 26 20 60 st %g3, [ %i0 + 0x60 ] stats->free_size += block_size; 4000b828: c2 26 20 3c st %g1, [ %i0 + 0x3c ] stats->lifetime_freed += block_size; 4000b82c: d8 3e 20 30 std %o4, [ %i0 + 0x30 ] return( true ); } 4000b830: b0 08 a0 ff and %g2, 0xff, %i0 4000b834: 81 c7 e0 08 ret 4000b838: 81 e8 00 00 restore if ( !_Heap_Is_prev_used( block ) ) { 4000b83c: 80 a7 60 00 cmp %i5, 0 4000b840: 12 80 00 20 bne 4000b8c0 <_Heap_Free+0x1a0> 4000b844: 9e 10 20 00 clr %o7 uintptr_t const prev_size = block->prev_size; 4000b848: f2 00 40 00 ld [ %g1 ], %i1 return (Heap_Block *) ((uintptr_t) block + offset); 4000b84c: ba 20 40 19 sub %g1, %i1, %i5 && (uintptr_t) block <= (uintptr_t) heap->last_block; 4000b850: 80 a7 40 04 cmp %i5, %g4 4000b854: 2a bf ff f7 bcs,a 4000b830 <_Heap_Free+0x110> <== NEVER TAKEN 4000b858: 84 10 20 00 clr %g2 <== NOT EXECUTED 4000b85c: 80 a7 40 1a cmp %i5, %i2 4000b860: 38 bf ff f4 bgu,a 4000b830 <_Heap_Free+0x110> <== NEVER TAKEN 4000b864: 84 10 20 00 clr %g2 <== NOT EXECUTED return block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000b868: c8 07 60 04 ld [ %i5 + 4 ], %g4 if ( !_Heap_Is_prev_used ( prev_block) ) { 4000b86c: 80 89 20 01 btst 1, %g4 4000b870: 02 80 00 2f be 4000b92c <_Heap_Free+0x20c> <== NEVER TAKEN 4000b874: b4 09 20 01 and %g4, 1, %i2 if ( next_is_free ) { /* coalesce both */ 4000b878: 80 a3 e0 00 cmp %o7, 0 4000b87c: 02 80 00 25 be 4000b910 <_Heap_Free+0x1f0> 4000b880: b2 06 40 1b add %i1, %i3, %i1 Heap_Block *next = block->next; 4000b884: c8 00 e0 08 ld [ %g3 + 8 ], %g4 Heap_Block *prev = block->prev; 4000b888: c6 00 e0 0c ld [ %g3 + 0xc ], %g3 prev->next = next; 4000b88c: c8 20 e0 08 st %g4, [ %g3 + 8 ] uintptr_t const size = block_size + prev_size + next_block_size; 4000b890: b8 07 00 19 add %i4, %i1, %i4 stats->free_blocks -= 1; 4000b894: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 next->prev = prev; 4000b898: c6 21 20 0c st %g3, [ %g4 + 0xc ] 4000b89c: 82 00 7f ff add %g1, -1, %g1 4000b8a0: c2 26 20 44 st %g1, [ %i0 + 0x44 ] prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 4000b8a4: 82 17 20 01 or %i4, 1, %g1 4000b8a8: c2 27 60 04 st %g1, [ %i5 + 4 ] next_block->prev_size = size; 4000b8ac: 10 bf ff d4 b 4000b7fc <_Heap_Free+0xdc> 4000b8b0: f8 27 40 1c st %i4, [ %i5 + %i4 ] } 4000b8b4: b0 08 a0 ff and %g2, 0xff, %i0 4000b8b8: 81 c7 e0 08 ret 4000b8bc: 81 e8 00 00 restore Heap_Block *next = block_before->next; 4000b8c0: fa 06 20 08 ld [ %i0 + 8 ], %i5 new_block->next = next; 4000b8c4: fa 20 60 08 st %i5, [ %g1 + 8 ] block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; 4000b8c8: 88 16 e0 01 or %i3, 1, %g4 new_block->prev = block_before; 4000b8cc: f0 20 60 0c st %i0, [ %g1 + 0xc ] block_before->next = new_block; 4000b8d0: c2 26 20 08 st %g1, [ %i0 + 8 ] next->prev = new_block; 4000b8d4: c2 27 60 0c st %g1, [ %i5 + 0xc ] 4000b8d8: c8 20 60 04 st %g4, [ %g1 + 4 ] next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 4000b8dc: c8 00 e0 04 ld [ %g3 + 4 ], %g4 4000b8e0: 88 09 3f fe and %g4, -2, %g4 4000b8e4: c8 20 e0 04 st %g4, [ %g3 + 4 ] ++stats->free_blocks; 4000b8e8: c6 06 20 44 ld [ %i0 + 0x44 ], %g3 next_block->prev_size = block_size; 4000b8ec: f6 20 40 1b st %i3, [ %g1 + %i3 ] ++stats->free_blocks; 4000b8f0: 82 00 e0 01 add %g3, 1, %g1 4000b8f4: c2 26 20 44 st %g1, [ %i0 + 0x44 ] if ( stats->max_free_blocks < stats->free_blocks ) { 4000b8f8: c6 06 20 48 ld [ %i0 + 0x48 ], %g3 4000b8fc: 80 a0 40 03 cmp %g1, %g3 4000b900: 38 bf ff bf bgu,a 4000b7fc <_Heap_Free+0xdc> 4000b904: c2 26 20 48 st %g1, [ %i0 + 0x48 ] stats->lifetime_freed += block_size; 4000b908: 10 bf ff be b 4000b800 <_Heap_Free+0xe0> 4000b90c: f8 1e 20 30 ldd [ %i0 + 0x30 ], %i4 prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 4000b910: 88 16 60 01 or %i1, 1, %g4 4000b914: c8 27 60 04 st %g4, [ %i5 + 4 ] next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 4000b918: c8 00 e0 04 ld [ %g3 + 4 ], %g4 4000b91c: 88 09 3f fe and %g4, -2, %g4 4000b920: c8 20 e0 04 st %g4, [ %g3 + 4 ] next_block->prev_size = size; 4000b924: 10 bf ff b6 b 4000b7fc <_Heap_Free+0xdc> 4000b928: f2 20 40 1b st %i1, [ %g1 + %i3 ] return false; 4000b92c: 10 bf ff c1 b 4000b830 <_Heap_Free+0x110> <== NOT EXECUTED 4000b930: 84 10 00 1a mov %i2, %g2 <== NOT EXECUTED =============================================================================== 400081c8 <_Heap_Get_first_and_last_block>: _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 400081c8: 84 02 20 08 add %o0, 8, %g2 uintptr_t remainder = value % alignment; 400081cc: 81 80 20 00 wr %g0, %y 400081d0: 01 00 00 00 nop 400081d4: 01 00 00 00 nop 400081d8: 01 00 00 00 nop 400081dc: 82 70 80 0a udiv %g2, %o2, %g1 400081e0: 82 58 40 0a smul %g1, %o2, %g1 if ( remainder != 0 ) { 400081e4: 82 a0 80 01 subcc %g2, %g1, %g1 400081e8: 02 80 00 1f be 40008264 <_Heap_Get_first_and_last_block+0x9c> 400081ec: 88 02 00 09 add %o0, %o1, %g4 uintptr_t const first_block_begin = 400081f0: 86 02 bf f8 add %o2, -8, %g3 400081f4: 84 00 c0 02 add %g3, %g2, %g2 400081f8: 82 20 80 01 sub %g2, %g1, %g1 uintptr_t const overhead = 400081fc: 84 20 40 08 sub %g1, %o0, %g2 40008200: 84 00 a0 08 add %g2, 8, %g2 heap_area_end < heap_area_begin 40008204: 80 a1 00 08 cmp %g4, %o0 40008208: 86 40 20 00 addx %g0, 0, %g3 || heap_area_size <= overhead 4000820c: 80 a0 80 09 cmp %g2, %o1 _Heap_Align_down( heap_area_size - overhead, page_size ); 40008210: 92 22 40 02 sub %o1, %g2, %o1 || heap_area_size <= overhead 40008214: 84 60 3f ff subx %g0, -1, %g2 return value - (value % alignment); 40008218: 81 80 20 00 wr %g0, %y 4000821c: 01 00 00 00 nop 40008220: 01 00 00 00 nop 40008224: 01 00 00 00 nop 40008228: 92 72 40 0a udiv %o1, %o2, %o1 || first_block_size < min_block_size 4000822c: 80 90 c0 02 orcc %g3, %g2, %g0 40008230: 12 80 00 0a bne 40008258 <_Heap_Get_first_and_last_block+0x90> 40008234: 94 5a 40 0a smul %o1, %o2, %o2 40008238: 80 a2 80 0b cmp %o2, %o3 4000823c: 0a 80 00 07 bcs 40008258 <_Heap_Get_first_and_last_block+0x90> <== NEVER TAKEN 40008240: 94 02 80 01 add %o2, %g1, %o2 *first_block_ptr = first_block; 40008244: c2 23 00 00 st %g1, [ %o4 ] return true; 40008248: 90 10 20 01 mov 1, %o0 *last_block_ptr = last_block; 4000824c: d4 23 40 00 st %o2, [ %o5 ] } 40008250: 81 c3 e0 08 retl 40008254: 90 0a 20 01 and %o0, 1, %o0 return false; 40008258: 90 10 20 00 clr %o0 } 4000825c: 81 c3 e0 08 retl 40008260: 90 0a 20 01 and %o0, 1, %o0 40008264: 82 10 00 08 mov %o0, %g1 40008268: 10 bf ff e7 b 40008204 <_Heap_Get_first_and_last_block+0x3c> 4000826c: 84 10 20 08 mov 8, %g2 =============================================================================== 4000dd14 <_Heap_Get_free_information>: ) { Heap_Block *the_block; Heap_Block *const tail = _Heap_Free_list_tail(the_heap); info->number = 0; 4000dd14: c0 22 40 00 clr [ %o1 ] info->largest = 0; 4000dd18: c0 22 60 04 clr [ %o1 + 4 ] info->total = 0; 4000dd1c: c0 22 60 08 clr [ %o1 + 8 ] return _Heap_Free_list_head(heap)->next; 4000dd20: c4 02 20 08 ld [ %o0 + 8 ], %g2 for(the_block = _Heap_Free_list_first(the_heap); 4000dd24: 80 a2 00 02 cmp %o0, %g2 4000dd28: 02 80 00 13 be 4000dd74 <_Heap_Get_free_information+0x60> <== NEVER TAKEN 4000dd2c: 88 10 20 01 mov 1, %g4 4000dd30: 9a 10 20 00 clr %o5 4000dd34: 10 80 00 04 b 4000dd44 <_Heap_Get_free_information+0x30> 4000dd38: 86 10 20 00 clr %g3 /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; info->total += the_size; if ( info->largest < the_size ) 4000dd3c: da 02 60 04 ld [ %o1 + 4 ], %o5 4000dd40: 88 10 00 01 mov %g1, %g4 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000dd44: c2 00 a0 04 ld [ %g2 + 4 ], %g1 4000dd48: 82 08 7f fe and %g1, -2, %g1 4000dd4c: 80 a0 40 0d cmp %g1, %o5 4000dd50: 08 80 00 03 bleu 4000dd5c <_Heap_Get_free_information+0x48> 4000dd54: 86 00 c0 01 add %g3, %g1, %g3 info->largest = the_size; 4000dd58: c2 22 60 04 st %g1, [ %o1 + 4 ] the_block = the_block->next) 4000dd5c: c4 00 a0 08 ld [ %g2 + 8 ], %g2 for(the_block = _Heap_Free_list_first(the_heap); 4000dd60: 80 a2 00 02 cmp %o0, %g2 4000dd64: 12 bf ff f6 bne 4000dd3c <_Heap_Get_free_information+0x28> 4000dd68: 82 01 20 01 add %g4, 1, %g1 4000dd6c: c8 22 40 00 st %g4, [ %o1 ] 4000dd70: c6 22 60 08 st %g3, [ %o1 + 8 ] } } 4000dd74: 81 c3 e0 08 retl 4000dd78: 01 00 00 00 nop =============================================================================== 40006cf0 <_Heap_Greedy_allocate>: Heap_Block *_Heap_Greedy_allocate( Heap_Control *heap, const uintptr_t *block_sizes, size_t block_count ) { 40006cf0: 9d e3 bf a0 save %sp, -96, %sp Heap_Block *current; size_t i; _Heap_Protection_free_all_delayed_blocks( heap ); for (i = 0; i < block_count; ++i) { 40006cf4: 80 a6 a0 00 cmp %i2, 0 40006cf8: 02 80 00 38 be 40006dd8 <_Heap_Greedy_allocate+0xe8> 40006cfc: b8 10 00 18 mov %i0, %i4 40006d00: ba 10 20 00 clr %i5 Heap_Block *allocated_blocks = NULL; 40006d04: b6 10 20 00 clr %i3 void *next = _Heap_Allocate( heap, block_sizes [i] ); 40006d08: 83 2f 60 02 sll %i5, 2, %g1 * @retval pointer The starting address of the allocated memory area. * @retval NULL No memory is available of the parameters are inconsistent. */ RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size ) { return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 40006d0c: d2 06 40 01 ld [ %i1 + %g1 ], %o1 40006d10: 96 10 20 00 clr %o3 40006d14: 94 10 20 00 clr %o2 40006d18: 40 00 14 66 call 4000beb0 <_Heap_Allocate_aligned_with_boundary> 40006d1c: 90 10 00 1c mov %i4, %o0 if ( next != NULL ) { 40006d20: 80 a2 20 00 cmp %o0, 0 40006d24: 02 80 00 0c be 40006d54 <_Heap_Greedy_allocate+0x64> 40006d28: ba 07 60 01 inc %i5 RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 40006d2c: c4 07 20 10 ld [ %i4 + 0x10 ], %g2 40006d30: 81 80 20 00 wr %g0, %y 40006d34: 01 00 00 00 nop 40006d38: 01 00 00 00 nop 40006d3c: 01 00 00 00 nop 40006d40: 82 72 00 02 udiv %o0, %g2, %g1 40006d44: 82 58 40 02 smul %g1, %g2, %g1 Heap_Block *next_block = _Heap_Block_of_alloc_area( (uintptr_t) next, heap->page_size ); next_block->next = allocated_blocks; 40006d48: f6 20 40 00 st %i3, [ %g1 ] uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 40006d4c: 82 00 7f f8 add %g1, -8, %g1 40006d50: b6 10 00 01 mov %g1, %i3 for (i = 0; i < block_count; ++i) { 40006d54: 80 a6 80 1d cmp %i2, %i5 40006d58: 12 bf ff ed bne 40006d0c <_Heap_Greedy_allocate+0x1c> 40006d5c: 83 2f 60 02 sll %i5, 2, %g1 return _Heap_Free_list_head(heap)->next; 40006d60: fa 07 20 08 ld [ %i4 + 8 ], %i5 allocated_blocks = next_block; } } while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { 40006d64: 80 a7 00 1d cmp %i4, %i5 40006d68: 02 80 00 17 be 40006dc4 <_Heap_Greedy_allocate+0xd4> 40006d6c: b0 10 20 00 clr %i0 Heap_Block *blocks = NULL; 40006d70: b0 10 20 00 clr %i0 * * @return The block size. */ RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40006d74: d6 07 60 04 ld [ %i5 + 4 ], %o3 _Heap_Block_allocate( 40006d78: 94 07 60 08 add %i5, 8, %o2 40006d7c: 92 10 00 1d mov %i5, %o1 40006d80: 96 0a ff fe and %o3, -2, %o3 40006d84: 90 10 00 1c mov %i4, %o0 40006d88: 40 00 15 c9 call 4000c4ac <_Heap_Block_allocate> 40006d8c: 96 02 ff f8 add %o3, -8, %o3 current, _Heap_Alloc_area_of_block( current ), _Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE ); current->next = blocks; 40006d90: f0 27 60 08 st %i0, [ %i5 + 8 ] return &heap->free_list; 40006d94: b0 10 00 1d mov %i5, %i0 return _Heap_Free_list_head(heap)->next; 40006d98: fa 07 20 08 ld [ %i4 + 8 ], %i5 while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { 40006d9c: 80 a7 00 1d cmp %i4, %i5 40006da0: 32 bf ff f6 bne,a 40006d78 <_Heap_Greedy_allocate+0x88> 40006da4: d6 07 60 04 ld [ %i5 + 4 ], %o3 blocks = current; } while ( allocated_blocks != NULL ) { 40006da8: 80 a6 e0 00 cmp %i3, 0 40006dac: 02 80 00 09 be 40006dd0 <_Heap_Greedy_allocate+0xe0> 40006db0: 92 10 00 1b mov %i3, %o1 current = allocated_blocks; allocated_blocks = allocated_blocks->next; _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); 40006db4: 90 10 00 1c mov %i4, %o0 allocated_blocks = allocated_blocks->next; 40006db8: f6 06 e0 08 ld [ %i3 + 8 ], %i3 _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); 40006dbc: 40 00 16 f1 call 4000c980 <_Heap_Free> 40006dc0: 92 02 60 08 add %o1, 8, %o1 while ( allocated_blocks != NULL ) { 40006dc4: 80 a6 e0 00 cmp %i3, 0 40006dc8: 12 bf ff fb bne 40006db4 <_Heap_Greedy_allocate+0xc4> 40006dcc: 92 10 00 1b mov %i3, %o1 } return blocks; } 40006dd0: 81 c7 e0 08 ret 40006dd4: 81 e8 00 00 restore 40006dd8: fa 06 20 08 ld [ %i0 + 8 ], %i5 while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { 40006ddc: 80 a7 40 18 cmp %i5, %i0 40006de0: 12 bf ff e4 bne 40006d70 <_Heap_Greedy_allocate+0x80> <== ALWAYS TAKEN 40006de4: b6 10 20 00 clr %i3 Heap_Block *blocks = NULL; 40006de8: 81 c7 e0 08 ret <== NOT EXECUTED 40006dec: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED =============================================================================== 400049b8 <_Heap_Greedy_allocate_all_except_largest>: Heap_Block *_Heap_Greedy_allocate_all_except_largest( Heap_Control *heap, uintptr_t *allocatable_size ) { 400049b8: 9d e3 bf 90 save %sp, -112, %sp Heap_Information info; _Heap_Get_free_information( heap, &info ); 400049bc: 92 07 bf f4 add %fp, -12, %o1 400049c0: 40 00 13 fb call 400099ac <_Heap_Get_free_information> 400049c4: 90 10 00 18 mov %i0, %o0 if ( info.largest > 0 ) { 400049c8: c2 07 bf f8 ld [ %fp + -8 ], %g1 400049cc: 80 a0 60 00 cmp %g1, 0 400049d0: 32 80 00 02 bne,a 400049d8 <_Heap_Greedy_allocate_all_except_largest+0x20><== ALWAYS TAKEN 400049d4: 82 00 7f fc add %g1, -4, %g1 *allocatable_size = info.largest - HEAP_BLOCK_HEADER_SIZE + HEAP_ALLOC_BONUS; 400049d8: c2 26 40 00 st %g1, [ %i1 ] } else { *allocatable_size = 0; } return _Heap_Greedy_allocate( heap, allocatable_size, 1 ); 400049dc: 94 10 20 01 mov 1, %o2 400049e0: 92 10 00 19 mov %i1, %o1 400049e4: 7f ff ff b5 call 400048b8 <_Heap_Greedy_allocate> 400049e8: 90 10 00 18 mov %i0, %o0 } 400049ec: 81 c7 e0 08 ret 400049f0: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 40008478 <_Heap_Iterate>: void _Heap_Iterate( Heap_Control *heap, Heap_Block_visitor visitor, void *visitor_arg ) { 40008478: 9d e3 bf a0 save %sp, -96, %sp Heap_Block *current = heap->first_block; 4000847c: fa 06 20 20 ld [ %i0 + 0x20 ], %i5 Heap_Block *end = heap->last_block; 40008480: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 bool stop = false; while ( !stop && current != end ) { 40008484: 80 a7 40 1c cmp %i5, %i4 40008488: 02 80 00 10 be 400084c8 <_Heap_Iterate+0x50> <== NEVER TAKEN 4000848c: 01 00 00 00 nop return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40008490: d2 07 60 04 ld [ %i5 + 4 ], %o1 40008494: 92 0a 7f fe and %o1, -2, %o1 return (Heap_Block *) ((uintptr_t) block + offset); 40008498: 90 10 00 1d mov %i5, %o0 4000849c: ba 07 40 09 add %i5, %o1, %i5 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 400084a0: d4 07 60 04 ld [ %i5 + 4 ], %o2 uintptr_t size = _Heap_Block_size( current ); Heap_Block *next = _Heap_Block_at( current, size ); bool used = _Heap_Is_prev_used( next ); stop = (*visitor)( current, size, used, visitor_arg ); 400084a4: 96 10 00 1a mov %i2, %o3 400084a8: 9f c6 40 00 call %i1 400084ac: 94 0a a0 01 and %o2, 1, %o2 while ( !stop && current != end ) { 400084b0: 90 1a 20 01 xor %o0, 1, %o0 400084b4: 80 8a 20 ff btst 0xff, %o0 400084b8: 02 80 00 04 be 400084c8 <_Heap_Iterate+0x50> <== NEVER TAKEN 400084bc: 80 a7 00 1d cmp %i4, %i5 400084c0: 32 bf ff f5 bne,a 40008494 <_Heap_Iterate+0x1c> 400084c4: d2 07 60 04 ld [ %i5 + 4 ], %o1 current = next; } } 400084c8: 81 c7 e0 08 ret 400084cc: 81 e8 00 00 restore =============================================================================== 4000613c <_Heap_Size_of_alloc_area>: return value - (value % alignment); 4000613c: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 return (uintptr_t) block >= (uintptr_t) heap->first_block 40006140: c8 02 20 20 ld [ %o0 + 0x20 ], %g4 return value - (value % alignment); 40006144: 81 80 20 00 wr %g0, %y 40006148: 01 00 00 00 nop 4000614c: 01 00 00 00 nop 40006150: 01 00 00 00 nop 40006154: 82 72 40 02 udiv %o1, %g2, %g1 40006158: 82 58 40 02 smul %g1, %g2, %g1 - HEAP_BLOCK_HEADER_SIZE); 4000615c: 82 00 7f f8 add %g1, -8, %g1 && (uintptr_t) block <= (uintptr_t) heap->last_block; 40006160: 80 a1 00 01 cmp %g4, %g1 40006164: 18 80 00 16 bgu 400061bc <_Heap_Size_of_alloc_area+0x80> <== NEVER TAKEN 40006168: 86 10 20 00 clr %g3 4000616c: da 02 20 24 ld [ %o0 + 0x24 ], %o5 40006170: 80 a3 40 01 cmp %o5, %g1 40006174: 0a 80 00 12 bcs 400061bc <_Heap_Size_of_alloc_area+0x80> <== NEVER TAKEN 40006178: 01 00 00 00 nop return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000617c: c4 00 60 04 ld [ %g1 + 4 ], %g2 40006180: 84 08 bf fe and %g2, -2, %g2 return (Heap_Block *) ((uintptr_t) block + offset); 40006184: 82 00 80 01 add %g2, %g1, %g1 && (uintptr_t) block <= (uintptr_t) heap->last_block; 40006188: 80 a1 00 01 cmp %g4, %g1 4000618c: 18 80 00 0c bgu 400061bc <_Heap_Size_of_alloc_area+0x80> <== NEVER TAKEN 40006190: 80 a3 40 01 cmp %o5, %g1 40006194: 0a 80 00 0a bcs 400061bc <_Heap_Size_of_alloc_area+0x80> <== NEVER TAKEN 40006198: 01 00 00 00 nop return block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000619c: c4 00 60 04 ld [ %g1 + 4 ], %g2 400061a0: 84 08 a0 01 and %g2, 1, %g2 block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) 400061a4: 80 a0 a0 00 cmp %g2, 0 400061a8: 02 80 00 05 be 400061bc <_Heap_Size_of_alloc_area+0x80> <== NEVER TAKEN 400061ac: 86 10 00 02 mov %g2, %g3 ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 400061b0: 82 20 40 09 sub %g1, %o1, %g1 400061b4: 82 00 60 04 add %g1, 4, %g1 400061b8: c2 22 80 00 st %g1, [ %o2 ] return true; } 400061bc: 81 c3 e0 08 retl 400061c0: 90 08 e0 ff and %g3, 0xff, %o0 =============================================================================== 4001522c <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 4001522c: 9d e3 bf 78 save %sp, -136, %sp uintptr_t const min_block_size = heap->min_block_size; Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block; Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 40015230: 80 a6 a0 00 cmp %i2, 0 40015234: 12 80 00 0c bne 40015264 <_Heap_Walk+0x38> 40015238: 90 10 00 19 mov %i1, %o0 return _System_state_Current; 4001523c: 03 10 02 6a sethi %hi(0x4009a800), %g1 if ( !_System_state_Is_up( _System_state_Get() ) ) { 40015240: c2 00 61 cc ld [ %g1 + 0x1cc ], %g1 ! 4009a9cc <_System_state_Current> _Heap_Walk_print : _Heap_Walk_print_nothing; 40015244: 37 10 00 54 sethi %hi(0x40015000), %i3 if ( !_System_state_Is_up( _System_state_Get() ) ) { 40015248: 80 a0 60 02 cmp %g1, 2 4001524c: 02 80 00 0c be 4001527c <_Heap_Walk+0x50> 40015250: b6 16 e1 c0 or %i3, 0x1c0, %i3 return true; 40015254: b8 10 20 01 mov 1, %i4 block = next_block; } while ( block != first_block ); return true; } 40015258: b0 0f 20 ff and %i4, 0xff, %i0 4001525c: 81 c7 e0 08 ret 40015260: 81 e8 00 00 restore 40015264: 03 10 02 6a sethi %hi(0x4009a800), %g1 if ( !_System_state_Is_up( _System_state_Get() ) ) { 40015268: c2 00 61 cc ld [ %g1 + 0x1cc ], %g1 ! 4009a9cc <_System_state_Current> _Heap_Walk_print : _Heap_Walk_print_nothing; 4001526c: 37 10 00 54 sethi %hi(0x40015000), %i3 if ( !_System_state_Is_up( _System_state_Get() ) ) { 40015270: 80 a0 60 02 cmp %g1, 2 40015274: 12 bf ff f8 bne 40015254 <_Heap_Walk+0x28> <== NEVER TAKEN 40015278: b6 16 e1 c8 or %i3, 0x1c8, %i3 Heap_Block *const first_block = heap->first_block; 4001527c: fa 06 20 20 ld [ %i0 + 0x20 ], %i5 Heap_Block *const last_block = heap->last_block; 40015280: f4 06 20 24 ld [ %i0 + 0x24 ], %i2 (*printer)( 40015284: c6 06 20 0c ld [ %i0 + 0xc ], %g3 40015288: c4 06 20 08 ld [ %i0 + 8 ], %g2 4001528c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 40015290: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 40015294: 15 10 02 18 sethi %hi(0x40086000), %o2 40015298: c6 23 a0 6c st %g3, [ %sp + 0x6c ] 4001529c: 94 12 a3 88 or %o2, 0x388, %o2 400152a0: c4 23 a0 68 st %g2, [ %sp + 0x68 ] 400152a4: 92 10 20 00 clr %o1 400152a8: f4 23 a0 64 st %i2, [ %sp + 0x64 ] 400152ac: fa 23 a0 60 st %i5, [ %sp + 0x60 ] uintptr_t const page_size = heap->page_size; 400152b0: f2 06 20 10 ld [ %i0 + 0x10 ], %i1 uintptr_t const min_block_size = heap->min_block_size; 400152b4: e2 06 20 14 ld [ %i0 + 0x14 ], %l1 (*printer)( 400152b8: da 06 20 18 ld [ %i0 + 0x18 ], %o5 400152bc: d0 27 bf fc st %o0, [ %fp + -4 ] 400152c0: 98 10 00 11 mov %l1, %o4 400152c4: 9f c6 c0 00 call %i3 400152c8: 96 10 00 19 mov %i1, %o3 if ( page_size == 0 ) { 400152cc: 80 a6 60 00 cmp %i1, 0 400152d0: 02 80 00 36 be 400153a8 <_Heap_Walk+0x17c> 400152d4: d0 07 bf fc ld [ %fp + -4 ], %o0 if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 400152d8: 80 8e 60 07 btst 7, %i1 400152dc: 32 80 00 2b bne,a 40015388 <_Heap_Walk+0x15c> 400152e0: 96 10 00 19 mov %i1, %o3 return (value % alignment) == 0; 400152e4: 81 80 20 00 wr %g0, %y 400152e8: 01 00 00 00 nop 400152ec: 01 00 00 00 nop 400152f0: 01 00 00 00 nop 400152f4: 82 74 40 19 udiv %l1, %i1, %g1 400152f8: 82 58 40 19 smul %g1, %i1, %g1 if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 400152fc: 80 a4 40 01 cmp %l1, %g1 40015300: 12 80 00 39 bne 400153e4 <_Heap_Walk+0x1b8> 40015304: 84 07 60 08 add %i5, 8, %g2 40015308: 81 80 20 00 wr %g0, %y 4001530c: 01 00 00 00 nop 40015310: 01 00 00 00 nop 40015314: 01 00 00 00 nop 40015318: 82 70 80 19 udiv %g2, %i1, %g1 4001531c: 82 58 40 19 smul %g1, %i1, %g1 if ( 40015320: 80 a0 80 01 cmp %g2, %g1 40015324: 32 80 00 39 bne,a 40015408 <_Heap_Walk+0x1dc> 40015328: 96 10 00 1d mov %i5, %o3 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 4001532c: c2 07 60 04 ld [ %i5 + 4 ], %g1 40015330: 82 08 60 01 and %g1, 1, %g1 if ( !_Heap_Is_prev_used( first_block ) ) { 40015334: 80 a0 60 00 cmp %g1, 0 40015338: 02 80 00 24 be 400153c8 <_Heap_Walk+0x19c> 4001533c: b8 10 00 01 mov %g1, %i4 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40015340: e0 06 a0 04 ld [ %i2 + 4 ], %l0 40015344: a0 0c 3f fe and %l0, -2, %l0 return (Heap_Block *) ((uintptr_t) block + offset); 40015348: a0 06 80 10 add %i2, %l0, %l0 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 4001534c: d8 04 20 04 ld [ %l0 + 4 ], %o4 40015350: ae 0b 20 01 and %o4, 1, %l7 if ( _Heap_Is_free( last_block ) ) { 40015354: 80 a5 e0 00 cmp %l7, 0 40015358: 02 80 00 34 be 40015428 <_Heap_Walk+0x1fc> 4001535c: b8 10 00 17 mov %l7, %i4 if ( 40015360: 80 a7 40 10 cmp %i5, %l0 40015364: 02 80 00 38 be 40015444 <_Heap_Walk+0x218> 40015368: 92 10 20 01 mov 1, %o1 (*printer)( 4001536c: 15 10 02 19 sethi %hi(0x40086400), %o2 return false; 40015370: b8 10 20 00 clr %i4 (*printer)( 40015374: 9f c6 c0 00 call %i3 40015378: 94 12 a1 00 or %o2, 0x100, %o2 return false; 4001537c: b0 0f 20 ff and %i4, 0xff, %i0 40015380: 81 c7 e0 08 ret 40015384: 81 e8 00 00 restore (*printer)( 40015388: 92 10 20 01 mov 1, %o1 4001538c: 15 10 02 19 sethi %hi(0x40086400), %o2 return false; 40015390: b8 10 20 00 clr %i4 (*printer)( 40015394: 9f c6 c0 00 call %i3 40015398: 94 12 a0 38 or %o2, 0x38, %o2 return false; 4001539c: b0 0f 20 ff and %i4, 0xff, %i0 400153a0: 81 c7 e0 08 ret 400153a4: 81 e8 00 00 restore (*printer)( source, true, "page size is zero\n" ); 400153a8: 92 10 20 01 mov 1, %o1 return false; 400153ac: b8 10 20 00 clr %i4 (*printer)( source, true, "page size is zero\n" ); 400153b0: 15 10 02 19 sethi %hi(0x40086400), %o2 } 400153b4: b0 0f 20 ff and %i4, 0xff, %i0 (*printer)( source, true, "page size is zero\n" ); 400153b8: 9f c6 c0 00 call %i3 400153bc: 94 12 a0 20 or %o2, 0x20, %o2 } 400153c0: 81 c7 e0 08 ret 400153c4: 81 e8 00 00 restore (*printer)( 400153c8: 92 10 20 01 mov 1, %o1 400153cc: 15 10 02 19 sethi %hi(0x40086400), %o2 400153d0: 9f c6 c0 00 call %i3 400153d4: 94 12 a0 b8 or %o2, 0xb8, %o2 ! 400864b8 <_Objects_Information_table+0x1e8> return false; 400153d8: b0 0f 20 ff and %i4, 0xff, %i0 400153dc: 81 c7 e0 08 ret 400153e0: 81 e8 00 00 restore (*printer)( 400153e4: 96 10 00 11 mov %l1, %o3 400153e8: 92 10 20 01 mov 1, %o1 400153ec: 15 10 02 19 sethi %hi(0x40086400), %o2 return false; 400153f0: b8 10 20 00 clr %i4 (*printer)( 400153f4: 9f c6 c0 00 call %i3 400153f8: 94 12 a0 58 or %o2, 0x58, %o2 return false; 400153fc: b0 0f 20 ff and %i4, 0xff, %i0 40015400: 81 c7 e0 08 ret 40015404: 81 e8 00 00 restore (*printer)( 40015408: 92 10 20 01 mov 1, %o1 4001540c: 15 10 02 19 sethi %hi(0x40086400), %o2 return false; 40015410: b8 10 20 00 clr %i4 (*printer)( 40015414: 9f c6 c0 00 call %i3 40015418: 94 12 a0 80 or %o2, 0x80, %o2 return false; 4001541c: b0 0f 20 ff and %i4, 0xff, %i0 40015420: 81 c7 e0 08 ret 40015424: 81 e8 00 00 restore (*printer)( 40015428: 92 10 20 01 mov 1, %o1 4001542c: 15 10 02 19 sethi %hi(0x40086400), %o2 40015430: 9f c6 c0 00 call %i3 40015434: 94 12 a0 e8 or %o2, 0xe8, %o2 ! 400864e8 <_Objects_Information_table+0x218> return false; 40015438: b0 0f 20 ff and %i4, 0xff, %i0 4001543c: 81 c7 e0 08 ret 40015440: 81 e8 00 00 restore return _Heap_Free_list_head(heap)->next; 40015444: d6 06 20 08 ld [ %i0 + 8 ], %o3 uintptr_t const page_size = heap->page_size; 40015448: c8 06 20 10 ld [ %i0 + 0x10 ], %g4 while ( free_block != free_list_tail ) { 4001544c: 80 a6 00 0b cmp %i0, %o3 40015450: 02 80 00 2d be 40015504 <_Heap_Walk+0x2d8> 40015454: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 40015458: ba 10 00 18 mov %i0, %i5 && (uintptr_t) block <= (uintptr_t) heap->last_block; 4001545c: 80 a2 c0 02 cmp %o3, %g2 40015460: 3a 80 00 0a bcc,a 40015488 <_Heap_Walk+0x25c> 40015464: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 (*printer)( 40015468: 92 10 20 01 mov 1, %o1 4001546c: 15 10 02 19 sethi %hi(0x40086400), %o2 return false; 40015470: b8 10 20 00 clr %i4 (*printer)( 40015474: 9f c6 c0 00 call %i3 40015478: 94 12 a3 38 or %o2, 0x338, %o2 return false; 4001547c: b0 0f 20 ff and %i4, 0xff, %i0 40015480: 81 c7 e0 08 ret 40015484: 81 e8 00 00 restore 40015488: 80 a0 40 0b cmp %g1, %o3 4001548c: 0a bf ff f8 bcs 4001546c <_Heap_Walk+0x240> <== NEVER TAKEN 40015490: 92 10 20 01 mov 1, %o1 return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 40015494: 86 02 e0 08 add %o3, 8, %g3 return (value % alignment) == 0; 40015498: 81 80 20 00 wr %g0, %y 4001549c: 01 00 00 00 nop 400154a0: 01 00 00 00 nop 400154a4: 01 00 00 00 nop 400154a8: 82 70 c0 04 udiv %g3, %g4, %g1 400154ac: 82 58 40 04 smul %g1, %g4, %g1 if ( 400154b0: 80 a0 c0 01 cmp %g3, %g1 400154b4: 12 80 00 cb bne 400157e0 <_Heap_Walk+0x5b4> 400154b8: 15 10 02 19 sethi %hi(0x40086400), %o2 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 400154bc: c2 02 e0 04 ld [ %o3 + 4 ], %g1 400154c0: 82 08 7f fe and %g1, -2, %g1 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 400154c4: 82 00 40 0b add %g1, %o3, %g1 400154c8: f8 00 60 04 ld [ %g1 + 4 ], %i4 400154cc: b8 0f 20 01 and %i4, 1, %i4 if ( _Heap_Is_used( free_block ) ) { 400154d0: 80 a7 20 00 cmp %i4, 0 400154d4: 12 80 00 bd bne 400157c8 <_Heap_Walk+0x59c> 400154d8: 15 10 02 19 sethi %hi(0x40086400), %o2 if ( free_block->prev != prev_block ) { 400154dc: c2 02 e0 0c ld [ %o3 + 0xc ], %g1 400154e0: 80 a0 40 1d cmp %g1, %i5 400154e4: 32 80 00 c5 bne,a 400157f8 <_Heap_Walk+0x5cc> 400154e8: 98 10 00 01 mov %g1, %o4 free_block = free_block->next; 400154ec: c2 02 e0 08 ld [ %o3 + 8 ], %g1 while ( free_block != free_list_tail ) { 400154f0: 80 a6 00 01 cmp %i0, %g1 400154f4: 02 80 00 04 be 40015504 <_Heap_Walk+0x2d8> 400154f8: ba 10 00 0b mov %o3, %i5 400154fc: 10 bf ff d8 b 4001545c <_Heap_Walk+0x230> 40015500: 96 10 00 01 mov %g1, %o3 : (block->prev == free_list_head ? " (= head)" : ""), 40015504: 2b 10 02 18 sethi %hi(0x40086000), %l5 40015508: 82 15 63 58 or %l5, 0x358, %g1 ! 40086358 <_Objects_Information_table+0x88> 4001550c: c2 27 bf f0 st %g1, [ %fp + -16 ] (*printer)( 40015510: 27 10 02 18 sethi %hi(0x40086000), %l3 : (block->next == free_list_tail ? " (= tail)" : "") 40015514: 2d 10 02 18 sethi %hi(0x40086000), %l6 40015518: 29 10 02 2f sethi %hi(0x4008bc00), %l4 (*printer)( 4001551c: 25 10 02 18 sethi %hi(0x40086000), %l2 while ( free_block != free_list_tail ) { 40015520: 96 10 00 10 mov %l0, %o3 (*printer)( 40015524: a6 14 e3 68 or %l3, 0x368, %l3 : (block->next == free_list_tail ? " (= tail)" : "") 40015528: ac 15 a3 78 or %l6, 0x378, %l6 4001552c: a8 15 20 b8 or %l4, 0xb8, %l4 (*printer)( 40015530: a4 14 a3 48 or %l2, 0x348, %l2 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40015534: 98 0b 3f fe and %o4, -2, %o4 return (Heap_Block *) ((uintptr_t) block + offset); 40015538: ba 02 c0 0c add %o3, %o4, %i5 && (uintptr_t) block <= (uintptr_t) heap->last_block; 4001553c: 80 a0 80 1d cmp %g2, %i5 40015540: 08 80 00 0b bleu 4001556c <_Heap_Walk+0x340> <== ALWAYS TAKEN 40015544: aa 10 00 17 mov %l7, %l5 (*printer)( 40015548: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED 4001554c: 92 10 20 01 mov 1, %o1 40015550: 15 10 02 19 sethi %hi(0x40086400), %o2 return false; 40015554: b8 10 20 00 clr %i4 (*printer)( 40015558: 9f c6 c0 00 call %i3 4001555c: 94 12 a3 88 or %o2, 0x388, %o2 return false; 40015560: b0 0f 20 ff and %i4, 0xff, %i0 40015564: 81 c7 e0 08 ret 40015568: 81 e8 00 00 restore 4001556c: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 40015570: 80 a0 80 1d cmp %g2, %i5 40015574: 2a bf ff f6 bcs,a 4001554c <_Heap_Walk+0x320> 40015578: 98 10 00 1d mov %i5, %o4 return (value % alignment) == 0; 4001557c: 81 80 20 00 wr %g0, %y 40015580: 01 00 00 00 nop 40015584: 01 00 00 00 nop 40015588: 01 00 00 00 nop 4001558c: 84 73 00 19 udiv %o4, %i1, %g2 40015590: 84 58 80 19 smul %g2, %i1, %g2 if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 40015594: 80 a3 00 02 cmp %o4, %g2 40015598: 02 80 00 1a be 40015600 <_Heap_Walk+0x3d4> 4001559c: 84 1a c0 1a xor %o3, %i2, %g2 400155a0: 80 a2 c0 1a cmp %o3, %i2 400155a4: 12 80 00 82 bne 400157ac <_Heap_Walk+0x580> 400155a8: 92 10 20 01 mov 1, %o1 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 400155ac: c4 07 60 04 ld [ %i5 + 4 ], %g2 400155b0: 84 08 a0 01 and %g2, 1, %g2 if ( !_Heap_Is_prev_used( next_block ) ) { 400155b4: 80 a0 a0 00 cmp %g2, 0 400155b8: 02 80 00 2e be 40015670 <_Heap_Walk+0x444> 400155bc: b8 10 00 02 mov %g2, %i4 } else if (prev_used) { 400155c0: 80 a5 e0 00 cmp %l7, 0 400155c4: 22 80 00 24 be,a 40015654 <_Heap_Walk+0x428> 400155c8: da 02 c0 00 ld [ %o3 ], %o5 (*printer)( 400155cc: d0 27 bf fc st %o0, [ %fp + -4 ] 400155d0: 15 10 02 19 sethi %hi(0x40086400), %o2 400155d4: 92 10 20 00 clr %o1 400155d8: 9f c6 c0 00 call %i3 400155dc: 94 12 a2 f8 or %o2, 0x2f8, %o2 400155e0: d0 07 bf fc ld [ %fp + -4 ], %o0 } while ( block != first_block ); 400155e4: 80 a7 40 10 cmp %i5, %l0 400155e8: 02 bf ff 1b be 40015254 <_Heap_Walk+0x28> 400155ec: 96 10 00 1d mov %i5, %o3 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 400155f0: d8 07 60 04 ld [ %i5 + 4 ], %o4 return (uintptr_t) block >= (uintptr_t) heap->first_block 400155f4: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 400155f8: 10 bf ff cf b 40015534 <_Heap_Walk+0x308> 400155fc: ae 0b 20 01 and %o4, 1, %l7 bool const is_not_last_block = block != last_block; 40015600: 80 a0 00 02 cmp %g0, %g2 40015604: 86 40 20 00 addx %g0, 0, %g3 if ( block_size < min_block_size && is_not_last_block ) { 40015608: 80 a3 00 11 cmp %o4, %l1 4001560c: 84 40 20 00 addx %g0, 0, %g2 40015610: 84 08 c0 02 and %g3, %g2, %g2 40015614: 80 a0 a0 00 cmp %g2, 0 40015618: 12 80 00 5c bne 40015788 <_Heap_Walk+0x55c> 4001561c: b8 10 00 02 mov %g2, %i4 if ( next_block_begin <= block_begin && is_not_last_block ) { 40015620: 80 a2 c0 1d cmp %o3, %i5 40015624: 0a bf ff e2 bcs 400155ac <_Heap_Walk+0x380> 40015628: 80 a0 e0 00 cmp %g3, 0 4001562c: 22 bf ff e1 be,a 400155b0 <_Heap_Walk+0x384> 40015630: c4 07 60 04 ld [ %i5 + 4 ], %g2 (*printer)( 40015634: 98 10 00 1d mov %i5, %o4 40015638: 15 10 02 19 sethi %hi(0x40086400), %o2 4001563c: 92 10 20 01 mov 1, %o1 40015640: 9f c6 c0 00 call %i3 40015644: 94 12 a2 18 or %o2, 0x218, %o2 return false; 40015648: b0 0f 20 ff and %i4, 0xff, %i0 4001564c: 81 c7 e0 08 ret 40015650: 81 e8 00 00 restore (*printer)( 40015654: d0 27 bf fc st %o0, [ %fp + -4 ] 40015658: 15 10 02 19 sethi %hi(0x40086400), %o2 4001565c: 92 10 20 00 clr %o1 40015660: 9f c6 c0 00 call %i3 40015664: 94 12 a3 10 or %o2, 0x310, %o2 40015668: 10 bf ff df b 400155e4 <_Heap_Walk+0x3b8> 4001566c: d0 07 bf fc ld [ %fp + -4 ], %o0 (*printer)( 40015670: da 02 e0 0c ld [ %o3 + 0xc ], %o5 40015674: c4 06 20 08 ld [ %i0 + 8 ], %g2 return _Heap_Free_list_tail(heap)->prev; 40015678: de 06 20 0c ld [ %i0 + 0xc ], %o7 4001567c: 80 a0 80 0d cmp %g2, %o5 40015680: 02 80 00 06 be 40015698 <_Heap_Walk+0x46c> 40015684: 86 10 00 12 mov %l2, %g3 : (block->prev == free_list_head ? " (= head)" : ""), 40015688: 80 a6 00 0d cmp %i0, %o5 4001568c: 02 80 00 03 be 40015698 <_Heap_Walk+0x46c> 40015690: c6 07 bf f0 ld [ %fp + -16 ], %g3 40015694: 86 10 00 14 mov %l4, %g3 (*printer)( 40015698: c4 02 e0 08 ld [ %o3 + 8 ], %g2 4001569c: 80 a3 c0 02 cmp %o7, %g2 400156a0: 02 80 00 06 be 400156b8 <_Heap_Walk+0x48c> 400156a4: 88 10 00 13 mov %l3, %g4 : (block->next == free_list_tail ? " (= tail)" : "") 400156a8: 80 a6 00 02 cmp %i0, %g2 400156ac: 02 80 00 03 be 400156b8 <_Heap_Walk+0x48c> 400156b0: 88 10 00 16 mov %l6, %g4 400156b4: 88 10 00 14 mov %l4, %g4 (*printer)( 400156b8: c8 23 a0 64 st %g4, [ %sp + 0x64 ] 400156bc: 92 10 20 00 clr %o1 400156c0: c4 23 a0 60 st %g2, [ %sp + 0x60 ] 400156c4: 15 10 02 19 sethi %hi(0x40086400), %o2 400156c8: c6 23 a0 5c st %g3, [ %sp + 0x5c ] 400156cc: 94 12 a2 50 or %o2, 0x250, %o2 400156d0: d8 27 bf f4 st %o4, [ %fp + -12 ] 400156d4: d6 27 bf f8 st %o3, [ %fp + -8 ] 400156d8: 9f c6 c0 00 call %i3 400156dc: d0 27 bf fc st %o0, [ %fp + -4 ] if ( block_size != next_block->prev_size ) { 400156e0: da 07 40 00 ld [ %i5 ], %o5 400156e4: d8 07 bf f4 ld [ %fp + -12 ], %o4 400156e8: d0 07 bf fc ld [ %fp + -4 ], %o0 400156ec: 80 a3 00 0d cmp %o4, %o5 400156f0: 02 80 00 0a be 40015718 <_Heap_Walk+0x4ec> 400156f4: d6 07 bf f8 ld [ %fp + -8 ], %o3 (*printer)( 400156f8: fa 23 a0 5c st %i5, [ %sp + 0x5c ] 400156fc: 92 10 20 01 mov 1, %o1 40015700: 15 10 02 19 sethi %hi(0x40086400), %o2 } 40015704: b0 0f 20 ff and %i4, 0xff, %i0 (*printer)( 40015708: 9f c6 c0 00 call %i3 4001570c: 94 12 a2 88 or %o2, 0x288, %o2 } 40015710: 81 c7 e0 08 ret 40015714: 81 e8 00 00 restore if ( !prev_used ) { 40015718: 80 a5 e0 00 cmp %l7, 0 4001571c: 02 80 00 14 be 4001576c <_Heap_Walk+0x540> 40015720: 92 10 20 01 mov 1, %o1 return _Heap_Free_list_head(heap)->next; 40015724: c2 06 20 08 ld [ %i0 + 8 ], %g1 while ( free_block != free_list_tail ) { 40015728: 80 a6 00 01 cmp %i0, %g1 4001572c: 02 80 00 0b be 40015758 <_Heap_Walk+0x52c> <== NEVER TAKEN 40015730: 15 10 02 19 sethi %hi(0x40086400), %o2 if ( free_block == block ) { 40015734: 80 a2 c0 01 cmp %o3, %g1 40015738: 02 bf ff ac be 400155e8 <_Heap_Walk+0x3bc> 4001573c: 80 a7 40 10 cmp %i5, %l0 free_block = free_block->next; 40015740: c2 00 60 08 ld [ %g1 + 8 ], %g1 while ( free_block != free_list_tail ) { 40015744: 80 a6 00 01 cmp %i0, %g1 40015748: 12 bf ff fc bne 40015738 <_Heap_Walk+0x50c> 4001574c: 80 a2 c0 01 cmp %o3, %g1 (*printer)( 40015750: 15 10 02 19 sethi %hi(0x40086400), %o2 40015754: 92 10 20 01 mov 1, %o1 40015758: 9f c6 c0 00 call %i3 4001575c: 94 12 a3 58 or %o2, 0x358, %o2 return false; 40015760: b0 0f 20 ff and %i4, 0xff, %i0 40015764: 81 c7 e0 08 ret 40015768: 81 e8 00 00 restore return false; 4001576c: b8 10 00 15 mov %l5, %i4 (*printer)( 40015770: 15 10 02 19 sethi %hi(0x40086400), %o2 } 40015774: b0 0f 20 ff and %i4, 0xff, %i0 (*printer)( 40015778: 9f c6 c0 00 call %i3 4001577c: 94 12 a2 c8 or %o2, 0x2c8, %o2 } 40015780: 81 c7 e0 08 ret 40015784: 81 e8 00 00 restore (*printer)( 40015788: 9a 10 00 11 mov %l1, %o5 4001578c: 92 10 20 01 mov 1, %o1 40015790: 15 10 02 19 sethi %hi(0x40086400), %o2 return false; 40015794: b8 10 20 00 clr %i4 (*printer)( 40015798: 9f c6 c0 00 call %i3 4001579c: 94 12 a1 e8 or %o2, 0x1e8, %o2 return false; 400157a0: b0 0f 20 ff and %i4, 0xff, %i0 400157a4: 81 c7 e0 08 ret 400157a8: 81 e8 00 00 restore (*printer)( 400157ac: 15 10 02 19 sethi %hi(0x40086400), %o2 return false; 400157b0: b8 10 20 00 clr %i4 (*printer)( 400157b4: 9f c6 c0 00 call %i3 400157b8: 94 12 a1 b8 or %o2, 0x1b8, %o2 return false; 400157bc: b0 0f 20 ff and %i4, 0xff, %i0 400157c0: 81 c7 e0 08 ret 400157c4: 81 e8 00 00 restore return false; 400157c8: b8 10 20 00 clr %i4 (*printer)( 400157cc: 9f c6 c0 00 call %i3 400157d0: 94 12 a1 60 or %o2, 0x160, %o2 return false; 400157d4: b0 0f 20 ff and %i4, 0xff, %i0 400157d8: 81 c7 e0 08 ret 400157dc: 81 e8 00 00 restore return false; 400157e0: b8 10 20 00 clr %i4 (*printer)( 400157e4: 9f c6 c0 00 call %i3 400157e8: 94 12 a1 30 or %o2, 0x130, %o2 return false; 400157ec: b0 0f 20 ff and %i4, 0xff, %i0 400157f0: 81 c7 e0 08 ret 400157f4: 81 e8 00 00 restore (*printer)( 400157f8: 15 10 02 19 sethi %hi(0x40086400), %o2 400157fc: 92 10 20 01 mov 1, %o1 40015800: 9f c6 c0 00 call %i3 40015804: 94 12 a1 80 or %o2, 0x180, %o2 return false; 40015808: b0 0f 20 ff and %i4, 0xff, %i0 4001580c: 81 c7 e0 08 ret 40015810: 81 e8 00 00 restore =============================================================================== 4000acec <_IO_Base64>: } int _IO_Base64(IO_Put_char put_char, void *arg, const void *src, size_t srclen, const char *wordbreak, int wordlen) { 4000acec: 9d e3 bf a0 save %sp, -96, %sp unsigned int loops = 0; const unsigned char *in = src; int out = 0; if (wordlen < 4) { 4000acf0: 80 a7 60 04 cmp %i5, 4 4000acf4: 26 80 00 02 bl,a 4000acfc <_IO_Base64+0x10> 4000acf8: ba 10 20 04 mov 4, %i5 wordlen = 4; } while (srclen > 2) { 4000acfc: 80 a6 e0 02 cmp %i3, 2 4000ad00: 08 80 00 2f bleu 4000adbc <_IO_Base64+0xd0> 4000ad04: a2 10 20 00 clr %l1 4000ad08: 21 10 00 74 sethi %hi(0x4001d000), %l0 4000ad0c: a4 10 20 00 clr %l2 4000ad10: a0 14 21 f0 or %l0, 0x1f0, %l0 if (srclen != 0 && (int)((loops + 1) * 4) >= wordlen) { const char *w = wordbreak; loops = 0; while (*w != '\0') { 4000ad14: a6 10 3f fc mov -4, %l3 _IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char); 4000ad18: c2 0e 80 00 ldub [ %i2 ], %g1 4000ad1c: 83 30 60 02 srl %g1, 2, %g1 (*put_char)(c, arg); 4000ad20: d0 4c 00 01 ldsb [ %l0 + %g1 ], %o0 4000ad24: 9f c6 00 00 call %i0 4000ad28: 92 10 00 19 mov %i1, %o1 _IO_Put(base64[((in[0]<<4)&0x30)| 4000ad2c: c2 0e 80 00 ldub [ %i2 ], %g1 ((in[1]>>4)&0x0f)], arg, put_char); 4000ad30: c4 0e a0 01 ldub [ %i2 + 1 ], %g2 4000ad34: 85 30 a0 04 srl %g2, 4, %g2 _IO_Put(base64[((in[0]<<4)&0x30)| 4000ad38: 83 28 60 04 sll %g1, 4, %g1 4000ad3c: 82 08 60 30 and %g1, 0x30, %g1 4000ad40: 82 10 40 02 or %g1, %g2, %g1 (*put_char)(c, arg); 4000ad44: d0 4c 00 01 ldsb [ %l0 + %g1 ], %o0 4000ad48: 9f c6 00 00 call %i0 4000ad4c: 92 10 00 19 mov %i1, %o1 _IO_Put(base64[((in[1]<<2)&0x3c)| 4000ad50: c2 0e a0 01 ldub [ %i2 + 1 ], %g1 ((in[2]>>6)&0x03)], arg, put_char); 4000ad54: c4 0e a0 02 ldub [ %i2 + 2 ], %g2 4000ad58: 85 30 a0 06 srl %g2, 6, %g2 _IO_Put(base64[((in[1]<<2)&0x3c)| 4000ad5c: 83 28 60 02 sll %g1, 2, %g1 4000ad60: 82 08 60 3c and %g1, 0x3c, %g1 4000ad64: 82 10 40 02 or %g1, %g2, %g1 (*put_char)(c, arg); 4000ad68: d0 4c 00 01 ldsb [ %l0 + %g1 ], %o0 4000ad6c: 9f c6 00 00 call %i0 4000ad70: 92 10 00 19 mov %i1, %o1 _IO_Put(base64[in[2]&0x3f], arg, put_char); 4000ad74: c2 0e a0 02 ldub [ %i2 + 2 ], %g1 4000ad78: 82 08 60 3f and %g1, 0x3f, %g1 (*put_char)(c, arg); 4000ad7c: d0 4c 00 01 ldsb [ %l0 + %g1 ], %o0 4000ad80: 9f c6 00 00 call %i0 4000ad84: 92 10 00 19 mov %i1, %o1 if (srclen != 0 && 4000ad88: b6 86 ff fd addcc %i3, -3, %i3 4000ad8c: 02 80 00 27 be 4000ae28 <_IO_Base64+0x13c> 4000ad90: a8 04 60 04 add %l1, 4, %l4 (int)((loops + 1) * 4) >= wordlen) 4000ad94: 82 04 a0 02 add %l2, 2, %g1 4000ad98: 83 28 60 02 sll %g1, 2, %g1 if (srclen != 0 && 4000ad9c: 80 a0 40 1d cmp %g1, %i5 4000ada0: 16 80 00 24 bge 4000ae30 <_IO_Base64+0x144> 4000ada4: a4 04 a0 01 inc %l2 out += 4; 4000ada8: a2 10 00 14 mov %l4, %l1 while (srclen > 2) { 4000adac: 80 a6 e0 02 cmp %i3, 2 4000adb0: 18 bf ff da bgu 4000ad18 <_IO_Base64+0x2c> 4000adb4: b4 06 a0 03 add %i2, 3, %i2 ++w; ++out; } } } if (srclen == 2) { 4000adb8: 80 a6 e0 02 cmp %i3, 2 4000adbc: 12 80 00 30 bne 4000ae7c <_IO_Base64+0x190> 4000adc0: 3b 10 00 74 sethi %hi(0x4001d000), %i5 _IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char); 4000adc4: c2 0e 80 00 ldub [ %i2 ], %g1 4000adc8: 83 30 60 02 srl %g1, 2, %g1 4000adcc: ba 17 61 f0 or %i5, 0x1f0, %i5 (*put_char)(c, arg); 4000add0: d0 4f 40 01 ldsb [ %i5 + %g1 ], %o0 4000add4: 9f c6 00 00 call %i0 4000add8: 92 10 00 19 mov %i1, %o1 _IO_Put(base64[((in[0]<<4)&0x30)| 4000addc: c2 0e 80 00 ldub [ %i2 ], %g1 ((in[1]>>4)&0x0f)], arg, put_char); 4000ade0: c4 0e a0 01 ldub [ %i2 + 1 ], %g2 4000ade4: 85 30 a0 04 srl %g2, 4, %g2 _IO_Put(base64[((in[0]<<4)&0x30)| 4000ade8: 83 28 60 04 sll %g1, 4, %g1 4000adec: 82 08 60 30 and %g1, 0x30, %g1 4000adf0: 82 10 40 02 or %g1, %g2, %g1 (*put_char)(c, arg); 4000adf4: d0 4f 40 01 ldsb [ %i5 + %g1 ], %o0 4000adf8: 9f c6 00 00 call %i0 4000adfc: 92 10 00 19 mov %i1, %o1 _IO_Put(base64[((in[1]<<2)&0x3c)], arg, put_char); 4000ae00: c2 0e a0 01 ldub [ %i2 + 1 ], %g1 4000ae04: 83 28 60 02 sll %g1, 2, %g1 4000ae08: 82 08 60 3c and %g1, 0x3c, %g1 (*put_char)(c, arg); 4000ae0c: d0 4f 40 01 ldsb [ %i5 + %g1 ], %o0 4000ae10: 92 10 00 19 mov %i1, %o1 4000ae14: 9f c6 00 00 call %i0 4000ae18: a8 04 60 04 add %l1, 4, %l4 4000ae1c: 92 10 00 19 mov %i1, %o1 4000ae20: 9f c6 00 00 call %i0 4000ae24: 90 10 20 3d mov 0x3d, %o0 _IO_Put('=', arg, put_char); _IO_Put('=', arg, put_char); out += 4; } return out; } 4000ae28: 81 c7 e0 08 ret 4000ae2c: 91 e8 00 14 restore %g0, %l4, %o0 while (*w != '\0') { 4000ae30: d0 0f 00 00 ldub [ %i4 ], %o0 4000ae34: 91 2a 20 18 sll %o0, 0x18, %o0 4000ae38: 80 a2 20 00 cmp %o0, 0 4000ae3c: 22 80 00 0e be,a 4000ae74 <_IO_Base64+0x188> <== NEVER TAKEN 4000ae40: a2 10 00 14 mov %l4, %l1 <== NOT EXECUTED 4000ae44: a2 24 c0 11 sub %l3, %l1, %l1 4000ae48: a2 07 00 11 add %i4, %l1, %l1 (*put_char)(c, arg); 4000ae4c: 91 3a 20 18 sra %o0, 0x18, %o0 4000ae50: 9f c6 00 00 call %i0 4000ae54: 92 10 00 19 mov %i1, %o1 ++out; 4000ae58: a8 05 20 01 inc %l4 while (*w != '\0') { 4000ae5c: d0 0c 40 14 ldub [ %l1 + %l4 ], %o0 4000ae60: 91 2a 20 18 sll %o0, 0x18, %o0 4000ae64: 80 a2 20 00 cmp %o0, 0 4000ae68: 32 bf ff fa bne,a 4000ae50 <_IO_Base64+0x164> <== NEVER TAKEN 4000ae6c: 91 3a 20 18 sra %o0, 0x18, %o0 <== NOT EXECUTED out += 4; 4000ae70: a2 10 00 14 mov %l4, %l1 loops = 0; 4000ae74: 10 bf ff ce b 4000adac <_IO_Base64+0xc0> 4000ae78: a4 10 20 00 clr %l2 } else if (srclen == 1) { 4000ae7c: 80 a6 e0 01 cmp %i3, 1 4000ae80: 12 80 00 10 bne 4000aec0 <_IO_Base64+0x1d4> 4000ae84: ba 17 61 f0 or %i5, 0x1f0, %i5 _IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char); 4000ae88: c2 0e 80 00 ldub [ %i2 ], %g1 4000ae8c: 83 30 60 02 srl %g1, 2, %g1 (*put_char)(c, arg); 4000ae90: d0 4f 40 01 ldsb [ %i5 + %g1 ], %o0 4000ae94: 9f c6 00 00 call %i0 4000ae98: 92 10 00 19 mov %i1, %o1 _IO_Put(base64[((in[0]<<4)&0x30)], arg, put_char); 4000ae9c: c2 0e 80 00 ldub [ %i2 ], %g1 4000aea0: 83 28 60 04 sll %g1, 4, %g1 4000aea4: 82 08 60 30 and %g1, 0x30, %g1 (*put_char)(c, arg); 4000aea8: d0 4f 40 01 ldsb [ %i5 + %g1 ], %o0 4000aeac: 9f c6 00 00 call %i0 4000aeb0: 92 10 00 19 mov %i1, %o1 4000aeb4: 92 10 00 19 mov %i1, %o1 4000aeb8: 10 bf ff d7 b 4000ae14 <_IO_Base64+0x128> 4000aebc: 90 10 20 3d mov 0x3d, %o0 return out; 4000aec0: 10 bf ff da b 4000ae28 <_IO_Base64+0x13c> 4000aec4: a8 10 00 11 mov %l1, %l4 =============================================================================== 4000ef20 <_IO_Vprintf>: return (p); } int _IO_Vprintf(IO_Put_char put_char, void *arg, char const *fmt, va_list ap) { 4000ef20: 9d e3 bf 40 save %sp, -192, %sp 4000ef24: ba 10 00 18 mov %i0, %i5 char padc; int stop = 0, retval = 0; num = 0; if (fmt == NULL) 4000ef28: 80 a6 a0 00 cmp %i2, 0 4000ef2c: 02 80 00 39 be 4000f010 <_IO_Vprintf+0xf0> <== NEVER TAKEN 4000ef30: ac 10 00 1b mov %i3, %l6 fmt = "(fmt null)\n"; for (;;) { padc = ' '; width = 0; while ((ch = (u_char)*fmt++) != '%' || stop) { 4000ef34: d0 0e 80 00 ldub [ %i2 ], %o0 4000ef38: 03 10 00 3b sethi %hi(0x4000ec00), %g1 4000ef3c: 82 10 61 c0 or %g1, 0x1c0, %g1 ! 4000edc0 4000ef40: c2 27 bf d4 st %g1, [ %fp + -44 ] 4000ef44: 03 10 00 61 sethi %hi(0x40018400), %g1 4000ef48: 82 10 60 af or %g1, 0xaf, %g1 ! 400184af 4000ef4c: c2 27 bf d0 st %g1, [ %fp + -48 ] num = (uintptr_t)va_arg(ap, void *); goto number; case 's': p = va_arg(ap, char *); if (p == NULL) p = "(null)"; 4000ef50: 03 10 00 61 sethi %hi(0x40018400), %g1 4000ef54: 82 10 60 a8 or %g1, 0xa8, %g1 ! 400184a8 <__clz_tab+0x140> 4000ef58: c2 27 bf c4 st %g1, [ %fp + -60 ] width -= n; if (!ladjust && width > 0) while (width--) PCHAR(padc); while (n--) 4000ef5c: a8 10 20 00 clr %l4 4000ef60: b0 10 20 00 clr %i0 while ((ch = (u_char)*fmt++) != '%' || stop) { 4000ef64: 82 10 00 1a mov %i2, %g1 4000ef68: 10 80 00 09 b 4000ef8c <_IO_Vprintf+0x6c> 4000ef6c: b6 25 00 1a sub %l4, %i2, %i3 if (ch == '\0') 4000ef70: 80 a2 20 00 cmp %o0, 0 4000ef74: 02 80 00 25 be 4000f008 <_IO_Vprintf+0xe8> 4000ef78: 01 00 00 00 nop PCHAR(ch); 4000ef7c: 9f c7 40 00 call %i5 4000ef80: 92 10 00 19 mov %i1, %o1 while ((ch = (u_char)*fmt++) != '%' || stop) { 4000ef84: d0 0f 00 00 ldub [ %i4 ], %o0 4000ef88: 82 10 00 1c mov %i4, %g1 4000ef8c: b8 00 60 01 add %g1, 1, %i4 4000ef90: 90 0a 20 ff and %o0, 0xff, %o0 4000ef94: aa 00 40 1b add %g1, %i3, %l5 4000ef98: 80 a2 20 25 cmp %o0, 0x25 4000ef9c: 12 bf ff f5 bne 4000ef70 <_IO_Vprintf+0x50> 4000efa0: ae 10 00 1c mov %i4, %l7 4000efa4: 80 a6 20 00 cmp %i0, 0 4000efa8: 12 bf ff f5 bne 4000ef7c <_IO_Vprintf+0x5c> <== NEVER TAKEN 4000efac: 84 10 20 20 mov 0x20, %g2 sign = 0; dot = 0; dwidth = 0; upper = 0; 4000efb0: c0 27 bf b4 clr [ %fp + -76 ] cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0; 4000efb4: 9e 10 20 00 clr %o7 4000efb8: c0 27 bf cc clr [ %fp + -52 ] 4000efbc: 9a 10 20 00 clr %o5 lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 4000efc0: c0 27 bf c8 clr [ %fp + -56 ] sign = 0; dot = 0; dwidth = 0; upper = 0; 4000efc4: 94 10 20 00 clr %o2 width = 0; 4000efc8: c0 27 bf c0 clr [ %fp + -64 ] lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 4000efcc: a8 10 20 00 clr %l4 padc = ' '; 4000efd0: c4 2f bf b3 stb %g2, [ %fp + -77 ] cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0; 4000efd4: 88 10 20 00 clr %g4 reswitch: switch (ch = (u_char)*fmt++) { 4000efd8: d8 08 60 01 ldub [ %g1 + 1 ], %o4 4000efdc: 84 03 3f dd add %o4, -35, %g2 4000efe0: b4 05 e0 01 add %l7, 1, %i2 4000efe4: 84 08 a0 ff and %g2, 0xff, %g2 4000efe8: 80 a0 a0 57 cmp %g2, 0x57 4000efec: 18 80 00 11 bgu 4000f030 <_IO_Vprintf+0x110> <== NEVER TAKEN 4000eff0: 90 0b 20 ff and %o4, 0xff, %o0 4000eff4: c6 07 bf d4 ld [ %fp + -44 ], %g3 4000eff8: 85 28 a0 02 sll %g2, 2, %g2 4000effc: c4 00 c0 02 ld [ %g3 + %g2 ], %g2 4000f000: 81 c0 80 00 jmp %g2 4000f004: 01 00 00 00 nop stop = 1; break; } } #undef PCHAR } 4000f008: 81 c7 e0 08 ret 4000f00c: 91 e8 00 15 restore %g0, %l5, %o0 fmt = "(fmt null)\n"; 4000f010: 35 10 00 61 sethi %hi(0x40018400), %i2 <== NOT EXECUTED 4000f014: 90 10 20 28 mov 0x28, %o0 <== NOT EXECUTED 4000f018: 10 bf ff c8 b 4000ef38 <_IO_Vprintf+0x18> <== NOT EXECUTED 4000f01c: b4 16 a0 98 or %i2, 0x98, %i2 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 4000f020: d8 0d e0 01 ldub [ %l7 + 1 ], %o4 zflag = 1; 4000f024: 88 10 20 01 mov 1, %g4 goto reswitch; 4000f028: 10 bf ff ed b 4000efdc <_IO_Vprintf+0xbc> 4000f02c: ae 10 00 1a mov %i2, %l7 while (percent < fmt) 4000f030: 90 10 20 25 mov 0x25, %o0 4000f034: a8 10 00 15 mov %l5, %l4 4000f038: 80 a0 40 1a cmp %g1, %i2 4000f03c: 0a 80 00 05 bcs 4000f050 <_IO_Vprintf+0x130> <== ALWAYS TAKEN 4000f040: b0 10 20 01 mov 1, %i0 while ((ch = (u_char)*fmt++) != '%' || stop) { 4000f044: 10 bf ff c8 b 4000ef64 <_IO_Vprintf+0x44> <== NOT EXECUTED 4000f048: d0 0d e0 01 ldub [ %l7 + 1 ], %o0 <== NOT EXECUTED 4000f04c: b8 07 20 01 inc %i4 PCHAR(*percent++); 4000f050: 91 2a 20 18 sll %o0, 0x18, %o0 4000f054: 92 10 00 19 mov %i1, %o1 4000f058: 9f c7 40 00 call %i5 4000f05c: 91 3a 20 18 sra %o0, 0x18, %o0 while (percent < fmt) 4000f060: 80 a6 80 1c cmp %i2, %i4 4000f064: 32 bf ff fa bne,a 4000f04c <_IO_Vprintf+0x12c> 4000f068: d0 0f 00 00 ldub [ %i4 ], %o0 PCHAR(*percent++); 4000f06c: a8 06 80 1b add %i2, %i3, %l4 stop = 1; 4000f070: b0 10 20 01 mov 1, %i0 while ((ch = (u_char)*fmt++) != '%' || stop) { 4000f074: 10 bf ff bc b 4000ef64 <_IO_Vprintf+0x44> 4000f078: d0 0d e0 01 ldub [ %l7 + 1 ], %o0 ch = *fmt; 4000f07c: d6 4d e0 01 ldsb [ %l7 + 1 ], %o3 if (ch < '0' || ch > '9') 4000f080: 86 02 ff d0 add %o3, -48, %g3 ch = *fmt; 4000f084: d8 0d e0 01 ldub [ %l7 + 1 ], %o4 if (ch < '0' || ch > '9') 4000f088: 80 a0 e0 09 cmp %g3, 9 4000f08c: 18 80 01 bf bgu 4000f788 <_IO_Vprintf+0x868> 4000f090: 84 02 3f d0 add %o0, -48, %g2 reswitch: switch (ch = (u_char)*fmt++) { 4000f094: ae 10 00 1a mov %i2, %l7 4000f098: 86 10 00 02 mov %g2, %g3 n = n * 10 + ch - '0'; 4000f09c: 85 28 e0 02 sll %g3, 2, %g2 4000f0a0: 84 00 80 03 add %g2, %g3, %g2 4000f0a4: 85 28 a0 01 sll %g2, 1, %g2 4000f0a8: 84 00 80 0b add %g2, %o3, %g2 ch = *fmt; 4000f0ac: d6 4d e0 01 ldsb [ %l7 + 1 ], %o3 if (ch < '0' || ch > '9') 4000f0b0: b4 02 ff d0 add %o3, -48, %i2 for (n = 0;; ++fmt) { 4000f0b4: ae 05 e0 01 inc %l7 n = n * 10 + ch - '0'; 4000f0b8: 86 00 bf d0 add %g2, -48, %g3 if (ch < '0' || ch > '9') 4000f0bc: 80 a6 a0 09 cmp %i2, 9 4000f0c0: 08 bf ff f7 bleu 4000f09c <_IO_Vprintf+0x17c> <== NEVER TAKEN 4000f0c4: d8 0d c0 00 ldub [ %l7 ], %o4 4000f0c8: 84 10 00 03 mov %g3, %g2 if (dot) 4000f0cc: 80 a2 a0 00 cmp %o2, 0 4000f0d0: 32 bf ff c3 bne,a 4000efdc <_IO_Vprintf+0xbc> 4000f0d4: c4 27 bf b4 st %g2, [ %fp + -76 ] 4000f0d8: 10 bf ff c1 b 4000efdc <_IO_Vprintf+0xbc> 4000f0dc: c4 27 bf c0 st %g2, [ %fp + -64 ] base = 10; 4000f0e0: 82 10 20 0a mov 0xa, %g1 4000f0e4: c2 27 bf a8 st %g1, [ %fp + -88 ] reswitch: switch (ch = (u_char)*fmt++) { 4000f0e8: a2 10 20 00 clr %l1 4000f0ec: a4 10 20 0a mov 0xa, %l2 if (jflag) 4000f0f0: c2 07 bf cc ld [ %fp + -52 ], %g1 4000f0f4: 80 a0 60 00 cmp %g1, 0 4000f0f8: 22 80 01 db be,a 4000f864 <_IO_Vprintf+0x944> 4000f0fc: c2 05 80 00 ld [ %l6 ], %g1 num = va_arg(ap, intmax_t); 4000f100: 92 10 00 16 mov %l6, %o1 4000f104: 94 10 20 08 mov 8, %o2 4000f108: 40 00 03 93 call 4000ff54 4000f10c: 90 07 bf e0 add %fp, -32, %o0 4000f110: c4 1f bf e0 ldd [ %fp + -32 ], %g2 4000f114: c4 3f bf a0 std %g2, [ %fp + -96 ] 4000f118: ac 05 a0 08 add %l6, 8, %l6 4000f11c: c4 3f bf b8 std %g2, [ %fp + -72 ] if (sharpflag && num != 0) { 4000f120: e8 2f bf af stb %l4, [ %fp + -81 ] if (sign && (intmax_t)num < 0) { 4000f124: c4 1f bf a0 ldd [ %fp + -96 ], %g2 4000f128: 82 90 a0 00 orcc %g2, 0, %g1 4000f12c: 16 80 02 49 bge 4000fa50 <_IO_Vprintf+0xb30> 4000f130: 9a a0 00 03 subcc %g0, %g3, %o5 neg = 1; 4000f134: 82 10 20 01 mov 1, %g1 num = -(intmax_t)num; 4000f138: 98 60 00 02 subx %g0, %g2, %o4 neg = 1; 4000f13c: c2 27 bf cc st %g1, [ %fp + -52 ] num = -(intmax_t)num; 4000f140: b8 10 20 00 clr %i4 4000f144: d8 3f bf b8 std %o4, [ %fp + -72 ] *p = '\0'; 4000f148: b9 2f 20 04 sll %i4, 4, %i4 4000f14c: c0 2f bf e8 clrb [ %fp + -24 ] p = nbuf; 4000f150: b6 07 bf e8 add %fp, -24, %i3 *p = '\0'; 4000f154: c4 1f bf b8 ldd [ %fp + -72 ], %g2 *++p = hex2ascii_data[upper][num % base]; 4000f158: c2 07 bf d0 ld [ %fp + -48 ], %g1 *p = '\0'; 4000f15c: a6 10 00 02 mov %g2, %l3 4000f160: a8 10 00 03 mov %g3, %l4 *++p = hex2ascii_data[upper][num % base]; 4000f164: a0 00 40 1c add %g1, %i4, %l0 4000f168: 94 10 20 00 clr %o2 4000f16c: 96 10 00 12 mov %l2, %o3 4000f170: 90 10 00 13 mov %l3, %o0 4000f174: 40 00 1e e9 call 40016d18 <__umoddi3> 4000f178: 92 10 00 14 mov %l4, %o1 4000f17c: f8 0c 00 09 ldub [ %l0 + %o1 ], %i4 4000f180: f8 2e e0 01 stb %i4, [ %i3 + 1 ] } while (num /= base); 4000f184: 90 10 00 13 mov %l3, %o0 4000f188: 92 10 00 14 mov %l4, %o1 4000f18c: 94 10 20 00 clr %o2 4000f190: 7f ff fe 65 call 4000eb24 <__udivdi3> 4000f194: 96 10 00 12 mov %l2, %o3 4000f198: 82 10 00 13 mov %l3, %g1 4000f19c: 84 10 00 14 mov %l4, %g2 *++p = hex2ascii_data[upper][num % base]; 4000f1a0: b6 06 e0 01 inc %i3 } while (num /= base); 4000f1a4: a6 10 00 08 mov %o0, %l3 4000f1a8: 80 a4 40 01 cmp %l1, %g1 4000f1ac: 12 bf ff ef bne 4000f168 <_IO_Vprintf+0x248> 4000f1b0: a8 10 00 09 mov %o1, %l4 4000f1b4: 80 a4 80 02 cmp %l2, %g2 4000f1b8: 08 bf ff ed bleu 4000f16c <_IO_Vprintf+0x24c> 4000f1bc: 94 10 20 00 clr %o2 if (sharpflag && num != 0) { 4000f1c0: c4 1f bf b8 ldd [ %fp + -72 ], %g2 4000f1c4: 82 10 00 02 mov %g2, %g1 4000f1c8: 82 10 40 03 or %g1, %g3, %g1 4000f1cc: c4 07 bf ac ld [ %fp + -84 ], %g2 4000f1d0: 80 a0 00 01 cmp %g0, %g1 *lenp = p - nbuf; 4000f1d4: 82 07 bf e8 add %fp, -24, %g1 if (sharpflag && num != 0) { 4000f1d8: 88 40 20 00 addx %g0, 0, %g4 *lenp = p - nbuf; 4000f1dc: a0 26 c0 01 sub %i3, %g1, %l0 if (sharpflag && num != 0) { 4000f1e0: a8 89 00 02 andcc %g4, %g2, %l4 4000f1e4: 02 80 00 0a be 4000f20c <_IO_Vprintf+0x2ec> 4000f1e8: 82 10 20 00 clr %g1 if (base == 8) 4000f1ec: c4 07 bf a8 ld [ %fp + -88 ], %g2 4000f1f0: 80 a0 a0 08 cmp %g2, 8 4000f1f4: 02 80 00 06 be 4000f20c <_IO_Vprintf+0x2ec> <== NEVER TAKEN 4000f1f8: 82 10 20 01 mov 1, %g1 tmp = 0; 4000f1fc: 82 18 a0 10 xor %g2, 0x10, %g1 4000f200: 80 a0 00 01 cmp %g0, %g1 4000f204: 82 60 3f ff subx %g0, -1, %g1 4000f208: 83 28 60 01 sll %g1, 1, %g1 tmp++; 4000f20c: c4 07 bf cc ld [ %fp + -52 ], %g2 4000f210: 80 a0 00 02 cmp %g0, %g2 if (!ladjust && padc == '0') 4000f214: c4 07 bf c8 ld [ %fp + -56 ], %g2 tmp++; 4000f218: 82 40 00 01 addx %g0, %g1, %g1 if (!ladjust && padc == '0') 4000f21c: 80 88 a0 01 btst 1, %g2 4000f220: 12 80 01 5e bne 4000f798 <_IO_Vprintf+0x878> 4000f224: c4 07 bf b0 ld [ %fp + -80 ], %g2 4000f228: 89 28 a0 18 sll %g2, 0x18, %g4 4000f22c: 89 39 20 18 sra %g4, 0x18, %g4 4000f230: 80 a1 20 30 cmp %g4, 0x30 4000f234: 12 80 01 59 bne 4000f798 <_IO_Vprintf+0x878> 4000f238: c4 07 bf c0 ld [ %fp + -64 ], %g2 dwidth = width - tmp; 4000f23c: a6 20 80 01 sub %g2, %g1, %l3 static inline int imax(int a, int b) { return (a > b ? a : b); } 4000f240: 80 a4 c0 10 cmp %l3, %l0 4000f244: 16 80 00 04 bge 4000f254 <_IO_Vprintf+0x334> 4000f248: 88 10 00 13 mov %l3, %g4 4000f24c: 88 10 00 10 mov %l0, %g4 width -= tmp + imax(dwidth, n); 4000f250: c4 07 bf c0 ld [ %fp + -64 ], %g2 4000f254: 82 01 00 01 add %g4, %g1, %g1 dwidth -= n; 4000f258: a0 24 c0 10 sub %l3, %l0, %l0 width -= tmp + imax(dwidth, n); 4000f25c: a4 20 80 01 sub %g2, %g1, %l2 while (width-- > 0) 4000f260: a2 04 bf ff add %l2, -1, %l1 4000f264: 80 a4 a0 00 cmp %l2, 0 4000f268: 04 80 00 0b ble 4000f294 <_IO_Vprintf+0x374> 4000f26c: a4 10 00 11 mov %l1, %l2 PCHAR(' '); 4000f270: 92 10 00 19 mov %i1, %o1 4000f274: 9f c7 40 00 call %i5 4000f278: 90 10 20 20 mov 0x20, %o0 while (width-- > 0) 4000f27c: a4 04 bf ff add %l2, -1, %l2 4000f280: 80 a4 bf ff cmp %l2, -1 4000f284: 12 bf ff fc bne 4000f274 <_IO_Vprintf+0x354> 4000f288: 92 10 00 19 mov %i1, %o1 PCHAR(' '); 4000f28c: 84 05 60 01 add %l5, 1, %g2 4000f290: aa 00 80 11 add %g2, %l1, %l5 if (neg) 4000f294: c2 07 bf cc ld [ %fp + -52 ], %g1 4000f298: 80 a0 60 00 cmp %g1, 0 4000f29c: 02 80 00 07 be 4000f2b8 <_IO_Vprintf+0x398> 4000f2a0: 80 a5 20 00 cmp %l4, 0 PCHAR('-'); 4000f2a4: 92 10 00 19 mov %i1, %o1 4000f2a8: 90 10 20 2d mov 0x2d, %o0 4000f2ac: 9f c7 40 00 call %i5 4000f2b0: aa 05 60 01 inc %l5 if (sharpflag && num != 0) { 4000f2b4: 80 a5 20 00 cmp %l4, 0 4000f2b8: 02 80 00 11 be 4000f2fc <_IO_Vprintf+0x3dc> 4000f2bc: 80 a4 20 00 cmp %l0, 0 if (base == 8) { 4000f2c0: c2 07 bf a8 ld [ %fp + -88 ], %g1 4000f2c4: 80 a0 60 08 cmp %g1, 8 4000f2c8: 02 80 01 5c be 4000f838 <_IO_Vprintf+0x918> <== NEVER TAKEN 4000f2cc: 92 10 00 19 mov %i1, %o1 } else if (base == 16) { 4000f2d0: 80 a0 60 10 cmp %g1, 0x10 4000f2d4: 12 80 00 0a bne 4000f2fc <_IO_Vprintf+0x3dc> <== NEVER TAKEN 4000f2d8: 80 a4 20 00 cmp %l0, 0 PCHAR('0'); 4000f2dc: 90 10 20 30 mov 0x30, %o0 4000f2e0: 9f c7 40 00 call %i5 4000f2e4: 92 10 00 19 mov %i1, %o1 PCHAR('x'); 4000f2e8: 92 10 00 19 mov %i1, %o1 4000f2ec: 90 10 20 78 mov 0x78, %o0 4000f2f0: 9f c7 40 00 call %i5 4000f2f4: aa 05 60 02 add %l5, 2, %l5 while (dwidth-- > 0) 4000f2f8: 80 a4 20 00 cmp %l0, 0 4000f2fc: 04 80 00 0c ble 4000f32c <_IO_Vprintf+0x40c> 4000f300: a2 04 3f ff add %l0, -1, %l1 4000f304: a0 10 00 11 mov %l1, %l0 PCHAR('0'); 4000f308: 92 10 00 19 mov %i1, %o1 4000f30c: 9f c7 40 00 call %i5 4000f310: 90 10 20 30 mov 0x30, %o0 while (dwidth-- > 0) 4000f314: a0 04 3f ff add %l0, -1, %l0 4000f318: 80 a4 3f ff cmp %l0, -1 4000f31c: 12 bf ff fc bne 4000f30c <_IO_Vprintf+0x3ec> 4000f320: 92 10 00 19 mov %i1, %o1 4000f324: 84 05 60 01 add %l5, 1, %g2 PCHAR('0'); 4000f328: aa 00 80 11 add %g2, %l1, %l5 while (*p) 4000f32c: b9 2f 20 18 sll %i4, 0x18, %i4 4000f330: 80 a7 20 00 cmp %i4, 0 4000f334: 02 80 00 0f be 4000f370 <_IO_Vprintf+0x450> <== NEVER TAKEN 4000f338: a8 10 00 15 mov %l5, %l4 *++p = hex2ascii_data[upper][num % base]; 4000f33c: a0 10 00 1b mov %i3, %l0 4000f340: 90 10 00 1c mov %i4, %o0 PCHAR(*p--); 4000f344: 91 3a 20 18 sra %o0, 0x18, %o0 4000f348: 9f c7 40 00 call %i5 4000f34c: 92 10 00 19 mov %i1, %o1 while (*p) 4000f350: d0 0c 3f ff ldub [ %l0 + -1 ], %o0 PCHAR(*p--); 4000f354: a0 04 3f ff add %l0, -1, %l0 while (*p) 4000f358: 91 2a 20 18 sll %o0, 0x18, %o0 4000f35c: 82 26 c0 10 sub %i3, %l0, %g1 4000f360: 80 a2 20 00 cmp %o0, 0 4000f364: 12 bf ff f8 bne 4000f344 <_IO_Vprintf+0x424> 4000f368: 82 00 40 15 add %g1, %l5, %g1 4000f36c: a8 10 00 01 mov %g1, %l4 if (ladjust) 4000f370: c2 07 bf c8 ld [ %fp + -56 ], %g1 4000f374: 80 a0 60 00 cmp %g1, 0 4000f378: 12 80 01 23 bne 4000f804 <_IO_Vprintf+0x8e4> 4000f37c: 80 a4 a0 00 cmp %l2, 0 while ((ch = (u_char)*fmt++) != '%' || stop) { 4000f380: d0 0d e0 01 ldub [ %l7 + 1 ], %o0 4000f384: 10 bf fe f8 b 4000ef64 <_IO_Vprintf+0x44> 4000f388: b0 10 20 00 clr %i0 if (!dot) { 4000f38c: 80 a2 a0 00 cmp %o2, 0 4000f390: 32 80 01 8a bne,a 4000f9b8 <_IO_Vprintf+0xa98> <== NEVER TAKEN 4000f394: d6 4d e0 01 ldsb [ %l7 + 1 ], %o3 <== NOT EXECUTED padc = '0'; 4000f398: d8 2f bf b3 stb %o4, [ %fp + -77 ] reswitch: switch (ch = (u_char)*fmt++) { 4000f39c: d8 0d e0 01 ldub [ %l7 + 1 ], %o4 4000f3a0: 10 bf ff 0f b 4000efdc <_IO_Vprintf+0xbc> 4000f3a4: ae 10 00 1a mov %i2, %l7 base = 16; 4000f3a8: 82 10 20 10 mov 0x10, %g1 4000f3ac: c2 27 bf a8 st %g1, [ %fp + -88 ] reswitch: switch (ch = (u_char)*fmt++) { 4000f3b0: a2 10 20 00 clr %l1 4000f3b4: a4 10 20 10 mov 0x10, %l2 upper = 1; 4000f3b8: b8 10 20 01 mov 1, %i4 if (sharpflag && num != 0) { 4000f3bc: e8 2f bf af stb %l4, [ %fp + -81 ] if (jflag) 4000f3c0: c2 07 bf cc ld [ %fp + -52 ], %g1 4000f3c4: 80 a0 60 00 cmp %g1, 0 4000f3c8: 02 80 01 04 be 4000f7d8 <_IO_Vprintf+0x8b8> 4000f3cc: 80 a1 20 00 cmp %g4, 0 num = va_arg(ap, uintmax_t); 4000f3d0: 92 10 00 16 mov %l6, %o1 4000f3d4: 94 10 20 08 mov 8, %o2 4000f3d8: 40 00 02 df call 4000ff54 4000f3dc: 90 07 bf d8 add %fp, -40, %o0 4000f3e0: c4 1f bf d8 ldd [ %fp + -40 ], %g2 lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 4000f3e4: c0 27 bf cc clr [ %fp + -52 ] num = va_arg(ap, uintmax_t); 4000f3e8: ac 05 a0 08 add %l6, 8, %l6 4000f3ec: 10 bf ff 57 b 4000f148 <_IO_Vprintf+0x228> 4000f3f0: c4 3f bf b8 std %g2, [ %fp + -72 ] PCHAR(ch); 4000f3f4: 9f c7 40 00 call %i5 4000f3f8: 92 10 00 19 mov %i1, %o1 while ((ch = (u_char)*fmt++) != '%' || stop) { 4000f3fc: d0 0d e0 01 ldub [ %l7 + 1 ], %o0 PCHAR(ch); 4000f400: 10 bf fe d9 b 4000ef64 <_IO_Vprintf+0x44> 4000f404: a8 05 60 01 add %l5, 1, %l4 if (!ladjust && width > 0) 4000f408: c2 07 bf c0 ld [ %fp + -64 ], %g1 4000f40c: 80 a0 60 01 cmp %g1, 1 4000f410: 14 80 00 03 bg 4000f41c <_IO_Vprintf+0x4fc> <== NEVER TAKEN 4000f414: b6 10 20 01 mov 1, %i3 4000f418: b6 10 20 00 clr %i3 4000f41c: c2 07 bf c8 ld [ %fp + -56 ], %g1 4000f420: 80 88 60 01 btst 1, %g1 4000f424: 12 80 00 05 bne 4000f438 <_IO_Vprintf+0x518> <== NEVER TAKEN 4000f428: b8 05 a0 04 add %l6, 4, %i4 4000f42c: 80 8e e0 ff btst 0xff, %i3 4000f430: 12 80 01 1c bne 4000f8a0 <_IO_Vprintf+0x980> <== NEVER TAKEN 4000f434: c2 07 bf c0 ld [ %fp + -64 ], %g1 PCHAR(va_arg(ap, int)); 4000f438: d0 05 80 00 ld [ %l6 ], %o0 4000f43c: 9f c7 40 00 call %i5 4000f440: 92 10 00 19 mov %i1, %o1 if (ladjust && width > 0) 4000f444: c2 07 bf c8 ld [ %fp + -56 ], %g1 4000f448: 80 88 60 01 btst 1, %g1 4000f44c: 02 80 01 25 be 4000f8e0 <_IO_Vprintf+0x9c0> <== ALWAYS TAKEN 4000f450: a8 05 60 01 add %l5, 1, %l4 4000f454: 80 8e e0 ff btst 0xff, %i3 <== NOT EXECUTED 4000f458: 22 80 01 23 be,a 4000f8e4 <_IO_Vprintf+0x9c4> <== NOT EXECUTED 4000f45c: d0 0d e0 01 ldub [ %l7 + 1 ], %o0 <== NOT EXECUTED while (width--) 4000f460: c2 07 bf c0 ld [ %fp + -64 ], %g1 <== NOT EXECUTED 4000f464: a8 00 7f fe add %g1, -2, %l4 <== NOT EXECUTED PCHAR(padc); 4000f468: c2 07 bf b0 ld [ %fp + -80 ], %g1 <== NOT EXECUTED 4000f46c: a1 28 60 18 sll %g1, 0x18, %l0 <== NOT EXECUTED while (width--) 4000f470: b6 10 00 14 mov %l4, %i3 <== NOT EXECUTED PCHAR(padc); 4000f474: a1 3c 20 18 sra %l0, 0x18, %l0 <== NOT EXECUTED PCHAR(padc); 4000f478: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000f47c: 9f c7 40 00 call %i5 <== NOT EXECUTED 4000f480: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED while (width--) 4000f484: b6 06 ff ff add %i3, -1, %i3 <== NOT EXECUTED 4000f488: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED 4000f48c: 32 bf ff fc bne,a 4000f47c <_IO_Vprintf+0x55c> <== NOT EXECUTED 4000f490: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED PCHAR(padc); 4000f494: b6 05 60 02 add %l5, 2, %i3 <== NOT EXECUTED while ((ch = (u_char)*fmt++) != '%' || stop) { 4000f498: d0 0d e0 01 ldub [ %l7 + 1 ], %o0 <== NOT EXECUTED PCHAR(va_arg(ap, int)); 4000f49c: ac 10 00 1c mov %i4, %l6 <== NOT EXECUTED PCHAR(padc); 4000f4a0: 10 bf fe b1 b 4000ef64 <_IO_Vprintf+0x44> <== NOT EXECUTED 4000f4a4: a8 06 c0 14 add %i3, %l4, %l4 <== NOT EXECUTED if (!width) 4000f4a8: c2 07 bf c0 ld [ %fp + -64 ], %g1 <== NOT EXECUTED up = va_arg(ap, u_char *); 4000f4ac: f8 05 80 00 ld [ %l6 ], %i4 <== NOT EXECUTED p = va_arg(ap, char *); 4000f4b0: e0 05 a0 04 ld [ %l6 + 4 ], %l0 <== NOT EXECUTED while(width--) { 4000f4b4: b6 10 20 0f mov 0xf, %i3 <== NOT EXECUTED if (!width) 4000f4b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000f4bc: 02 80 00 03 be 4000f4c8 <_IO_Vprintf+0x5a8> <== NOT EXECUTED 4000f4c0: ac 05 a0 08 add %l6, 8, %l6 <== NOT EXECUTED while(width--) { 4000f4c4: b6 00 7f ff add %g1, -1, %i3 <== NOT EXECUTED 4000f4c8: b6 07 00 1b add %i4, %i3, %i3 <== NOT EXECUTED for (q=p;*q;q++) 4000f4cc: a2 10 3f fe mov -2, %l1 <== NOT EXECUTED 4000f4d0: a4 10 00 15 mov %l5, %l2 <== NOT EXECUTED PCHAR(hex2ascii(*up >> 4)); 4000f4d4: e6 07 bf d0 ld [ %fp + -48 ], %l3 <== NOT EXECUTED 4000f4d8: c2 0f 00 00 ldub [ %i4 ], %g1 <== NOT EXECUTED 4000f4dc: 83 30 60 04 srl %g1, 4, %g1 <== NOT EXECUTED 4000f4e0: d0 4c c0 01 ldsb [ %l3 + %g1 ], %o0 <== NOT EXECUTED 4000f4e4: 9f c7 40 00 call %i5 <== NOT EXECUTED 4000f4e8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED PCHAR(hex2ascii(*up & 0x0f)); 4000f4ec: c2 0f 00 00 ldub [ %i4 ], %g1 <== NOT EXECUTED 4000f4f0: 82 08 60 0f and %g1, 0xf, %g1 <== NOT EXECUTED 4000f4f4: d0 4c c0 01 ldsb [ %l3 + %g1 ], %o0 <== NOT EXECUTED 4000f4f8: 9f c7 40 00 call %i5 <== NOT EXECUTED 4000f4fc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED if (width) 4000f500: 80 a7 00 1b cmp %i4, %i3 <== NOT EXECUTED 4000f504: 02 bf fe dc be 4000f074 <_IO_Vprintf+0x154> <== NOT EXECUTED 4000f508: a8 04 a0 02 add %l2, 2, %l4 <== NOT EXECUTED for (q=p;*q;q++) 4000f50c: d0 0c 00 00 ldub [ %l0 ], %o0 <== NOT EXECUTED 4000f510: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED 4000f514: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000f518: 22 80 00 0e be,a 4000f550 <_IO_Vprintf+0x630> <== NOT EXECUTED 4000f51c: b8 07 20 01 inc %i4 <== NOT EXECUTED 4000f520: a4 24 40 12 sub %l1, %l2, %l2 <== NOT EXECUTED 4000f524: a4 04 00 12 add %l0, %l2, %l2 <== NOT EXECUTED PCHAR(*q); 4000f528: 91 3a 20 18 sra %o0, 0x18, %o0 <== NOT EXECUTED 4000f52c: 9f c7 40 00 call %i5 <== NOT EXECUTED 4000f530: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000f534: a8 05 20 01 inc %l4 <== NOT EXECUTED for (q=p;*q;q++) 4000f538: d0 0c 80 14 ldub [ %l2 + %l4 ], %o0 <== NOT EXECUTED 4000f53c: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED 4000f540: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000f544: 12 bf ff fa bne 4000f52c <_IO_Vprintf+0x60c> <== NOT EXECUTED 4000f548: 91 3a 20 18 sra %o0, 0x18, %o0 <== NOT EXECUTED up++; 4000f54c: b8 07 20 01 inc %i4 <== NOT EXECUTED 4000f550: 10 bf ff e1 b 4000f4d4 <_IO_Vprintf+0x5b4> <== NOT EXECUTED 4000f554: a4 10 00 14 mov %l4, %l2 <== NOT EXECUTED width = va_arg(ap, int); 4000f558: c6 05 80 00 ld [ %l6 ], %g3 if (!dot) { 4000f55c: 80 a2 a0 00 cmp %o2, 0 4000f560: 12 80 00 ea bne 4000f908 <_IO_Vprintf+0x9e8> <== ALWAYS TAKEN 4000f564: 84 05 a0 04 add %l6, 4, %g2 if (width < 0) { 4000f568: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 4000f56c: 06 80 01 2f bl 4000fa28 <_IO_Vprintf+0xb08> <== NOT EXECUTED 4000f570: c6 27 bf c0 st %g3, [ %fp + -64 ] <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 4000f574: d8 0d e0 01 ldub [ %l7 + 1 ], %o4 dwidth = va_arg(ap, int); 4000f578: ac 10 00 02 mov %g2, %l6 reswitch: switch (ch = (u_char)*fmt++) { 4000f57c: 10 bf fe 98 b 4000efdc <_IO_Vprintf+0xbc> 4000f580: ae 10 00 1a mov %i2, %l7 if (hflag) { 4000f584: 80 a3 e0 00 cmp %o7, 0 4000f588: 12 80 00 e2 bne 4000f910 <_IO_Vprintf+0x9f0> 4000f58c: d8 0d e0 01 ldub [ %l7 + 1 ], %o4 hflag = 1; 4000f590: 9e 10 20 01 mov 1, %o7 reswitch: switch (ch = (u_char)*fmt++) { 4000f594: 10 bf fe 92 b 4000efdc <_IO_Vprintf+0xbc> 4000f598: ae 10 00 1a mov %i2, %l7 4000f59c: d8 0d e0 01 ldub [ %l7 + 1 ], %o4 jflag = 1; 4000f5a0: 84 10 20 01 mov 1, %g2 reswitch: switch (ch = (u_char)*fmt++) { 4000f5a4: ae 10 00 1a mov %i2, %l7 goto reswitch; 4000f5a8: 10 bf fe 8d b 4000efdc <_IO_Vprintf+0xbc> 4000f5ac: c4 27 bf cc st %g2, [ %fp + -52 ] if (lflag) { 4000f5b0: 80 a1 20 00 cmp %g4, 0 4000f5b4: 02 bf fe 9c be 4000f024 <_IO_Vprintf+0x104> 4000f5b8: d8 0d e0 01 ldub [ %l7 + 1 ], %o4 jflag = 1; 4000f5bc: c8 27 bf cc st %g4, [ %fp + -52 ] reswitch: switch (ch = (u_char)*fmt++) { 4000f5c0: 10 bf fe 87 b 4000efdc <_IO_Vprintf+0xbc> 4000f5c4: ae 10 00 1a mov %i2, %l7 base = 8; 4000f5c8: 82 10 20 08 mov 8, %g1 sign = 0; dot = 0; dwidth = 0; upper = 0; 4000f5cc: b8 10 20 00 clr %i4 base = 8; 4000f5d0: c2 27 bf a8 st %g1, [ %fp + -88 ] reswitch: switch (ch = (u_char)*fmt++) { 4000f5d4: a2 10 20 00 clr %l1 4000f5d8: 10 bf ff 79 b 4000f3bc <_IO_Vprintf+0x49c> 4000f5dc: a4 10 20 08 mov 8, %l2 num = (uintptr_t)va_arg(ap, void *); 4000f5e0: c2 05 80 00 ld [ %l6 ], %g1 sharpflag = (width == 0); 4000f5e4: c4 07 bf c0 ld [ %fp + -64 ], %g2 4000f5e8: 80 a0 00 02 cmp %g0, %g2 num = (uintptr_t)va_arg(ap, void *); 4000f5ec: 86 10 00 01 mov %g1, %g3 sharpflag = (width == 0); 4000f5f0: a8 60 3f ff subx %g0, -1, %l4 num = (uintptr_t)va_arg(ap, void *); 4000f5f4: 84 10 20 00 clr %g2 base = 16; 4000f5f8: 82 10 20 10 mov 0x10, %g1 num = (uintptr_t)va_arg(ap, void *); 4000f5fc: c4 3f bf b8 std %g2, [ %fp + -72 ] 4000f600: ac 05 a0 04 add %l6, 4, %l6 sharpflag = (width == 0); 4000f604: e8 2f bf af stb %l4, [ %fp + -81 ] sign = 0; dot = 0; dwidth = 0; upper = 0; 4000f608: b8 10 20 00 clr %i4 lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 4000f60c: c0 27 bf cc clr [ %fp + -52 ] goto number; 4000f610: a2 10 20 00 clr %l1 base = 16; 4000f614: c2 27 bf a8 st %g1, [ %fp + -88 ] goto number; 4000f618: 10 bf fe cc b 4000f148 <_IO_Vprintf+0x228> 4000f61c: a4 10 20 10 mov 0x10, %l2 p = va_arg(ap, char *); 4000f620: f8 05 80 00 ld [ %l6 ], %i4 if (p == NULL) 4000f624: 80 a7 20 00 cmp %i4, 0 4000f628: 02 80 00 c6 be 4000f940 <_IO_Vprintf+0xa20> 4000f62c: ac 05 a0 04 add %l6, 4, %l6 if (!ladjust && width > 0) 4000f630: c2 07 bf c8 ld [ %fp + -56 ], %g1 4000f634: a0 18 60 01 xor %g1, 1, %l0 if (!dot) 4000f638: 80 a2 a0 00 cmp %o2, 0 4000f63c: 12 80 00 e7 bne 4000f9d8 <_IO_Vprintf+0xab8> 4000f640: a0 0c 20 01 and %l0, 1, %l0 n = strlen (p); 4000f644: 40 00 03 c9 call 40010568 4000f648: 90 10 00 1c mov %i4, %o0 4000f64c: a2 10 00 08 mov %o0, %l1 width -= n; 4000f650: c2 07 bf c0 ld [ %fp + -64 ], %g1 4000f654: 84 20 40 11 sub %g1, %l1, %g2 4000f658: c4 27 bf c0 st %g2, [ %fp + -64 ] if (!ladjust && width > 0) 4000f65c: 83 38 a0 1f sra %g2, 0x1f, %g1 while (n--) 4000f660: a8 04 7f ff add %l1, -1, %l4 if (!ladjust && width > 0) 4000f664: 82 20 40 02 sub %g1, %g2, %g1 4000f668: 80 a0 60 00 cmp %g1, 0 4000f66c: 16 80 00 05 bge 4000f680 <_IO_Vprintf+0x760> 4000f670: 89 30 60 1f srl %g1, 0x1f, %g4 4000f674: 80 a4 20 00 cmp %l0, 0 4000f678: 12 80 00 b5 bne 4000f94c <_IO_Vprintf+0xa2c> 4000f67c: c2 07 bf b0 ld [ %fp + -80 ], %g1 if (ladjust && width > 0) 4000f680: c2 07 bf c8 ld [ %fp + -56 ], %g1 while (n--) 4000f684: 80 a4 60 00 cmp %l1, 0 4000f688: 02 80 00 42 be 4000f790 <_IO_Vprintf+0x870> 4000f68c: b6 08 40 04 and %g1, %g4, %i3 if (ladjust && width > 0) 4000f690: a2 10 00 1c mov %i4, %l1 while (n--) 4000f694: a0 10 20 01 mov 1, %l0 PCHAR(*p++); 4000f698: d0 4c 40 00 ldsb [ %l1 ], %o0 4000f69c: 9f c7 40 00 call %i5 4000f6a0: 92 10 00 19 mov %i1, %o1 4000f6a4: a2 04 60 01 inc %l1 while (n--) 4000f6a8: 82 24 00 11 sub %l0, %l1, %g1 4000f6ac: 82 07 00 01 add %i4, %g1, %g1 4000f6b0: 82 00 40 14 add %g1, %l4, %g1 4000f6b4: 80 a0 60 00 cmp %g1, 0 4000f6b8: 32 bf ff f9 bne,a 4000f69c <_IO_Vprintf+0x77c> 4000f6bc: d0 4c 40 00 ldsb [ %l1 ], %o0 4000f6c0: 84 05 60 01 add %l5, 1, %g2 PCHAR(*p++); 4000f6c4: a8 05 00 02 add %l4, %g2, %l4 if (ladjust && width > 0) 4000f6c8: 80 8e e0 ff btst 0xff, %i3 4000f6cc: 22 bf fe 26 be,a 4000ef64 <_IO_Vprintf+0x44> 4000f6d0: d0 0d e0 01 ldub [ %l7 + 1 ], %o0 PCHAR(padc); 4000f6d4: c2 07 bf b0 ld [ %fp + -80 ], %g1 while (width--) 4000f6d8: e4 07 bf c0 ld [ %fp + -64 ], %l2 PCHAR(padc); 4000f6dc: b9 28 60 18 sll %g1, 0x18, %i4 while (width--) 4000f6e0: a0 04 bf ff add %l2, -1, %l0 PCHAR(padc); 4000f6e4: b9 3f 20 18 sra %i4, 0x18, %i4 PCHAR(padc); 4000f6e8: 92 10 00 19 mov %i1, %o1 4000f6ec: 9f c7 40 00 call %i5 4000f6f0: 90 10 00 1c mov %i4, %o0 while (width--) 4000f6f4: a4 84 bf ff addcc %l2, -1, %l2 4000f6f8: 32 bf ff fd bne,a 4000f6ec <_IO_Vprintf+0x7cc> 4000f6fc: 92 10 00 19 mov %i1, %o1 4000f700: b6 05 20 01 add %l4, 1, %i3 PCHAR(' '); 4000f704: a8 04 00 1b add %l0, %i3, %l4 while ((ch = (u_char)*fmt++) != '%' || stop) { 4000f708: 10 bf fe 17 b 4000ef64 <_IO_Vprintf+0x44> 4000f70c: d0 0d e0 01 ldub [ %l7 + 1 ], %o0 reswitch: switch (ch = (u_char)*fmt++) { 4000f710: d8 0d e0 01 ldub [ %l7 + 1 ], %o4 ladjust = 1; 4000f714: 84 10 20 01 mov 1, %g2 reswitch: switch (ch = (u_char)*fmt++) { 4000f718: ae 10 00 1a mov %i2, %l7 goto reswitch; 4000f71c: 10 bf fe 30 b 4000efdc <_IO_Vprintf+0xbc> 4000f720: c4 27 bf c8 st %g2, [ %fp + -56 ] reswitch: switch (ch = (u_char)*fmt++) { 4000f724: d8 0d e0 01 ldub [ %l7 + 1 ], %o4 dot = 1; 4000f728: 94 10 20 01 mov 1, %o2 reswitch: switch (ch = (u_char)*fmt++) { 4000f72c: 10 bf fe 2c b 4000efdc <_IO_Vprintf+0xbc> 4000f730: ae 10 00 1a mov %i2, %l7 4000f734: d8 0d e0 01 ldub [ %l7 + 1 ], %o4 sharpflag = 1; 4000f738: a8 10 20 01 mov 1, %l4 goto reswitch; 4000f73c: 10 bf fe 28 b 4000efdc <_IO_Vprintf+0xbc> 4000f740: ae 10 00 1a mov %i2, %l7 base = 10; 4000f744: 82 10 20 0a mov 0xa, %g1 sign = 0; dot = 0; dwidth = 0; upper = 0; 4000f748: b8 10 20 00 clr %i4 base = 10; 4000f74c: c2 27 bf a8 st %g1, [ %fp + -88 ] reswitch: switch (ch = (u_char)*fmt++) { 4000f750: a2 10 20 00 clr %l1 4000f754: 10 bf ff 1a b 4000f3bc <_IO_Vprintf+0x49c> 4000f758: a4 10 20 0a mov 0xa, %l2 4000f75c: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED 4000f760: a2 10 20 00 clr %l1 <== NOT EXECUTED 4000f764: c2 27 bf a8 st %g1, [ %fp + -88 ] <== NOT EXECUTED 4000f768: 10 bf fe 62 b 4000f0f0 <_IO_Vprintf+0x1d0> <== NOT EXECUTED 4000f76c: a4 10 20 10 mov 0x10, %l2 <== NOT EXECUTED 4000f770: 82 10 20 10 mov 0x10, %g1 4000f774: b8 10 20 00 clr %i4 4000f778: c2 27 bf a8 st %g1, [ %fp + -88 ] 4000f77c: a2 10 20 00 clr %l1 4000f780: 10 bf ff 0f b 4000f3bc <_IO_Vprintf+0x49c> 4000f784: a4 10 20 10 mov 0x10, %l2 4000f788: 10 bf fe 51 b 4000f0cc <_IO_Vprintf+0x1ac> 4000f78c: ae 10 00 1a mov %i2, %l7 while (n--) 4000f790: 10 bf ff ce b 4000f6c8 <_IO_Vprintf+0x7a8> 4000f794: a8 10 00 15 mov %l5, %l4 static inline int imax(int a, int b) { return (a > b ? a : b); } 4000f798: c4 07 bf b4 ld [ %fp + -76 ], %g2 4000f79c: 80 a0 80 10 cmp %g2, %l0 4000f7a0: 16 80 00 04 bge 4000f7b0 <_IO_Vprintf+0x890> 4000f7a4: 88 10 00 02 mov %g2, %g4 4000f7a8: 88 10 00 10 mov %l0, %g4 dwidth -= n; 4000f7ac: c4 07 bf b4 ld [ %fp + -76 ], %g2 width -= tmp + imax(dwidth, n); 4000f7b0: 82 01 00 01 add %g4, %g1, %g1 dwidth -= n; 4000f7b4: a0 20 80 10 sub %g2, %l0, %l0 width -= tmp + imax(dwidth, n); 4000f7b8: c4 07 bf c0 ld [ %fp + -64 ], %g2 4000f7bc: a4 20 80 01 sub %g2, %g1, %l2 if (!ladjust) 4000f7c0: c2 07 bf c8 ld [ %fp + -56 ], %g1 4000f7c4: 80 a0 60 00 cmp %g1, 0 4000f7c8: 12 bf fe b4 bne 4000f298 <_IO_Vprintf+0x378> 4000f7cc: c2 07 bf cc ld [ %fp + -52 ], %g1 4000f7d0: 10 bf fe a5 b 4000f264 <_IO_Vprintf+0x344> 4000f7d4: a2 04 bf ff add %l2, -1, %l1 else if (lflag) 4000f7d8: 12 80 00 1d bne 4000f84c <_IO_Vprintf+0x92c> 4000f7dc: 82 05 a0 04 add %l6, 4, %g1 else if (hflag) 4000f7e0: 80 a3 e0 00 cmp %o7, 0 4000f7e4: 02 80 00 4f be 4000f920 <_IO_Vprintf+0xa00> 4000f7e8: 80 a3 60 00 cmp %o5, 0 num = (u_short)va_arg(ap, int); 4000f7ec: c8 15 a0 02 lduh [ %l6 + 2 ], %g4 4000f7f0: 86 10 00 04 mov %g4, %g3 4000f7f4: 84 10 20 00 clr %g2 4000f7f8: ac 10 00 01 mov %g1, %l6 4000f7fc: 10 bf fe 53 b 4000f148 <_IO_Vprintf+0x228> 4000f800: c4 3f bf b8 std %g2, [ %fp + -72 ] while (width-- > 0) 4000f804: 04 bf fe 1c ble 4000f074 <_IO_Vprintf+0x154> 4000f808: a0 04 bf ff add %l2, -1, %l0 4000f80c: b8 10 00 10 mov %l0, %i4 PCHAR(' '); 4000f810: 92 10 00 19 mov %i1, %o1 4000f814: 9f c7 40 00 call %i5 4000f818: 90 10 20 20 mov 0x20, %o0 while (width-- > 0) 4000f81c: b8 07 3f ff add %i4, -1, %i4 4000f820: 80 a7 3f ff cmp %i4, -1 4000f824: 32 bf ff fc bne,a 4000f814 <_IO_Vprintf+0x8f4> 4000f828: 92 10 00 19 mov %i1, %o1 4000f82c: b6 05 20 01 add %l4, 1, %i3 PCHAR(' '); 4000f830: 10 bf ff b6 b 4000f708 <_IO_Vprintf+0x7e8> 4000f834: a8 04 00 1b add %l0, %i3, %l4 PCHAR('0'); 4000f838: 90 10 20 30 mov 0x30, %o0 <== NOT EXECUTED 4000f83c: 9f c7 40 00 call %i5 <== NOT EXECUTED 4000f840: aa 05 60 01 inc %l5 <== NOT EXECUTED 4000f844: 10 bf fe ae b 4000f2fc <_IO_Vprintf+0x3dc> <== NOT EXECUTED 4000f848: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED num = va_arg(ap, u_int); 4000f84c: c8 05 80 00 ld [ %l6 ], %g4 4000f850: 86 10 00 04 mov %g4, %g3 4000f854: 84 10 20 00 clr %g2 4000f858: ac 10 00 01 mov %g1, %l6 4000f85c: 10 bf fe 3b b 4000f148 <_IO_Vprintf+0x228> 4000f860: c4 3f bf b8 std %g2, [ %fp + -72 ] else if (tflag) 4000f864: 80 a1 20 00 cmp %g4, 0 4000f868: 12 80 00 21 bne 4000f8ec <_IO_Vprintf+0x9cc> 4000f86c: b8 05 a0 04 add %l6, 4, %i4 else if (hflag) 4000f870: 80 a3 e0 00 cmp %o7, 0 4000f874: 02 80 00 4b be 4000f9a0 <_IO_Vprintf+0xa80> <== ALWAYS TAKEN 4000f878: 80 a3 60 00 cmp %o5, 0 num = (short)va_arg(ap, int); 4000f87c: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED 4000f880: ac 10 00 1c mov %i4, %l6 <== NOT EXECUTED 4000f884: 89 38 60 10 sra %g1, 0x10, %g4 <== NOT EXECUTED num = (char)va_arg(ap, int); 4000f888: 83 38 60 1f sra %g1, 0x1f, %g1 <== NOT EXECUTED 4000f88c: c8 27 bf bc st %g4, [ %fp + -68 ] <== NOT EXECUTED if (sign && (intmax_t)num < 0) { 4000f890: c8 27 bf a4 st %g4, [ %fp + -92 ] <== NOT EXECUTED num = (char)va_arg(ap, int); 4000f894: c2 27 bf b8 st %g1, [ %fp + -72 ] <== NOT EXECUTED 4000f898: 10 bf fe 22 b 4000f120 <_IO_Vprintf+0x200> <== NOT EXECUTED 4000f89c: c2 27 bf a0 st %g1, [ %fp + -96 ] <== NOT EXECUTED while (width--) 4000f8a0: a4 00 7f fe add %g1, -2, %l2 <== NOT EXECUTED PCHAR(padc); 4000f8a4: c2 07 bf b0 ld [ %fp + -80 ], %g1 <== NOT EXECUTED 4000f8a8: a1 28 60 18 sll %g1, 0x18, %l0 <== NOT EXECUTED while (width--) 4000f8ac: b6 10 00 12 mov %l2, %i3 <== NOT EXECUTED PCHAR(padc); 4000f8b0: a1 3c 20 18 sra %l0, 0x18, %l0 <== NOT EXECUTED 4000f8b4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000f8b8: 9f c7 40 00 call %i5 <== NOT EXECUTED 4000f8bc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED while (width--) 4000f8c0: b6 06 ff ff add %i3, -1, %i3 <== NOT EXECUTED 4000f8c4: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED 4000f8c8: 12 bf ff fc bne 4000f8b8 <_IO_Vprintf+0x998> <== NOT EXECUTED 4000f8cc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED PCHAR(va_arg(ap, int)); 4000f8d0: d0 05 80 00 ld [ %l6 ], %o0 <== NOT EXECUTED 4000f8d4: b6 04 80 15 add %l2, %l5, %i3 <== NOT EXECUTED 4000f8d8: 9f c7 40 00 call %i5 <== NOT EXECUTED 4000f8dc: a8 06 e0 02 add %i3, 2, %l4 <== NOT EXECUTED while ((ch = (u_char)*fmt++) != '%' || stop) { 4000f8e0: d0 0d e0 01 ldub [ %l7 + 1 ], %o0 PCHAR(va_arg(ap, int)); 4000f8e4: 10 bf fd a0 b 4000ef64 <_IO_Vprintf+0x44> 4000f8e8: ac 10 00 1c mov %i4, %l6 num = va_arg(ap, int); 4000f8ec: 89 38 60 1f sra %g1, 0x1f, %g4 4000f8f0: c2 27 bf bc st %g1, [ %fp + -68 ] 4000f8f4: ac 10 00 1c mov %i4, %l6 if (sign && (intmax_t)num < 0) { 4000f8f8: c2 27 bf a4 st %g1, [ %fp + -92 ] num = va_arg(ap, int); 4000f8fc: c8 27 bf b8 st %g4, [ %fp + -72 ] if (sign && (intmax_t)num < 0) { 4000f900: 10 bf fe 08 b 4000f120 <_IO_Vprintf+0x200> 4000f904: c8 27 bf a0 st %g4, [ %fp + -96 ] dwidth = va_arg(ap, int); 4000f908: 10 bf ff 1b b 4000f574 <_IO_Vprintf+0x654> 4000f90c: c6 27 bf b4 st %g3, [ %fp + -76 ] cflag = 1; 4000f910: 9a 10 00 0f mov %o7, %o5 reswitch: switch (ch = (u_char)*fmt++) { 4000f914: ae 10 00 1a mov %i2, %l7 hflag = 0; 4000f918: 10 bf fd b1 b 4000efdc <_IO_Vprintf+0xbc> 4000f91c: 9e 10 20 00 clr %o7 else if (cflag) 4000f920: 22 bf ff cc be,a 4000f850 <_IO_Vprintf+0x930> 4000f924: c8 05 80 00 ld [ %l6 ], %g4 num = (u_char)va_arg(ap, int); 4000f928: c8 0d a0 03 ldub [ %l6 + 3 ], %g4 4000f92c: 86 10 00 04 mov %g4, %g3 4000f930: 84 10 20 00 clr %g2 4000f934: ac 10 00 01 mov %g1, %l6 4000f938: 10 bf fe 04 b 4000f148 <_IO_Vprintf+0x228> 4000f93c: c4 3f bf b8 std %g2, [ %fp + -72 ] p = "(null)"; 4000f940: 10 bf ff 3c b 4000f630 <_IO_Vprintf+0x710> 4000f944: f8 07 bf c4 ld [ %fp + -60 ], %i4 PCHAR(padc); 4000f948: c2 07 bf b0 ld [ %fp + -80 ], %g1 <== NOT EXECUTED while (width--) 4000f94c: e4 07 bf c0 ld [ %fp + -64 ], %l2 PCHAR(padc); 4000f950: a7 28 60 18 sll %g1, 0x18, %l3 while (width--) 4000f954: a0 04 bf ff add %l2, -1, %l0 PCHAR(padc); 4000f958: a7 3c e0 18 sra %l3, 0x18, %l3 PCHAR(padc); 4000f95c: 92 10 00 19 mov %i1, %o1 4000f960: 9f c7 40 00 call %i5 4000f964: 90 10 00 13 mov %l3, %o0 while (width--) 4000f968: a4 84 bf ff addcc %l2, -1, %l2 4000f96c: 12 bf ff fd bne 4000f960 <_IO_Vprintf+0xa40> 4000f970: 92 10 00 19 mov %i1, %o1 while (n--) 4000f974: 82 10 3f ff mov -1, %g1 4000f978: c2 27 bf c0 st %g1, [ %fp + -64 ] PCHAR(padc); 4000f97c: 84 05 60 01 add %l5, 1, %g2 while (n--) 4000f980: b6 10 20 00 clr %i3 4000f984: 80 a4 60 00 cmp %l1, 0 4000f988: 12 bf ff 42 bne 4000f690 <_IO_Vprintf+0x770> <== ALWAYS TAKEN 4000f98c: aa 00 80 10 add %g2, %l0, %l5 while ((ch = (u_char)*fmt++) != '%' || stop) { 4000f990: d0 0d e0 01 ldub [ %l7 + 1 ], %o0 <== NOT EXECUTED PCHAR(padc); 4000f994: a8 10 00 15 mov %l5, %l4 <== NOT EXECUTED while (n--) 4000f998: 10 bf fd 73 b 4000ef64 <_IO_Vprintf+0x44> <== NOT EXECUTED 4000f99c: b0 10 20 00 clr %i0 <== NOT EXECUTED else if (cflag) 4000f9a0: 22 bf ff d4 be,a 4000f8f0 <_IO_Vprintf+0x9d0> <== ALWAYS TAKEN 4000f9a4: 89 38 60 1f sra %g1, 0x1f, %g4 num = (char)va_arg(ap, int); 4000f9a8: 83 28 60 18 sll %g1, 0x18, %g1 <== NOT EXECUTED 4000f9ac: ac 10 00 1c mov %i4, %l6 <== NOT EXECUTED 4000f9b0: 10 bf ff b6 b 4000f888 <_IO_Vprintf+0x968> <== NOT EXECUTED 4000f9b4: 89 38 60 18 sra %g1, 0x18, %g4 <== NOT EXECUTED if (ch < '0' || ch > '9') 4000f9b8: 86 02 ff d0 add %o3, -48, %g3 <== NOT EXECUTED ch = *fmt; 4000f9bc: d8 0d e0 01 ldub [ %l7 + 1 ], %o4 <== NOT EXECUTED if (ch < '0' || ch > '9') 4000f9c0: 80 a0 e0 09 cmp %g3, 9 <== NOT EXECUTED 4000f9c4: 08 bf fd b4 bleu 4000f094 <_IO_Vprintf+0x174> <== NOT EXECUTED 4000f9c8: 84 02 3f d0 add %o0, -48, %g2 <== NOT EXECUTED n = n * 10 + ch - '0'; 4000f9cc: c4 27 bf b4 st %g2, [ %fp + -76 ] <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 4000f9d0: 10 bf fd 83 b 4000efdc <_IO_Vprintf+0xbc> <== NOT EXECUTED 4000f9d4: ae 10 00 1a mov %i2, %l7 <== NOT EXECUTED for (n = 0; n < dwidth && p[n]; n++) 4000f9d8: c2 07 bf b4 ld [ %fp + -76 ], %g1 4000f9dc: 80 a0 60 00 cmp %g1, 0 4000f9e0: 04 80 00 2e ble 4000fa98 <_IO_Vprintf+0xb78> <== NEVER TAKEN 4000f9e4: a2 10 20 00 clr %l1 4000f9e8: c2 4f 00 11 ldsb [ %i4 + %l1 ], %g1 4000f9ec: 80 a0 60 00 cmp %g1, 0 4000f9f0: 02 bf ff 19 be 4000f654 <_IO_Vprintf+0x734> <== NEVER TAKEN 4000f9f4: c2 07 bf c0 ld [ %fp + -64 ], %g1 4000f9f8: c4 07 bf b4 ld [ %fp + -76 ], %g2 4000f9fc: 82 04 60 01 add %l1, 1, %g1 4000fa00: 80 a0 40 02 cmp %g1, %g2 4000fa04: 22 80 00 16 be,a 4000fa5c <_IO_Vprintf+0xb3c> 4000fa08: c2 07 bf c0 ld [ %fp + -64 ], %g1 4000fa0c: a2 10 00 01 mov %g1, %l1 4000fa10: c2 4f 00 11 ldsb [ %i4 + %l1 ], %g1 4000fa14: 80 a0 60 00 cmp %g1, 0 4000fa18: 22 bf ff 0f be,a 4000f654 <_IO_Vprintf+0x734> 4000fa1c: c2 07 bf c0 ld [ %fp + -64 ], %g1 4000fa20: 10 bf ff f8 b 4000fa00 <_IO_Vprintf+0xae0> 4000fa24: 82 04 60 01 add %l1, 1, %g1 ladjust = !ladjust; 4000fa28: c6 07 bf c8 ld [ %fp + -56 ], %g3 <== NOT EXECUTED 4000fa2c: 86 18 e0 01 xor %g3, 1, %g3 <== NOT EXECUTED 4000fa30: c6 27 bf c8 st %g3, [ %fp + -56 ] <== NOT EXECUTED width = va_arg(ap, int); 4000fa34: ac 10 00 02 mov %g2, %l6 <== NOT EXECUTED width = -width; 4000fa38: c6 07 bf c0 ld [ %fp + -64 ], %g3 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 4000fa3c: d8 0d e0 01 ldub [ %l7 + 1 ], %o4 <== NOT EXECUTED width = -width; 4000fa40: 86 20 00 03 neg %g3 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 4000fa44: ae 10 00 1a mov %i2, %l7 <== NOT EXECUTED width = -width; 4000fa48: 10 bf fd 65 b 4000efdc <_IO_Vprintf+0xbc> <== NOT EXECUTED 4000fa4c: c6 27 bf c0 st %g3, [ %fp + -64 ] <== NOT EXECUTED lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 4000fa50: c0 27 bf cc clr [ %fp + -52 ] 4000fa54: 10 bf fd bd b 4000f148 <_IO_Vprintf+0x228> 4000fa58: b8 10 20 00 clr %i4 width -= n; 4000fa5c: c4 07 bf b4 ld [ %fp + -76 ], %g2 4000fa60: 84 20 40 02 sub %g1, %g2, %g2 4000fa64: c4 27 bf c0 st %g2, [ %fp + -64 ] if (!ladjust && width > 0) 4000fa68: 83 38 a0 1f sra %g2, 0x1f, %g1 4000fa6c: 82 20 40 02 sub %g1, %g2, %g1 4000fa70: 80 a0 60 00 cmp %g1, 0 4000fa74: 16 80 00 05 bge 4000fa88 <_IO_Vprintf+0xb68> <== ALWAYS TAKEN 4000fa78: 89 30 60 1f srl %g1, 0x1f, %g4 4000fa7c: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 4000fa80: 32 80 00 13 bne,a 4000facc <_IO_Vprintf+0xbac> <== NOT EXECUTED 4000fa84: a8 10 00 11 mov %l1, %l4 <== NOT EXECUTED if (ladjust && width > 0) 4000fa88: c2 07 bf c8 ld [ %fp + -56 ], %g1 4000fa8c: b6 08 40 04 and %g1, %g4, %i3 4000fa90: 10 bf ff 00 b 4000f690 <_IO_Vprintf+0x770> 4000fa94: a8 10 00 11 mov %l1, %l4 if (!ladjust && width > 0) 4000fa98: c4 07 bf c0 ld [ %fp + -64 ], %g2 <== NOT EXECUTED 4000fa9c: 83 38 a0 1f sra %g2, 0x1f, %g1 <== NOT EXECUTED 4000faa0: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 4000faa4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000faa8: 16 80 00 05 bge 4000fabc <_IO_Vprintf+0xb9c> <== NOT EXECUTED 4000faac: 89 30 60 1f srl %g1, 0x1f, %g4 <== NOT EXECUTED 4000fab0: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 4000fab4: 32 bf ff a5 bne,a 4000f948 <_IO_Vprintf+0xa28> <== NOT EXECUTED 4000fab8: a8 10 3f ff mov -1, %l4 <== NOT EXECUTED if (ladjust && width > 0) 4000fabc: c2 07 bf c8 ld [ %fp + -56 ], %g1 <== NOT EXECUTED 4000fac0: b6 08 40 04 and %g1, %g4, %i3 <== NOT EXECUTED 4000fac4: 10 bf ff 01 b 4000f6c8 <_IO_Vprintf+0x7a8> <== NOT EXECUTED 4000fac8: a8 10 00 15 mov %l5, %l4 <== NOT EXECUTED if (!ladjust && width > 0) 4000facc: 10 bf ff 9f b 4000f948 <_IO_Vprintf+0xa28> <== NOT EXECUTED 4000fad0: e2 07 bf b4 ld [ %fp + -76 ], %l1 <== NOT EXECUTED =============================================================================== 400049bc <_Internal_error>: /* will not return from this routine */ while (true); } void _Internal_error( Internal_errors_Core_list core_error ) { 400049bc: 9d e3 bf a0 save %sp, -96, %sp _Terminate( INTERNAL_ERROR_CORE, core_error ); 400049c0: 90 10 20 00 clr %o0 400049c4: 7f ff ff eb call 40004970 <_Terminate> 400049c8: 92 10 00 18 mov %i0, %o1 400049cc: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 4000fee8 <_Memory_Allocate>: { Memory_Area *area; const Memory_Area *end; uintptr_t alignment_mask; area = &information->areas[ 0 ]; 4000fee8: c2 02 20 04 ld [ %o0 + 4 ], %g1 end = &information->areas[ information->count ]; 4000feec: c4 02 00 00 ld [ %o0 ], %g2 4000fef0: 89 28 a0 01 sll %g2, 1, %g4 4000fef4: 88 01 00 02 add %g4, %g2, %g4 4000fef8: 89 29 20 02 sll %g4, 2, %g4 4000fefc: 88 00 40 04 add %g1, %g4, %g4 alignment_mask = alignment - 1; while ( area != end ) { 4000ff00: 80 a0 40 04 cmp %g1, %g4 4000ff04: 02 80 00 13 be 4000ff50 <_Memory_Allocate+0x68> <== NEVER TAKEN 4000ff08: 9a 02 bf ff add %o2, -1, %o5 4000ff0c: 10 80 00 05 b 4000ff20 <_Memory_Allocate+0x38> 4000ff10: 94 20 00 0a neg %o2 4000ff14: 80 a1 00 01 cmp %g4, %g1 <== NOT EXECUTED 4000ff18: 02 80 00 0e be 4000ff50 <_Memory_Allocate+0x68> <== NOT EXECUTED 4000ff1c: 01 00 00 00 nop <== NOT EXECUTED uintptr_t alloc_begin; uintptr_t alloc_end; alloc_begin = (uintptr_t) area->free; 4000ff20: d0 00 60 04 ld [ %g1 + 4 ], %o0 alloc_begin += alignment_mask; 4000ff24: 90 03 40 08 add %o5, %o0, %o0 alloc_begin &= ~alignment_mask; 4000ff28: 90 0a 00 0a and %o0, %o2, %o0 alloc_end = alloc_begin + size; 4000ff2c: 84 82 00 09 addcc %o0, %o1, %g2 area->free = (void *) alloc_end; return (void *) alloc_begin; } ++area; 4000ff30: 2a bf ff f9 bcs,a 4000ff14 <_Memory_Allocate+0x2c> <== NEVER TAKEN 4000ff34: 82 00 60 0c add %g1, 0xc, %g1 <== NOT EXECUTED if ( alloc_begin <= alloc_end && alloc_end <= (uintptr_t) area->end ) { 4000ff38: c6 00 60 08 ld [ %g1 + 8 ], %g3 4000ff3c: 80 a0 c0 02 cmp %g3, %g2 4000ff40: 2a bf ff f5 bcs,a 4000ff14 <_Memory_Allocate+0x2c> <== NEVER TAKEN 4000ff44: 82 00 60 0c add %g1, 0xc, %g1 <== NOT EXECUTED return (void *) alloc_begin; 4000ff48: 81 c3 e0 08 retl 4000ff4c: c4 20 60 04 st %g2, [ %g1 + 4 ] } return NULL; } 4000ff50: 81 c3 e0 08 retl <== NOT EXECUTED 4000ff54: 90 10 20 00 clr %o0 <== NOT EXECUTED =============================================================================== 400049a4 <_Memory_Fill>: #include #include void _Memory_Fill( const Memory_Information *information, int c ) { 400049a4: 9d e3 bf a0 save %sp, -96, %sp Memory_Area *area; const Memory_Area *end; area = &information->areas[ 0 ]; 400049a8: fa 06 20 04 ld [ %i0 + 4 ], %i5 end = &information->areas[ information->count ]; 400049ac: c2 06 00 00 ld [ %i0 ], %g1 400049b0: b9 28 60 01 sll %g1, 1, %i4 400049b4: b8 07 00 01 add %i4, %g1, %i4 400049b8: b9 2f 20 02 sll %i4, 2, %i4 400049bc: b8 07 40 1c add %i5, %i4, %i4 while ( area != end ) { 400049c0: 80 a7 40 1c cmp %i5, %i4 400049c4: 02 80 00 0b be 400049f0 <_Memory_Fill+0x4c> <== NEVER TAKEN 400049c8: 01 00 00 00 nop * * @return The free memory area begin the memory area. */ RTEMS_INLINE_ROUTINE void *_Memory_Get_free_begin( const Memory_Area *area ) { return area->free; 400049cc: d0 07 60 04 ld [ %i5 + 4 ], %o0 * * @return The free memory area size in bytes of the memory area. */ RTEMS_INLINE_ROUTINE uintptr_t _Memory_Get_free_size( const Memory_Area *area ) { return (uintptr_t) area->end - (uintptr_t) area->free; 400049d0: d4 07 60 08 ld [ %i5 + 8 ], %o2 memset( _Memory_Get_free_begin( area ), c, _Memory_Get_free_size( area ) ); 400049d4: 94 22 80 08 sub %o2, %o0, %o2 400049d8: 40 00 23 fa call 4000d9c0 400049dc: 92 10 00 19 mov %i1, %o1 ++area; 400049e0: ba 07 60 0c add %i5, 0xc, %i5 while ( area != end ) { 400049e4: 80 a7 00 1d cmp %i4, %i5 400049e8: 32 bf ff fa bne,a 400049d0 <_Memory_Fill+0x2c> <== NEVER TAKEN 400049ec: d0 07 60 04 ld [ %i5 + 4 ], %o0 <== NOT EXECUTED } } 400049f0: 81 c7 e0 08 ret 400049f4: 81 e8 00 00 restore =============================================================================== 40009210 <_Objects_Extend_information>: #include /* for memcpy() */ Objects_Maximum _Objects_Extend_information( Objects_Information *information ) { 40009210: 9d e3 bf 98 save %sp, -104, %sp */ RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Extend_size( const Objects_Information *information ) { return information->objects_per_block; 40009214: c8 16 20 12 lduh [ %i0 + 0x12 ], %g4 ); _Assert( _Objects_Is_auto_extend( information ) ); extend_count = _Objects_Extend_size( information ); old_maximum = _Objects_Get_maximum_index( information ); new_maximum = (uint32_t) old_maximum + extend_count; 40009218: e2 16 20 02 lduh [ %i0 + 2 ], %l1 */ do_extend = true; index_base = extend_count; block = 1; if ( information->object_blocks == NULL ) { 4000921c: c6 06 20 28 ld [ %i0 + 0x28 ], %g3 new_maximum = (uint32_t) old_maximum + extend_count; 40009220: 89 29 20 10 sll %g4, 0x10, %g4 40009224: e8 06 00 00 ld [ %i0 ], %l4 40009228: 85 31 20 10 srl %g4, 0x10, %g2 if ( information->object_blocks == NULL ) { 4000922c: 80 a0 e0 00 cmp %g3, 0 new_maximum = (uint32_t) old_maximum + extend_count; 40009230: a0 00 80 11 add %g2, %l1, %l0 if ( information->object_blocks == NULL ) { 40009234: 02 80 00 51 be 40009378 <_Objects_Extend_information+0x168> 40009238: b9 28 a0 01 sll %g2, 1, %i4 block_count = 1; } else { block_count = old_maximum / extend_count; 4000923c: 83 2d 20 10 sll %l4, 0x10, %g1 40009240: 83 30 60 10 srl %g1, 0x10, %g1 40009244: 81 80 20 00 wr %g0, %y 40009248: 01 00 00 00 nop 4000924c: 01 00 00 00 nop 40009250: 01 00 00 00 nop 40009254: a4 70 40 02 udiv %g1, %g2, %l2 for ( ; block < block_count; block++ ) { 40009258: 80 a4 a0 01 cmp %l2, 1 4000925c: 08 80 00 82 bleu 40009464 <_Objects_Extend_information+0x254> <== NEVER TAKEN 40009260: b4 10 00 02 mov %g2, %i2 index_base = extend_count; 40009264: b8 10 00 02 mov %g2, %i4 block = 1; 40009268: 10 80 00 06 b 40009280 <_Objects_Extend_information+0x70> 4000926c: ba 10 20 01 mov 1, %i5 for ( ; block < block_count; block++ ) { 40009270: ba 07 60 01 inc %i5 40009274: 80 a4 80 1d cmp %l2, %i5 40009278: 02 80 00 3d be 4000936c <_Objects_Extend_information+0x15c> 4000927c: b4 10 00 1c mov %i4, %i2 if ( information->object_blocks[ block ] == NULL ) { 40009280: 83 2f 60 02 sll %i5, 2, %g1 40009284: c2 00 c0 01 ld [ %g3 + %g1 ], %g1 40009288: b4 10 00 1c mov %i4, %i2 4000928c: 80 a0 60 00 cmp %g1, 0 40009290: 12 bf ff f8 bne 40009270 <_Objects_Extend_information+0x60> 40009294: b8 07 00 02 add %i4, %g2, %i4 do_extend = false; 40009298: b2 10 20 00 clr %i1 /* * 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 ( new_maximum > OBJECTS_ID_FINAL_INDEX ) { 4000929c: 03 00 00 3f sethi %hi(0xfc00), %g1 400092a0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <_ISR_Stack_size+0xefff> 400092a4: 80 a4 00 01 cmp %l0, %g1 400092a8: 38 80 00 2d bgu,a 4000935c <_Objects_Extend_information+0x14c> 400092ac: ba 10 20 00 clr %i5 /* * Allocate the name table, and the objects and if it fails either return or * generate a fatal error depending on auto-extending being active. */ object_block_size = extend_count * information->object_size; 400092b0: d0 16 20 14 lduh [ %i0 + 0x14 ], %o0 400092b4: a7 31 20 10 srl %g4, 0x10, %l3 new_object_block = _Workspace_Allocate( object_block_size ); 400092b8: 40 00 0b 8d call 4000c0ec <_Workspace_Allocate> 400092bc: 90 5a 00 13 smul %o0, %l3, %o0 if ( new_object_block == NULL ) { 400092c0: b6 92 20 00 orcc %o0, 0, %i3 400092c4: 02 80 00 25 be 40009358 <_Objects_Extend_information+0x148> <== NEVER TAKEN 400092c8: 80 8e 60 ff btst 0xff, %i1 api_class_and_node = information->maximum_id & ~OBJECTS_INDEX_MASK; 400092cc: 33 3f ff c0 sethi %hi(0xffff0000), %i1 } /* * Do we need to grow the tables? */ if ( do_extend ) { 400092d0: 12 80 00 2f bne 4000938c <_Objects_Extend_information+0x17c> 400092d4: b2 0d 00 19 and %l4, %i1, %i1 } /* * Assign the new object block to the object block table. */ information->object_blocks[ block ] = new_object_block; 400092d8: c8 06 20 28 ld [ %i0 + 0x28 ], %g4 information->inactive_per_block[ block ] = information->objects_per_block; 400092dc: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 400092e0: c6 16 20 12 lduh [ %i0 + 0x12 ], %g3 information->object_blocks[ block ] = new_object_block; 400092e4: 83 2f 60 02 sll %i5, 2, %g1 400092e8: f6 21 00 01 st %i3, [ %g4 + %g1 ] information->inactive_per_block[ block ] = information->objects_per_block; 400092ec: 83 2f 60 01 sll %i5, 1, %g1 400092f0: c6 30 80 01 sth %g3, [ %g2 + %g1 ] /* * Append to inactive chain. */ the_object = new_object_block; for ( index = index_base ; index < index_end ; ++index ) { 400092f4: 80 a6 80 1c cmp %i2, %i4 information->inactive += information->objects_per_block; 400092f8: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 400092fc: c4 16 20 12 lduh [ %i0 + 0x12 ], %g2 40009300: 82 00 40 02 add %g1, %g2, %g1 for ( index = index_base ; index < index_end ; ++index ) { 40009304: 1a 80 00 0f bcc 40009340 <_Objects_Extend_information+0x130> <== NEVER TAKEN 40009308: c2 36 20 10 sth %g1, [ %i0 + 0x10 ] | ( ( index + OBJECTS_INDEX_MINIMUM ) << OBJECTS_INDEX_START_BIT ); _Chain_Initialize_node( &the_object->Node ); _Chain_Append_unprotected( &information->Inactive, &the_object->Node ); the_object = _Addresses_Add_offset( the_object, information->object_size ); 4000930c: c8 16 20 14 lduh [ %i0 + 0x14 ], %g4 return &the_chain->Tail.Node; 40009310: 86 06 20 1c add %i0, 0x1c, %g3 old_last = tail->previous; 40009314: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 | ( ( index + OBJECTS_INDEX_MINIMUM ) << OBJECTS_INDEX_START_BIT ); 40009318: b4 06 a0 01 inc %i2 the_node->next = tail; 4000931c: c6 26 c0 00 st %g3, [ %i3 ] 40009320: 84 16 80 19 or %i2, %i1, %g2 the_object->id = api_class_and_node 40009324: c4 26 e0 08 st %g2, [ %i3 + 8 ] for ( index = index_base ; index < index_end ; ++index ) { 40009328: 80 a6 80 1c cmp %i2, %i4 tail->previous = the_node; 4000932c: f6 26 20 20 st %i3, [ %i0 + 0x20 ] old_last->next = the_node; 40009330: f6 20 40 00 st %i3, [ %g1 ] the_node->previous = old_last; 40009334: c2 26 e0 04 st %g1, [ %i3 + 4 ] 40009338: 12 bf ff f7 bne 40009314 <_Objects_Extend_information+0x104> 4000933c: b6 06 c0 04 add %i3, %g4, %i3 } return block; } 40009340: b1 2f 60 10 sll %i5, 0x10, %i0 40009344: b1 36 20 10 srl %i0, 0x10, %i0 40009348: 81 c7 e0 08 ret 4000934c: 81 e8 00 00 restore _Workspace_Free( new_object_block ); 40009350: 40 00 0b 6f call 4000c10c <_Workspace_Free> 40009354: 90 10 00 1b mov %i3, %o0 return 0; 40009358: ba 10 20 00 clr %i5 } 4000935c: b1 2f 60 10 sll %i5, 0x10, %i0 40009360: b1 36 20 10 srl %i0, 0x10, %i0 40009364: 81 c7 e0 08 ret 40009368: 81 e8 00 00 restore do_extend = true; 4000936c: b2 10 20 01 mov 1, %i1 index_end = index_base + extend_count; 40009370: 10 bf ff cb b 4000929c <_Objects_Extend_information+0x8c> 40009374: b8 00 80 1c add %g2, %i4, %i4 index_base = extend_count; 40009378: b4 10 00 02 mov %g2, %i2 do_extend = true; 4000937c: b2 10 20 01 mov 1, %i1 block = 1; 40009380: ba 10 20 01 mov 1, %i5 block_count = 1; 40009384: 10 bf ff c6 b 4000929c <_Objects_Extend_information+0x8c> 40009388: a4 10 20 01 mov 1, %l2 block_count++; 4000938c: 82 04 a0 01 add %l2, 1, %g1 object_blocks_size = block_count * sizeof( *object_blocks ); 40009390: 95 28 60 02 sll %g1, 2, %o2 table_size = object_blocks_size 40009394: 91 28 60 01 sll %g1, 1, %o0 object_blocks_size = block_count * sizeof( *object_blocks ); 40009398: d4 27 bf fc st %o2, [ %fp + -4 ] table_size = object_blocks_size 4000939c: 90 02 00 01 add %o0, %g1, %o0 local_table_size = new_maximum * sizeof( *local_table ); 400093a0: af 2c 20 02 sll %l0, 2, %l7 table_size = object_blocks_size 400093a4: 91 2a 20 01 sll %o0, 1, %o0 object_blocks = _Workspace_Allocate( table_size ); 400093a8: 40 00 0b 51 call 4000c0ec <_Workspace_Allocate> 400093ac: 90 02 00 17 add %o0, %l7, %o0 if ( object_blocks == NULL ) { 400093b0: aa 92 20 00 orcc %o0, 0, %l5 400093b4: 02 bf ff e7 be 40009350 <_Objects_Extend_information+0x140> 400093b8: d4 07 bf fc ld [ %fp + -4 ], %o2 if ( old_maximum > extend_count ) { 400093bc: 85 2d 20 10 sll %l4, 0x10, %g2 RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( const void *base, uintptr_t offset ) { return (void *)((uintptr_t)base + offset); 400093c0: ac 05 40 0a add %l5, %o2, %l6 400093c4: 85 30 a0 10 srl %g2, 0x10, %g2 400093c8: 80 a4 c0 02 cmp %l3, %g2 400093cc: 0a 80 00 1d bcs 40009440 <_Objects_Extend_information+0x230> 400093d0: a8 05 c0 16 add %l7, %l6, %l4 object_blocks[ 0 ] = NULL; 400093d4: c0 25 40 00 clr [ %l5 ] inactive_per_block[ 0 ] = 0; 400093d8: c0 35 c0 16 clrh [ %l7 + %l6 ] memcpy( 400093dc: 95 2c 60 02 sll %l1, 2, %o2 400093e0: d2 06 20 04 ld [ %i0 + 4 ], %o1 400093e4: 40 00 4b 3f call 4001c0e0 400093e8: 90 10 00 16 mov %l6, %o0 for ( index = index_base ; index < index_end ; ++index ) { 400093ec: 80 a6 80 1c cmp %i2, %i4 400093f0: 1a 80 00 07 bcc 4000940c <_Objects_Extend_information+0x1fc> <== NEVER TAKEN 400093f4: 94 27 00 1a sub %i4, %i2, %o2 local_table[ index ] = NULL; 400093f8: 91 2e a0 02 sll %i2, 2, %o0 400093fc: 95 2a a0 02 sll %o2, 2, %o2 40009400: 92 10 20 00 clr %o1 40009404: 40 00 4b 76 call 4001c1dc 40009408: 90 05 80 08 add %l6, %o0, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000940c: 91 d0 20 09 ta 9 old_tables = information->object_blocks; 40009410: d0 06 20 28 ld [ %i0 + 0x28 ], %o0 | (new_maximum << OBJECTS_INDEX_START_BIT); 40009414: a0 14 00 19 or %l0, %i1, %l0 information->object_blocks = object_blocks; 40009418: ea 26 20 28 st %l5, [ %i0 + 0x28 ] information->inactive_per_block = inactive_per_block; 4000941c: e8 26 20 24 st %l4, [ %i0 + 0x24 ] information->local_table = local_table; 40009420: ec 26 20 04 st %l6, [ %i0 + 4 ] information->maximum_id = api_class_and_node 40009424: e0 26 00 00 st %l0, [ %i0 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009428: 91 d0 20 0a ta 0xa 4000942c: 01 00 00 00 nop _Workspace_Free( old_tables ); 40009430: 40 00 0b 37 call 4000c10c <_Workspace_Free> 40009434: 01 00 00 00 nop block_count++; 40009438: 10 bf ff a9 b 400092dc <_Objects_Extend_information+0xcc> 4000943c: c8 06 20 28 ld [ %i0 + 0x28 ], %g4 memcpy( 40009440: d2 06 20 28 ld [ %i0 + 0x28 ], %o1 40009444: 40 00 4b 27 call 4001c0e0 40009448: 94 02 bf fc add %o2, -4, %o2 memcpy( 4000944c: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 40009450: 95 2c a0 01 sll %l2, 1, %o2 40009454: 40 00 4b 23 call 4001c0e0 40009458: 90 10 00 14 mov %l4, %o0 4000945c: 10 bf ff e1 b 400093e0 <_Objects_Extend_information+0x1d0> 40009460: 95 2c 60 02 sll %l1, 2, %o2 do_extend = true; 40009464: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED block = 1; 40009468: 10 bf ff 8d b 4000929c <_Objects_Extend_information+0x8c> <== NOT EXECUTED 4000946c: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED =============================================================================== 40009538 <_Objects_Free_objects_block>: void _Objects_Free_objects_block( Objects_Information *information, Objects_Maximum block ) { 40009538: 9d e3 bf a0 save %sp, -96, %sp Objects_Maximum index_base; Objects_Maximum index_end; Chain_Node *node; const Chain_Node *tail; objects_per_block = information->objects_per_block; 4000953c: f4 16 20 12 lduh [ %i0 + 0x12 ], %i2 return _Chain_Immutable_head( the_chain )->next; 40009540: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 _Assert( block >= 1 ); _Assert( block < _Objects_Get_maximum_index( information ) / objects_per_block ); index_base = block * objects_per_block; 40009544: 86 5e 40 1a smul %i1, %i2, %g3 return &the_chain->Tail.Node; 40009548: b6 06 20 1c add %i0, 0x1c, %i3 /* * Get the next node before the node is extracted */ node = _Chain_Next( node ); if ( index >= index_base && index < index_end ) { 4000954c: 89 28 e0 10 sll %g3, 0x10, %g4 while ( node != tail ) { 40009550: 80 a0 80 1b cmp %g2, %i3 index_end = index_base + objects_per_block; 40009554: 86 00 c0 1a add %g3, %i2, %g3 while ( node != tail ) { 40009558: 02 80 00 16 be 400095b0 <_Objects_Free_objects_block+0x78> <== NEVER TAKEN 4000955c: 89 31 20 10 srl %g4, 0x10, %g4 if ( index >= index_base && index < index_end ) { 40009560: 87 28 e0 10 sll %g3, 0x10, %g3 index = _Objects_Get_index( object->id ) - OBJECTS_INDEX_MINIMUM; 40009564: 3b 00 00 3f sethi %hi(0xfc00), %i5 if ( index >= index_base && index < index_end ) { 40009568: 87 30 e0 10 srl %g3, 0x10, %g3 index = _Objects_Get_index( object->id ) - OBJECTS_INDEX_MINIMUM; 4000956c: ba 17 63 ff or %i5, 0x3ff, %i5 40009570: c2 00 a0 08 ld [ %g2 + 8 ], %g1 40009574: b8 10 00 02 mov %g2, %i4 40009578: 82 08 40 1d and %g1, %i5, %g1 4000957c: 82 00 7f ff add %g1, -1, %g1 if ( index >= index_base && index < index_end ) { 40009580: 80 a0 40 04 cmp %g1, %g4 40009584: 0a 80 00 08 bcs 400095a4 <_Objects_Free_objects_block+0x6c> 40009588: c4 00 80 00 ld [ %g2 ], %g2 4000958c: 80 a0 c0 01 cmp %g3, %g1 40009590: 08 80 00 06 bleu 400095a8 <_Objects_Free_objects_block+0x70> 40009594: 80 a0 80 1b cmp %g2, %i3 previous = the_node->previous; 40009598: c2 07 20 04 ld [ %i4 + 4 ], %g1 next->previous = previous; 4000959c: c2 20 a0 04 st %g1, [ %g2 + 4 ] previous->next = next; 400095a0: c4 20 40 00 st %g2, [ %g1 ] while ( node != tail ) { 400095a4: 80 a0 80 1b cmp %g2, %i3 400095a8: 32 bf ff f3 bne,a 40009574 <_Objects_Free_objects_block+0x3c> 400095ac: c2 00 a0 08 ld [ %g2 + 8 ], %g1 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 400095b0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 400095b4: bb 2e 60 02 sll %i1, 2, %i5 400095b8: 40 00 0a d5 call 4000c10c <_Workspace_Free> 400095bc: d0 00 40 1d ld [ %g1 + %i5 ], %o0 information->object_blocks[ block ] = NULL; 400095c0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 400095c4: c0 20 40 1d clr [ %g1 + %i5 ] information->inactive_per_block[ block ] = 0; 400095c8: b3 2e 60 01 sll %i1, 1, %i1 400095cc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 400095d0: c0 30 40 19 clrh [ %g1 + %i1 ] information->inactive -= objects_per_block; 400095d4: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 400095d8: b4 20 40 1a sub %g1, %i2, %i2 400095dc: f4 36 20 10 sth %i2, [ %i0 + 0x10 ] } 400095e0: 81 c7 e0 08 ret 400095e4: 81 e8 00 00 restore =============================================================================== 40009470 <_Objects_Free_unlimited>: old_last = tail->previous; 40009470: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 return &the_chain->Tail.Node; 40009474: 86 02 20 1c add %o0, 0x1c, %g3 the_node->next = tail; 40009478: c6 22 40 00 st %g3, [ %o1 ] tail->previous = the_node; 4000947c: d2 22 20 20 st %o1, [ %o0 + 0x20 ] old_last->next = the_node; 40009480: d2 20 80 00 st %o1, [ %g2 ] the_node->previous = old_last; 40009484: c4 22 60 04 st %g2, [ %o1 + 4 ] */ RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Is_auto_extend( const Objects_Information *information ) { return information->objects_per_block != 0; 40009488: c6 12 20 12 lduh [ %o0 + 0x12 ], %g3 Objects_Control *the_object ) { _Chain_Append_unprotected( &information->Inactive, &the_object->Node ); if ( _Objects_Is_auto_extend( information ) ) { 4000948c: 87 28 e0 10 sll %g3, 0x10, %g3 40009490: 89 30 e0 10 srl %g3, 0x10, %g4 40009494: 80 a1 20 00 cmp %g4, 0 40009498: 02 80 00 1c be 40009508 <_Objects_Free_unlimited+0x98> <== NEVER TAKEN 4000949c: 01 00 00 00 nop RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Get_index( Objects_Id id ) { return (Objects_Maximum)((id >> OBJECTS_INDEX_START_BIT) & 400094a0: c4 02 60 08 ld [ %o1 + 8 ], %g2 Objects_Maximum objects_per_block; Objects_Maximum block; Objects_Maximum inactive; objects_per_block = information->objects_per_block; block = _Objects_Get_index( the_object->id ) - OBJECTS_INDEX_MINIMUM; 400094a4: 84 00 bf ff add %g2, -1, %g2 if ( block > objects_per_block ) { 400094a8: 85 28 a0 10 sll %g2, 0x10, %g2 400094ac: 85 30 a0 10 srl %g2, 0x10, %g2 400094b0: 80 a1 00 02 cmp %g4, %g2 400094b4: 1a 80 00 15 bcc 40009508 <_Objects_Free_unlimited+0x98> 400094b8: 87 30 e0 11 srl %g3, 0x11, %g3 block /= objects_per_block; ++information->inactive_per_block[ block ]; 400094bc: d8 02 20 24 ld [ %o0 + 0x24 ], %o4 400094c0: 81 80 20 00 wr %g0, %y 400094c4: 01 00 00 00 nop 400094c8: 01 00 00 00 nop 400094cc: 01 00 00 00 nop 400094d0: 84 70 80 04 udiv %g2, %g4, %g2 400094d4: 85 28 a0 01 sll %g2, 1, %g2 400094d8: da 13 00 02 lduh [ %o4 + %g2 ], %o5 400094dc: 9a 03 60 01 inc %o5 400094e0: da 33 00 02 sth %o5, [ %o4 + %g2 ] inactive = information->inactive; 400094e4: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 ++inactive; 400094e8: 84 00 a0 01 inc %g2 information->inactive = inactive; 400094ec: c4 32 20 10 sth %g2, [ %o0 + 0x10 ] /* * Check if the threshold level has been met of * 1.5 x objects_per_block are free. */ if ( inactive > ( objects_per_block + ( objects_per_block >> 1 ) ) ) { 400094f0: 86 00 c0 04 add %g3, %g4, %g3 400094f4: 85 28 a0 10 sll %g2, 0x10, %g2 400094f8: 85 30 a0 10 srl %g2, 0x10, %g2 400094fc: 80 a0 80 03 cmp %g2, %g3 40009500: 14 80 00 04 bg 40009510 <_Objects_Free_unlimited+0xa0> 40009504: 01 00 00 00 nop _Objects_Shrink_information( information ); } } } } 40009508: 81 c3 e0 08 retl 4000950c: 01 00 00 00 nop _Objects_Shrink_information( information ); 40009510: 82 13 c0 00 mov %o7, %g1 40009514: 40 00 00 35 call 400095e8 <_Objects_Shrink_information> 40009518: 9e 10 40 00 mov %g1, %o7 =============================================================================== 4000b934 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 4000b934: 9d e3 bf a0 save %sp, -96, %sp Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 4000b938: 80 a6 60 00 cmp %i1, 0 4000b93c: 02 80 00 19 be 4000b9a0 <_Objects_Get_information+0x6c> 4000b940: 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 ); 4000b944: 40 00 01 8f call 4000bf80 <_Objects_API_maximum_class> 4000b948: 90 10 00 18 mov %i0, %o0 if ( the_class_api_maximum == 0 ) 4000b94c: 80 a2 20 00 cmp %o0, 0 4000b950: 02 80 00 14 be 4000b9a0 <_Objects_Get_information+0x6c> 4000b954: 80 a2 00 19 cmp %o0, %i1 return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 4000b958: 0a 80 00 12 bcs 4000b9a0 <_Objects_Get_information+0x6c> 4000b95c: 03 10 00 5f sethi %hi(0x40017c00), %g1 return NULL; if ( !_Objects_Information_table[ the_api ] ) 4000b960: b1 2e 20 02 sll %i0, 2, %i0 4000b964: 82 10 62 34 or %g1, 0x234, %g1 4000b968: c2 00 40 18 ld [ %g1 + %i0 ], %g1 4000b96c: 80 a0 60 00 cmp %g1, 0 4000b970: 02 80 00 0c be 4000b9a0 <_Objects_Get_information+0x6c> <== NEVER TAKEN 4000b974: b3 2e 60 02 sll %i1, 2, %i1 return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 4000b978: f0 00 40 19 ld [ %g1 + %i1 ], %i0 if ( !info ) 4000b97c: 80 a6 20 00 cmp %i0, 0 4000b980: 02 80 00 08 be 4000b9a0 <_Objects_Get_information+0x6c> 4000b984: 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 ( _Objects_Get_maximum_index( info ) == 0 ) 4000b988: c2 16 20 02 lduh [ %i0 + 2 ], %g1 4000b98c: 80 a0 60 00 cmp %g1, 0 4000b990: 02 80 00 04 be 4000b9a0 <_Objects_Get_information+0x6c> 4000b994: 01 00 00 00 nop return NULL; #endif return info; } 4000b998: 81 c7 e0 08 ret 4000b99c: 81 e8 00 00 restore 4000b9a0: 81 c7 e0 08 ret 4000b9a4: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 40009574 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 40009574: 9d e3 bf 90 save %sp, -112, %sp Objects_Id tmpId; if ( length == 0 ) return NULL; if ( name == NULL ) 40009578: 80 a6 60 00 cmp %i1, 0 4000957c: 02 80 00 24 be 4000960c <_Objects_Get_name_as_string+0x98> 40009580: 80 a6 a0 00 cmp %i2, 0 40009584: 02 80 00 22 be 4000960c <_Objects_Get_name_as_string+0x98> 40009588: 80 a6 20 00 cmp %i0, 0 return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id; 4000958c: 22 80 00 1a be,a 400095f4 <_Objects_Get_name_as_string+0x80> 40009590: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1 information = _Objects_Get_information_id( tmpId ); 40009594: 40 00 18 b1 call 4000f858 <_Objects_Get_information_id> 40009598: 90 10 00 18 mov %i0, %o0 if ( !information ) 4000959c: ba 92 20 00 orcc %o0, 0, %i5 400095a0: 02 80 00 1b be 4000960c <_Objects_Get_name_as_string+0x98> 400095a4: 94 10 00 1d mov %i5, %o2 return NULL; the_object = _Objects_Get( tmpId, &lock_context, information ); 400095a8: 92 07 bf fc add %fp, -4, %o1 400095ac: 7f ff ff ac call 4000945c <_Objects_Get> 400095b0: 90 10 00 18 mov %i0, %o0 if ( the_object == NULL ) { 400095b4: 80 a2 20 00 cmp %o0, 0 400095b8: 02 80 00 15 be 4000960c <_Objects_Get_name_as_string+0x98> 400095bc: 96 10 00 19 mov %i1, %o3 return information->name_length > 0; 400095c0: c4 17 60 16 lduh [ %i5 + 0x16 ], %g2 return NULL; } _Objects_Name_to_string( 400095c4: c2 02 20 0c ld [ %o0 + 0xc ], %g1 400095c8: 80 a0 00 02 cmp %g0, %g2 400095cc: c2 27 bf f4 st %g1, [ %fp + -12 ] 400095d0: 94 10 00 1a mov %i2, %o2 400095d4: 92 40 20 00 addx %g0, 0, %o1 400095d8: 7f ff ff ba call 400094c0 <_Objects_Name_to_string> 400095dc: 90 07 bf f4 add %fp, -12, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400095e0: c2 07 bf fc ld [ %fp + -4 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400095e4: 91 d0 20 0a ta 0xa 400095e8: 01 00 00 00 nop length ); _ISR_lock_ISR_enable( &lock_context ); return name; } 400095ec: 81 c7 e0 08 ret 400095f0: 91 e8 00 1a restore %g0, %i2, %o0 tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id; 400095f4: f0 00 60 08 ld [ %g1 + 8 ], %i0 information = _Objects_Get_information_id( tmpId ); 400095f8: 40 00 18 98 call 4000f858 <_Objects_Get_information_id> 400095fc: 90 10 00 18 mov %i0, %o0 if ( !information ) 40009600: ba 92 20 00 orcc %o0, 0, %i5 40009604: 12 bf ff e9 bne 400095a8 <_Objects_Get_name_as_string+0x34> <== ALWAYS TAKEN 40009608: 94 10 00 1d mov %i5, %o2 return NULL; 4000960c: 81 c7 e0 08 ret 40009610: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 40009614 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 40009614: 9d e3 bf 98 save %sp, -104, %sp /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id; 40009618: 80 a6 20 00 cmp %i0, 0 4000961c: 12 80 00 04 bne 4000962c <_Objects_Id_to_name+0x18> 40009620: 01 00 00 00 nop 40009624: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1 40009628: f0 00 60 08 ld [ %g1 + 8 ], %i0 information = _Objects_Get_information_id( tmpId ); 4000962c: 40 00 18 8b call 4000f858 <_Objects_Get_information_id> 40009630: 90 10 00 18 mov %i0, %o0 if ( !information ) 40009634: 94 92 20 00 orcc %o0, 0, %o2 40009638: 02 80 00 12 be 40009680 <_Objects_Id_to_name+0x6c> 4000963c: 01 00 00 00 nop return OBJECTS_INVALID_ID; if ( _Objects_Has_string_name( information ) ) 40009640: c2 12 a0 16 lduh [ %o2 + 0x16 ], %g1 40009644: 80 a0 60 00 cmp %g1, 0 40009648: 12 80 00 0e bne 40009680 <_Objects_Id_to_name+0x6c> <== NEVER TAKEN 4000964c: 92 07 bf fc add %fp, -4, %o1 return OBJECTS_INVALID_ID; the_object = _Objects_Get( 40009650: 7f ff ff 83 call 4000945c <_Objects_Get> 40009654: 90 10 00 18 mov %i0, %o0 tmpId, &lock_context, information ); if ( !the_object ) 40009658: 80 a2 20 00 cmp %o0, 0 4000965c: 02 80 00 09 be 40009680 <_Objects_Id_to_name+0x6c> 40009660: 01 00 00 00 nop return OBJECTS_INVALID_ID; *name = the_object->name; 40009664: c2 02 20 0c ld [ %o0 + 0xc ], %g1 40009668: c2 26 40 00 st %g1, [ %i1 ] register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000966c: c2 07 bf fc ld [ %fp + -4 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009670: 91 d0 20 0a ta 0xa 40009674: 01 00 00 00 nop _ISR_lock_ISR_enable( &lock_context ); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 40009678: 81 c7 e0 08 ret 4000967c: 91 e8 20 00 restore %g0, 0, %o0 return OBJECTS_INVALID_ID; 40009680: 81 c7 e0 08 ret 40009684: 91 e8 20 03 restore %g0, 3, %o0 =============================================================================== 400094c0 <_Objects_Name_to_string>: Objects_Name name, bool is_string, char *buffer, size_t buffer_size ) { 400094c0: c2 02 00 00 ld [ %o0 ], %g1 char lname[ 5 ]; const char *s; char *d; size_t i; if ( is_string ) { 400094c4: 80 a2 60 00 cmp %o1, 0 400094c8: 02 80 00 21 be 4000954c <_Objects_Name_to_string+0x8c> <== ALWAYS TAKEN 400094cc: 9c 03 bf b0 add %sp, -80, %sp } d = buffer; i = 1; if ( s != NULL ) { 400094d0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400094d4: 32 80 00 08 bne,a 400094f4 <_Objects_Name_to_string+0x34> <== NOT EXECUTED 400094d8: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED while ( *s != '\0' ) { if ( i < buffer_size ) { *d = _Objects_Name_char_is_printable(*s) ? *s : '*'; 400094dc: 90 10 20 00 clr %o0 ++s; ++i; } } if ( buffer_size > 0 ) { 400094e0: 80 a2 e0 00 cmp %o3, 0 400094e4: 32 80 00 02 bne,a 400094ec <_Objects_Name_to_string+0x2c> 400094e8: c0 2a 80 00 clrb [ %o2 ] *d = '\0'; } return i - 1; } 400094ec: 81 c3 e0 08 retl 400094f0: 9c 03 a0 50 add %sp, 0x50, %sp s = name.name_p; 400094f4: 86 10 00 01 mov %g1, %g3 <== NOT EXECUTED while ( *s != '\0' ) { 400094f8: 83 28 a0 18 sll %g2, 0x18, %g1 400094fc: 80 a0 60 00 cmp %g1, 0 40009500: 02 bf ff f7 be 400094dc <_Objects_Name_to_string+0x1c> 40009504: 90 10 20 01 mov 1, %o0 40009508: 86 00 ff ff add %g3, -1, %g3 if ( i < buffer_size ) { 4000950c: 80 a2 c0 08 cmp %o3, %o0 40009510: 08 80 00 09 bleu 40009534 <_Objects_Name_to_string+0x74> 40009514: 82 02 20 01 add %o0, 1, %g1 return uc >= ' ' && uc <= '~'; 40009518: 88 00 bf e0 add %g2, -32, %g4 *d = _Objects_Name_char_is_printable(*s) ? *s : '*'; 4000951c: 88 09 20 ff and %g4, 0xff, %g4 40009520: 80 a1 20 5e cmp %g4, 0x5e 40009524: 38 80 00 02 bgu,a 4000952c <_Objects_Name_to_string+0x6c> 40009528: 84 10 20 2a mov 0x2a, %g2 4000952c: c4 2a 80 00 stb %g2, [ %o2 ] ++d; 40009530: 94 02 a0 01 inc %o2 while ( *s != '\0' ) { 40009534: c8 48 c0 01 ldsb [ %g3 + %g1 ], %g4 40009538: 80 a1 20 00 cmp %g4, 0 4000953c: 02 bf ff e9 be 400094e0 <_Objects_Name_to_string+0x20> 40009540: c4 08 c0 01 ldub [ %g3 + %g1 ], %g2 ++i; 40009544: 10 bf ff f2 b 4000950c <_Objects_Name_to_string+0x4c> 40009548: 90 10 00 01 mov %g1, %o0 lname[ 1 ] = (name.name_u32 >> 16) & 0xff; 4000954c: 87 30 60 10 srl %g1, 0x10, %g3 lname[ 0 ] = (name.name_u32 >> 24) & 0xff; 40009550: 85 30 60 18 srl %g1, 0x18, %g2 lname[ 1 ] = (name.name_u32 >> 16) & 0xff; 40009554: c6 2b a0 49 stb %g3, [ %sp + 0x49 ] lname[ 2 ] = (name.name_u32 >> 8) & 0xff; 40009558: 89 30 60 08 srl %g1, 8, %g4 lname[ 0 ] = (name.name_u32 >> 24) & 0xff; 4000955c: c4 2b a0 48 stb %g2, [ %sp + 0x48 ] s = lname; 40009560: 86 03 a0 48 add %sp, 0x48, %g3 lname[ 2 ] = (name.name_u32 >> 8) & 0xff; 40009564: c8 2b a0 4a stb %g4, [ %sp + 0x4a ] lname[ 3 ] = (name.name_u32 >> 0) & 0xff; 40009568: c2 2b a0 4b stb %g1, [ %sp + 0x4b ] lname[ 4 ] = '\0'; 4000956c: 10 bf ff e3 b 400094f8 <_Objects_Name_to_string+0x38> 40009570: c0 2b a0 4c clrb [ %sp + 0x4c ] =============================================================================== 40004f28 <_Objects_Set_name>: Status_Control _Objects_Set_name( const Objects_Information *information, Objects_Control *the_object, const char *name ) { 40004f28: 9d e3 bf 98 save %sp, -104, %sp if ( _Objects_Has_string_name( information ) ) { 40004f2c: d2 16 20 16 lduh [ %i0 + 0x16 ], %o1 40004f30: 80 a2 60 00 cmp %o1, 0 40004f34: 02 80 00 0f be 40004f70 <_Objects_Set_name+0x48> 40004f38: 03 08 08 08 sethi %hi(0x20202000), %g1 size_t length; char *dup; length = strnlen( name, information->name_length ); 40004f3c: 40 00 2b 57 call 4000fc98 40004f40: 90 10 00 1a mov %i2, %o0 40004f44: 92 10 00 08 mov %o0, %o1 dup = _Workspace_String_duplicate( name, length ); 40004f48: 40 00 09 7a call 40007530 <_Workspace_String_duplicate> 40004f4c: 90 10 00 1a mov %i2, %o0 if ( dup == NULL ) { 40004f50: ba 92 20 00 orcc %o0, 0, %i5 40004f54: 22 80 00 21 be,a 40004fd8 <_Objects_Set_name+0xb0> <== ALWAYS TAKEN 40004f58: 31 00 00 05 sethi %hi(0x1400), %i0 return STATUS_NO_MEMORY; } _Workspace_Free( RTEMS_DECONST( char *, the_object->name.name_p ) ); 40004f5c: 40 00 09 6f call 40007518 <_Workspace_Free> <== NOT EXECUTED 40004f60: d0 06 60 0c ld [ %i1 + 0xc ], %o0 <== NOT EXECUTED the_object->name.name_p = dup; 40004f64: fa 26 60 0c st %i5, [ %i1 + 0xc ] <== NOT EXECUTED 40004f68: 81 c7 e0 08 ret <== NOT EXECUTED 40004f6c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED } else { char c[ 4 ]; size_t i; memset( c, ' ', sizeof( c ) ); 40004f70: 82 10 60 20 or %g1, 0x20, %g1 for ( i = 0; i < 4; ++i ) { if ( name[ i ] == '\0') { break; } c[ i ] = name[ i ]; 40004f74: 88 07 bf f8 add %fp, -8, %g4 memset( c, ' ', sizeof( c ) ); 40004f78: c2 27 bf f8 st %g1, [ %fp + -8 ] for ( i = 0; i < 4; ++i ) { 40004f7c: 82 10 20 00 clr %g1 if ( name[ i ] == '\0') { 40004f80: c4 4e 80 01 ldsb [ %i2 + %g1 ], %g2 40004f84: 80 a0 a0 00 cmp %g2, 0 40004f88: 02 80 00 07 be 40004fa4 <_Objects_Set_name+0x7c> 40004f8c: c6 0e 80 01 ldub [ %i2 + %g1 ], %g3 c[ i ] = name[ i ]; 40004f90: c6 28 40 04 stb %g3, [ %g1 + %g4 ] for ( i = 0; i < 4; ++i ) { 40004f94: 82 00 60 01 inc %g1 40004f98: 80 a0 60 04 cmp %g1, 4 40004f9c: 32 bf ff fa bne,a 40004f84 <_Objects_Set_name+0x5c> 40004fa0: c4 4e 80 01 ldsb [ %i2 + %g1 ], %g2 } the_object->name.name_u32 = _Objects_Build_name( c[ 0 ], c[ 1 ], c[ 2 ], c[ 3 ] ); 40004fa4: c2 4f bf f8 ldsb [ %fp + -8 ], %g1 40004fa8: c6 4f bf f9 ldsb [ %fp + -7 ], %g3 40004fac: c8 4f bf fb ldsb [ %fp + -5 ], %g4 40004fb0: c4 4f bf fa ldsb [ %fp + -6 ], %g2 40004fb4: 87 28 e0 10 sll %g3, 0x10, %g3 40004fb8: 85 28 a0 08 sll %g2, 8, %g2 40004fbc: 83 28 60 18 sll %g1, 0x18, %g1 40004fc0: 82 10 40 03 or %g1, %g3, %g1 40004fc4: 82 10 40 04 or %g1, %g4, %g1 40004fc8: 82 10 40 02 or %g1, %g2, %g1 the_object->name.name_u32 = 40004fcc: c2 26 60 0c st %g1, [ %i1 + 0xc ] } return STATUS_SUCCESSFUL; 40004fd0: 81 c7 e0 08 ret 40004fd4: 91 e8 20 00 restore %g0, 0, %o0 return STATUS_NO_MEMORY; 40004fd8: b0 16 22 1a or %i0, 0x21a, %i0 } 40004fdc: 81 c7 e0 08 ret 40004fe0: 81 e8 00 00 restore =============================================================================== 400095e8 <_Objects_Shrink_information>: /* * Search the list to find block or chunk with all objects inactive. */ objects_per_block = information->objects_per_block; block_count = _Objects_Get_maximum_index( information ) / objects_per_block; 400095e8: c2 12 20 02 lduh [ %o0 + 2 ], %g1 400095ec: c8 12 20 12 lduh [ %o0 + 0x12 ], %g4 400095f0: 81 80 20 00 wr %g0, %y 400095f4: 01 00 00 00 nop 400095f8: 01 00 00 00 nop 400095fc: 01 00 00 00 nop 40009600: 82 70 40 04 udiv %g1, %g4, %g1 for ( block = 1; block < block_count; block++ ) { 40009604: 80 a0 60 01 cmp %g1, 1 40009608: 08 80 00 17 bleu 40009664 <_Objects_Shrink_information+0x7c> <== NEVER TAKEN 4000960c: 86 10 00 01 mov %g1, %g3 40009610: 87 28 e0 10 sll %g3, 0x10, %g3 if ( information->inactive_per_block[ block ] == objects_per_block ) { 40009614: da 02 20 24 ld [ %o0 + 0x24 ], %o5 40009618: 82 10 20 01 mov 1, %g1 for ( block = 1; block < block_count; block++ ) { 4000961c: 10 80 00 08 b 4000963c <_Objects_Shrink_information+0x54> 40009620: 87 30 e0 10 srl %g3, 0x10, %g3 40009624: 82 00 60 01 inc %g1 40009628: 85 28 60 10 sll %g1, 0x10, %g2 4000962c: 85 30 a0 10 srl %g2, 0x10, %g2 40009630: 80 a0 c0 02 cmp %g3, %g2 40009634: 08 80 00 0c bleu 40009664 <_Objects_Shrink_information+0x7c> <== NEVER TAKEN 40009638: 01 00 00 00 nop if ( information->inactive_per_block[ block ] == objects_per_block ) { 4000963c: 85 28 60 01 sll %g1, 1, %g2 40009640: c4 13 40 02 lduh [ %o5 + %g2 ], %g2 40009644: 80 a0 80 04 cmp %g2, %g4 40009648: 12 bf ff f7 bne 40009624 <_Objects_Shrink_information+0x3c> 4000964c: 92 10 00 01 mov %g1, %o1 _Objects_Free_objects_block( information, block ); 40009650: 93 2a 60 10 sll %o1, 0x10, %o1 40009654: 93 32 60 10 srl %o1, 0x10, %o1 40009658: 82 13 c0 00 mov %o7, %g1 4000965c: 7f ff ff b7 call 40009538 <_Objects_Free_objects_block> 40009660: 9e 10 40 00 mov %g1, %o7 return; } } } 40009664: 81 c3 e0 08 retl <== NOT EXECUTED 40009668: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40004f7c <_Once>: .Mutex = RTEMS_MUTEX_INITIALIZER( "_Once" ), .State = RTEMS_CONDITION_VARIABLE_INITIALIZER( "_Once" ) }; int _Once( unsigned char *once_state, void ( *init_routine )( void ) ) { 40004f7c: 9d e3 bf a0 save %sp, -96, %sp _Atomic_Fence( ATOMIC_ORDER_ACQUIRE ); if ( RTEMS_PREDICT_FALSE( *once_state != ONCE_STATE_COMPLETE ) ) { 40004f80: c2 0e 00 00 ldub [ %i0 ], %g1 40004f84: 80 a0 60 02 cmp %g1, 2 40004f88: 12 80 00 04 bne 40004f98 <_Once+0x1c> 40004f8c: 01 00 00 00 nop _Once_Unlock( thread_life_state ); } return 0; } 40004f90: 81 c7 e0 08 ret 40004f94: 91 e8 20 00 restore %g0, 0, %o0 Thread_Life_state _Once_Lock( void ) { Thread_Life_state thread_life_state; thread_life_state = _Thread_Set_life_protection( THREAD_LIFE_PROTECTED ); 40004f98: 40 00 03 ef call 40005f54 <_Thread_Set_life_protection> 40004f9c: 90 10 20 01 mov 1, %o0 mutex->_Queue._name = name; } static __inline void rtems_mutex_lock( rtems_mutex *mutex ) { _Mutex_Acquire( mutex ); 40004fa0: 39 10 00 6b sethi %hi(0x4001ac00), %i4 40004fa4: b6 10 00 08 mov %o0, %i3 40004fa8: 40 00 0d 80 call 400085a8 <_Mutex_Acquire> 40004fac: 90 17 21 28 or %i4, 0x128, %o0 if ( *once_state == ONCE_STATE_INIT ) { 40004fb0: c2 0e 00 00 ldub [ %i0 ], %g1 40004fb4: 80 a0 60 00 cmp %g1, 0 40004fb8: 02 80 00 12 be 40005000 <_Once+0x84> <== ALWAYS TAKEN 40004fbc: 80 a0 60 02 cmp %g1, 2 while ( *once_state != ONCE_STATE_COMPLETE ) { 40004fc0: 02 80 00 09 be 40004fe4 <_Once+0x68> <== NOT EXECUTED 40004fc4: ba 17 21 28 or %i4, 0x128, %i5 <== NOT EXECUTED static __inline void rtems_condition_variable_wait( rtems_condition_variable *condition_variable, rtems_mutex *mutex ) { _Condition_Wait( condition_variable, mutex ); 40004fc8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 40004fcc: 40 00 0b 73 call 40007d98 <_Condition_Wait> <== NOT EXECUTED 40004fd0: 90 07 60 14 add %i5, 0x14, %o0 <== NOT EXECUTED 40004fd4: c2 0e 00 00 ldub [ %i0 ], %g1 <== NOT EXECUTED 40004fd8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40004fdc: 12 bf ff fc bne 40004fcc <_Once+0x50> <== NOT EXECUTED 40004fe0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED _Mutex_Release( mutex ); 40004fe4: 40 00 0d 8c call 40008614 <_Mutex_Release> 40004fe8: 90 17 21 28 or %i4, 0x128, %o0 } void _Once_Unlock( Thread_Life_state thread_life_state ) { rtems_mutex_unlock( &_Once_Information.Mutex ); _Thread_Set_life_protection( thread_life_state ); 40004fec: 90 10 00 1b mov %i3, %o0 40004ff0: 40 00 03 d9 call 40005f54 <_Thread_Set_life_protection> 40004ff4: b0 10 20 00 clr %i0 } 40004ff8: 81 c7 e0 08 ret 40004ffc: 81 e8 00 00 restore *once_state = ONCE_STATE_RUNNING; 40005000: 82 10 20 01 mov 1, %g1 40005004: c2 2e 00 00 stb %g1, [ %i0 ] 40005008: 40 00 0d 83 call 40008614 <_Mutex_Release> 4000500c: 90 17 21 28 or %i4, 0x128, %o0 _Thread_Set_life_protection( thread_life_state ); 40005010: 40 00 03 d1 call 40005f54 <_Thread_Set_life_protection> 40005014: 90 10 20 01 mov 1, %o0 ( *init_routine )(); 40005018: 9f c6 40 00 call %i1 4000501c: 01 00 00 00 nop thread_life_state = _Thread_Set_life_protection( THREAD_LIFE_PROTECTED ); 40005020: 40 00 03 cd call 40005f54 <_Thread_Set_life_protection> 40005024: 90 10 20 01 mov 1, %o0 ! 1 <_TLS_Alignment> _Mutex_Acquire( mutex ); 40005028: 40 00 0d 60 call 400085a8 <_Mutex_Acquire> 4000502c: 90 17 21 28 or %i4, 0x128, %o0 *once_state = ONCE_STATE_COMPLETE; 40005030: 82 10 20 02 mov 2, %g1 40005034: c2 2e 00 00 stb %g1, [ %i0 ] static __inline void rtems_condition_variable_broadcast( rtems_condition_variable *condition_variable ) { _Condition_Broadcast( condition_variable ); 40005038: 11 10 00 6b sethi %hi(0x4001ac00), %o0 4000503c: 40 00 0b 6a call 40007de4 <_Condition_Broadcast> 40005040: 90 12 21 3c or %o0, 0x13c, %o0 ! 4001ad3c <_Once_Information+0x14> } 40005044: 30 bf ff e8 b,a 40004fe4 <_Once+0x68> =============================================================================== 4000cf38 <_Processor_mask_Copy>: long *dst, size_t dst_size, const long *src, size_t src_size ) { 4000cf38: 82 10 00 08 mov %o0, %g1 long inclusive = 0; long exclusive = 0; if ( ( dst_size | src_size ) % sizeof( long ) != 0 ) { 4000cf3c: 90 12 40 0b or %o1, %o3, %o0 4000cf40: 90 8a 20 03 andcc %o0, 3, %o0 4000cf44: 12 80 00 2d bne 4000cff8 <_Processor_mask_Copy+0xc0> 4000cf48: 80 a2 e0 00 cmp %o3, 0 return PROCESSOR_MASK_COPY_INVALID_SIZE; } while ( dst_size > 0 && src_size > 0 ) { 4000cf4c: 02 80 00 10 be 4000cf8c <_Processor_mask_Copy+0x54> 4000cf50: 86 10 20 00 clr %g3 4000cf54: 80 a2 60 00 cmp %o1, 0 4000cf58: 02 80 00 17 be 4000cfb4 <_Processor_mask_Copy+0x7c> 4000cf5c: 80 a2 e0 00 cmp %o3, 0 long bits = *src; 4000cf60: c4 02 80 00 ld [ %o2 ], %g2 inclusive |= bits; *dst = bits; 4000cf64: c4 20 40 00 st %g2, [ %g1 ] ++dst; ++src; dst_size -= sizeof( long ); src_size -= sizeof( long ); 4000cf68: 96 02 ff fc add %o3, -4, %o3 while ( dst_size > 0 && src_size > 0 ) { 4000cf6c: 92 82 7f fc addcc %o1, -4, %o1 inclusive |= bits; 4000cf70: 86 10 c0 02 or %g3, %g2, %g3 ++dst; 4000cf74: 82 00 60 04 add %g1, 4, %g1 while ( dst_size > 0 && src_size > 0 ) { 4000cf78: 02 80 00 05 be 4000cf8c <_Processor_mask_Copy+0x54> 4000cf7c: 94 02 a0 04 add %o2, 4, %o2 4000cf80: 80 a2 e0 00 cmp %o3, 0 4000cf84: 32 bf ff f8 bne,a 4000cf64 <_Processor_mask_Copy+0x2c> <== NEVER TAKEN 4000cf88: c4 02 80 00 ld [ %o2 ], %g2 <== NOT EXECUTED } while ( dst_size > 0 ) { 4000cf8c: 80 a2 60 00 cmp %o1, 0 4000cf90: 02 80 00 09 be 4000cfb4 <_Processor_mask_Copy+0x7c> 4000cf94: 80 a2 e0 00 cmp %o3, 0 4000cf98: 92 00 40 09 add %g1, %o1, %o1 *dst = 0; 4000cf9c: c0 20 40 00 clr [ %g1 ] ++dst; 4000cfa0: 82 00 60 04 add %g1, 4, %g1 while ( dst_size > 0 ) { 4000cfa4: 80 a0 40 09 cmp %g1, %o1 4000cfa8: 32 bf ff fe bne,a 4000cfa0 <_Processor_mask_Copy+0x68> <== NEVER TAKEN 4000cfac: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED dst_size -= sizeof( long ); } while ( src_size > 0 ) { 4000cfb0: 80 a2 e0 00 cmp %o3, 0 4000cfb4: 02 80 00 0e be 4000cfec <_Processor_mask_Copy+0xb4> 4000cfb8: 82 10 20 00 clr %g1 4000cfbc: 96 02 80 0b add %o2, %o3, %o3 exclusive |= *src; 4000cfc0: c4 02 80 00 ld [ %o2 ], %g2 ++src; 4000cfc4: 94 02 a0 04 add %o2, 4, %o2 while ( src_size > 0 ) { 4000cfc8: 80 a2 80 0b cmp %o2, %o3 4000cfcc: 12 bf ff fd bne 4000cfc0 <_Processor_mask_Copy+0x88> <== NEVER TAKEN 4000cfd0: 82 10 40 02 or %g1, %g2, %g1 src_size -= sizeof( long ); } if ( exclusive != 0 ) { 4000cfd4: 80 a0 60 00 cmp %g1, 0 4000cfd8: 02 80 00 06 be 4000cff0 <_Processor_mask_Copy+0xb8> 4000cfdc: 80 a0 00 03 cmp %g0, %g3 if ( inclusive != 0 ) { return PROCESSOR_MASK_COPY_PARTIAL_LOSS; } else { return PROCESSOR_MASK_COPY_COMPLETE_LOSS; 4000cfe0: 90 60 3f ff subx %g0, -1, %o0 4000cfe4: 81 c3 e0 08 retl 4000cfe8: 90 02 20 01 inc %o0 } } return PROCESSOR_MASK_COPY_LOSSLESS; 4000cfec: 90 10 20 00 clr %o0 } 4000cff0: 81 c3 e0 08 retl 4000cff4: 01 00 00 00 nop return PROCESSOR_MASK_COPY_INVALID_SIZE; 4000cff8: 81 c3 e0 08 retl 4000cffc: 90 10 20 03 mov 3, %o0 ! 3 <_TLS_Alignment+0x2> =============================================================================== 40008824 <_RBTree_Extract>: #include RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 40008824: c6 02 40 00 ld [ %o1 ], %g3 40008828: 80 a0 e0 00 cmp %g3, 0 4000882c: 02 80 00 b6 be 40008b04 <_RBTree_Extract+0x2e0> 40008830: c2 02 60 04 ld [ %o1 + 4 ], %g1 40008834: 80 a0 60 00 cmp %g1, 0 40008838: 22 80 00 63 be,a 400089c4 <_RBTree_Extract+0x1a0> 4000883c: c4 02 60 08 ld [ %o1 + 8 ], %g2 40008840: 86 10 00 01 mov %g1, %g3 40008844: c2 00 40 00 ld [ %g1 ], %g1 40008848: 80 a0 60 00 cmp %g1, 0 4000884c: 32 bf ff fe bne,a 40008844 <_RBTree_Extract+0x20> 40008850: 86 10 00 01 mov %g1, %g3 40008854: c2 00 e0 04 ld [ %g3 + 4 ], %g1 40008858: c4 00 e0 08 ld [ %g3 + 8 ], %g2 4000885c: c8 00 e0 0c ld [ %g3 + 0xc ], %g4 40008860: 80 a0 60 00 cmp %g1, 0 40008864: 02 80 00 04 be 40008874 <_RBTree_Extract+0x50> 40008868: 9a 10 00 02 mov %g2, %o5 4000886c: c4 20 60 08 st %g2, [ %g1 + 8 ] 40008870: da 00 e0 08 ld [ %g3 + 8 ], %o5 40008874: 80 a0 a0 00 cmp %g2, 0 40008878: 02 80 00 f0 be 40008c38 <_RBTree_Extract+0x414> <== NEVER TAKEN 4000887c: 80 a2 40 0d cmp %o1, %o5 40008880: d8 00 80 00 ld [ %g2 ], %o4 40008884: 80 a0 c0 0c cmp %g3, %o4 40008888: 22 80 00 03 be,a 40008894 <_RBTree_Extract+0x70> 4000888c: c2 20 80 00 st %g1, [ %g2 ] 40008890: c2 20 a0 04 st %g1, [ %g2 + 4 ] 40008894: 80 a2 40 0d cmp %o1, %o5 40008898: 22 80 00 eb be,a 40008c44 <_RBTree_Extract+0x420> 4000889c: da 02 40 00 ld [ %o1 ], %o5 400088a0: da 02 40 00 ld [ %o1 ], %o5 400088a4: da 20 c0 00 st %o5, [ %g3 ] 400088a8: da 02 60 04 ld [ %o1 + 4 ], %o5 400088ac: da 20 e0 04 st %o5, [ %g3 + 4 ] 400088b0: da 02 60 08 ld [ %o1 + 8 ], %o5 400088b4: da 20 e0 08 st %o5, [ %g3 + 8 ] 400088b8: da 02 60 0c ld [ %o1 + 0xc ], %o5 400088bc: da 20 e0 0c st %o5, [ %g3 + 0xc ] 400088c0: da 02 60 08 ld [ %o1 + 8 ], %o5 400088c4: 80 a3 60 00 cmp %o5, 0 400088c8: 22 80 00 07 be,a 400088e4 <_RBTree_Extract+0xc0> 400088cc: c6 22 00 00 st %g3, [ %o0 ] 400088d0: d8 03 40 00 ld [ %o5 ], %o4 400088d4: 80 a2 40 0c cmp %o1, %o4 400088d8: 22 80 00 03 be,a 400088e4 <_RBTree_Extract+0xc0> 400088dc: c6 23 40 00 st %g3, [ %o5 ] 400088e0: c6 23 60 04 st %g3, [ %o5 + 4 ] 400088e4: da 02 40 00 ld [ %o1 ], %o5 400088e8: c6 23 60 08 st %g3, [ %o5 + 8 ] 400088ec: da 02 60 04 ld [ %o1 + 4 ], %o5 400088f0: 80 a3 60 00 cmp %o5, 0 400088f4: 32 80 00 02 bne,a 400088fc <_RBTree_Extract+0xd8> 400088f8: c6 23 60 08 st %g3, [ %o5 + 8 ] 400088fc: 80 a0 a0 00 cmp %g2, 0 40008900: 02 80 00 3b be 400089ec <_RBTree_Extract+0x1c8> <== NEVER TAKEN 40008904: 86 10 00 02 mov %g2, %g3 40008908: c6 00 e0 08 ld [ %g3 + 8 ], %g3 4000890c: 80 a0 e0 00 cmp %g3, 0 40008910: 32 bf ff ff bne,a 4000890c <_RBTree_Extract+0xe8> 40008914: c6 00 e0 08 ld [ %g3 + 8 ], %g3 40008918: 80 a1 20 00 cmp %g4, 0 4000891c: 12 80 00 37 bne 400089f8 <_RBTree_Extract+0x1d4> 40008920: 9a 10 20 01 mov 1, %o5 RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 40008924: 80 a0 60 00 cmp %g1, 0 40008928: 22 80 00 07 be,a 40008944 <_RBTree_Extract+0x120> 4000892c: c6 02 00 00 ld [ %o0 ], %g3 40008930: c6 00 60 0c ld [ %g1 + 0xc ], %g3 40008934: 80 a0 e0 00 cmp %g3, 0 40008938: 12 80 00 9e bne 40008bb0 <_RBTree_Extract+0x38c> 4000893c: 86 10 00 01 mov %g1, %g3 40008940: c6 02 00 00 ld [ %o0 ], %g3 40008944: 80 a0 40 03 cmp %g1, %g3 40008948: 02 80 00 98 be 40008ba8 <_RBTree_Extract+0x384> 4000894c: 80 a0 e0 00 cmp %g3, 0 40008950: c6 00 80 00 ld [ %g2 ], %g3 40008954: 80 a0 c0 01 cmp %g3, %g1 40008958: 22 80 00 2a be,a 40008a00 <_RBTree_Extract+0x1dc> 4000895c: c2 00 a0 04 ld [ %g2 + 4 ], %g1 40008960: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 40008964: 80 a0 60 01 cmp %g1, 1 40008968: 22 80 00 3d be,a 40008a5c <_RBTree_Extract+0x238> 4000896c: c8 00 e0 04 ld [ %g3 + 4 ], %g4 40008970: c2 00 c0 00 ld [ %g3 ], %g1 40008974: 80 a0 60 00 cmp %g1, 0 40008978: 22 80 00 07 be,a 40008994 <_RBTree_Extract+0x170> 4000897c: c8 00 e0 04 ld [ %g3 + 4 ], %g4 40008980: c8 00 60 0c ld [ %g1 + 0xc ], %g4 40008984: 80 a1 20 00 cmp %g4, 0 40008988: 32 80 00 71 bne,a 40008b4c <_RBTree_Extract+0x328> 4000898c: da 00 a0 0c ld [ %g2 + 0xc ], %o5 40008990: c8 00 e0 04 ld [ %g3 + 4 ], %g4 40008994: 80 a1 20 00 cmp %g4, 0 40008998: 22 80 00 07 be,a 400089b4 <_RBTree_Extract+0x190> 4000899c: da 20 e0 0c st %o5, [ %g3 + 0xc ] 400089a0: d8 01 20 0c ld [ %g4 + 0xc ], %o4 400089a4: 80 a3 20 00 cmp %o4, 0 400089a8: 12 80 00 62 bne 40008b30 <_RBTree_Extract+0x30c> 400089ac: 80 a0 60 00 cmp %g1, 0 400089b0: da 20 e0 0c st %o5, [ %g3 + 0xc ] 400089b4: 82 10 00 02 mov %g2, %g1 400089b8: c6 00 a0 08 ld [ %g2 + 8 ], %g3 400089bc: 10 bf ff da b 40008924 <_RBTree_Extract+0x100> 400089c0: 84 10 00 03 mov %g3, %g2 RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 400089c4: c8 02 60 0c ld [ %o1 + 0xc ], %g4 400089c8: 82 10 00 03 mov %g3, %g1 400089cc: 80 a0 a0 00 cmp %g2, 0 400089d0: 02 80 00 54 be 40008b20 <_RBTree_Extract+0x2fc> 400089d4: c4 20 60 08 st %g2, [ %g1 + 8 ] 400089d8: c6 00 80 00 ld [ %g2 ], %g3 400089dc: 80 a2 40 03 cmp %o1, %g3 400089e0: 22 80 00 03 be,a 400089ec <_RBTree_Extract+0x1c8> 400089e4: c2 20 80 00 st %g1, [ %g2 ] 400089e8: c2 20 a0 04 st %g1, [ %g2 + 4 ] 400089ec: 80 a1 20 00 cmp %g4, 0 400089f0: 02 bf ff cd be 40008924 <_RBTree_Extract+0x100> 400089f4: 9a 10 20 01 mov 1, %o5 ) { _Assert( _RBTree_Find_root( the_node ) == _RBTree_Root( the_rbtree ) ); RB_REMOVE( RBTree_Control, the_rbtree, the_node ); _RBTree_Initialize_node( the_node ); } 400089f8: 81 c3 e0 08 retl 400089fc: 01 00 00 00 nop RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 40008a00: c8 00 60 0c ld [ %g1 + 0xc ], %g4 40008a04: 80 a1 20 01 cmp %g4, 1 40008a08: 02 80 00 28 be 40008aa8 <_RBTree_Extract+0x284> 40008a0c: c6 00 40 00 ld [ %g1 ], %g3 40008a10: 80 a0 e0 00 cmp %g3, 0 40008a14: 22 80 00 06 be,a 40008a2c <_RBTree_Extract+0x208> 40008a18: c8 00 60 04 ld [ %g1 + 4 ], %g4 40008a1c: c8 00 e0 0c ld [ %g3 + 0xc ], %g4 40008a20: 80 a1 20 00 cmp %g4, 0 40008a24: 12 80 00 b6 bne 40008cfc <_RBTree_Extract+0x4d8> 40008a28: c8 00 60 04 ld [ %g1 + 4 ], %g4 40008a2c: 80 a1 20 00 cmp %g4, 0 40008a30: 22 80 00 07 be,a 40008a4c <_RBTree_Extract+0x228> 40008a34: c6 00 a0 08 ld [ %g2 + 8 ], %g3 40008a38: c6 01 20 0c ld [ %g4 + 0xc ], %g3 40008a3c: 80 a0 e0 00 cmp %g3, 0 40008a40: 32 80 00 92 bne,a 40008c88 <_RBTree_Extract+0x464> 40008a44: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 40008a48: c6 00 a0 08 ld [ %g2 + 8 ], %g3 40008a4c: da 20 60 0c st %o5, [ %g1 + 0xc ] 40008a50: 82 10 00 02 mov %g2, %g1 40008a54: 10 bf ff b4 b 40008924 <_RBTree_Extract+0x100> 40008a58: 84 10 00 03 mov %g3, %g2 40008a5c: c0 20 e0 0c clr [ %g3 + 0xc ] 40008a60: 80 a1 20 00 cmp %g4, 0 40008a64: c2 20 a0 0c st %g1, [ %g2 + 0xc ] 40008a68: 02 80 00 03 be 40008a74 <_RBTree_Extract+0x250> <== NEVER TAKEN 40008a6c: c8 20 80 00 st %g4, [ %g2 ] 40008a70: c4 21 20 08 st %g2, [ %g4 + 8 ] 40008a74: c2 00 a0 08 ld [ %g2 + 8 ], %g1 40008a78: 80 a0 60 00 cmp %g1, 0 40008a7c: 02 80 00 20 be 40008afc <_RBTree_Extract+0x2d8> 40008a80: c2 20 e0 08 st %g1, [ %g3 + 8 ] 40008a84: d8 00 40 00 ld [ %g1 ], %o4 40008a88: 80 a0 80 0c cmp %g2, %o4 40008a8c: 22 80 00 27 be,a 40008b28 <_RBTree_Extract+0x304> 40008a90: c6 20 40 00 st %g3, [ %g1 ] 40008a94: c6 20 60 04 st %g3, [ %g1 + 4 ] 40008a98: c4 20 e0 04 st %g2, [ %g3 + 4 ] 40008a9c: c6 20 a0 08 st %g3, [ %g2 + 8 ] 40008aa0: 10 bf ff b4 b 40008970 <_RBTree_Extract+0x14c> 40008aa4: 86 10 00 04 mov %g4, %g3 40008aa8: c0 20 60 0c clr [ %g1 + 0xc ] 40008aac: 80 a0 e0 00 cmp %g3, 0 40008ab0: c8 20 a0 0c st %g4, [ %g2 + 0xc ] 40008ab4: 02 80 00 03 be 40008ac0 <_RBTree_Extract+0x29c> <== NEVER TAKEN 40008ab8: c6 20 a0 04 st %g3, [ %g2 + 4 ] 40008abc: c4 20 e0 08 st %g2, [ %g3 + 8 ] 40008ac0: c8 00 a0 08 ld [ %g2 + 8 ], %g4 40008ac4: 80 a1 20 00 cmp %g4, 0 40008ac8: 02 80 00 59 be 40008c2c <_RBTree_Extract+0x408> 40008acc: c8 20 60 08 st %g4, [ %g1 + 8 ] 40008ad0: d8 01 00 00 ld [ %g4 ], %o4 40008ad4: 80 a0 80 0c cmp %g2, %o4 40008ad8: 22 80 00 68 be,a 40008c78 <_RBTree_Extract+0x454> 40008adc: c2 21 00 00 st %g1, [ %g4 ] 40008ae0: c2 21 20 04 st %g1, [ %g4 + 4 ] 40008ae4: c8 00 a0 04 ld [ %g2 + 4 ], %g4 40008ae8: c4 20 40 00 st %g2, [ %g1 ] 40008aec: c6 01 00 00 ld [ %g4 ], %g3 40008af0: c2 20 a0 08 st %g1, [ %g2 + 8 ] 40008af4: 10 bf ff c7 b 40008a10 <_RBTree_Extract+0x1ec> 40008af8: 82 10 00 04 mov %g4, %g1 40008afc: 10 bf ff e7 b 40008a98 <_RBTree_Extract+0x274> 40008b00: c6 22 00 00 st %g3, [ %o0 ] RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 40008b04: c4 02 60 08 ld [ %o1 + 8 ], %g2 40008b08: 80 a0 60 00 cmp %g1, 0 40008b0c: 12 bf ff b0 bne 400089cc <_RBTree_Extract+0x1a8> 40008b10: c8 02 60 0c ld [ %o1 + 0xc ], %g4 40008b14: 80 a0 a0 00 cmp %g2, 0 40008b18: 32 bf ff b1 bne,a 400089dc <_RBTree_Extract+0x1b8> 40008b1c: c6 00 80 00 ld [ %g2 ], %g3 40008b20: 10 bf ff b3 b 400089ec <_RBTree_Extract+0x1c8> 40008b24: c2 22 00 00 st %g1, [ %o0 ] RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 40008b28: 10 bf ff dc b 40008a98 <_RBTree_Extract+0x274> 40008b2c: c8 00 80 00 ld [ %g2 ], %g4 40008b30: 22 80 00 24 be,a 40008bc0 <_RBTree_Extract+0x39c> 40008b34: c2 01 00 00 ld [ %g4 ], %g1 40008b38: da 00 60 0c ld [ %g1 + 0xc ], %o5 40008b3c: 80 a3 60 00 cmp %o5, 0 40008b40: 22 80 00 20 be,a 40008bc0 <_RBTree_Extract+0x39c> <== ALWAYS TAKEN 40008b44: c2 01 00 00 ld [ %g4 ], %g1 40008b48: da 00 a0 0c ld [ %g2 + 0xc ], %o5 <== NOT EXECUTED 40008b4c: c8 00 80 00 ld [ %g2 ], %g4 40008b50: da 20 e0 0c st %o5, [ %g3 + 0xc ] 40008b54: c0 20 a0 0c clr [ %g2 + 0xc ] 40008b58: c0 20 60 0c clr [ %g1 + 0xc ] 40008b5c: c2 01 20 04 ld [ %g4 + 4 ], %g1 40008b60: 80 a0 60 00 cmp %g1, 0 40008b64: 02 80 00 03 be 40008b70 <_RBTree_Extract+0x34c> 40008b68: c2 20 80 00 st %g1, [ %g2 ] 40008b6c: c4 20 60 08 st %g2, [ %g1 + 8 ] 40008b70: c2 00 a0 08 ld [ %g2 + 8 ], %g1 40008b74: 80 a0 60 00 cmp %g1, 0 40008b78: 02 80 00 5c be 40008ce8 <_RBTree_Extract+0x4c4> 40008b7c: c2 21 20 08 st %g1, [ %g4 + 8 ] 40008b80: c6 00 a0 08 ld [ %g2 + 8 ], %g3 40008b84: c6 00 c0 00 ld [ %g3 ], %g3 40008b88: 80 a0 80 03 cmp %g2, %g3 40008b8c: 22 80 00 7f be,a 40008d88 <_RBTree_Extract+0x564> 40008b90: c8 20 40 00 st %g4, [ %g1 ] 40008b94: c8 20 60 04 st %g4, [ %g1 + 4 ] 40008b98: c6 02 00 00 ld [ %o0 ], %g3 40008b9c: c4 21 20 04 st %g2, [ %g4 + 4 ] 40008ba0: c8 20 a0 08 st %g4, [ %g2 + 8 ] 40008ba4: 80 a0 e0 00 cmp %g3, 0 40008ba8: 02 80 00 04 be 40008bb8 <_RBTree_Extract+0x394> 40008bac: 01 00 00 00 nop } 40008bb0: 81 c3 e0 08 retl 40008bb4: c0 20 e0 0c clr [ %g3 + 0xc ] 40008bb8: 81 c3 e0 08 retl 40008bbc: 01 00 00 00 nop RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 40008bc0: c0 21 20 0c clr [ %g4 + 0xc ] 40008bc4: 9a 10 20 01 mov 1, %o5 40008bc8: c2 20 e0 04 st %g1, [ %g3 + 4 ] 40008bcc: 80 a0 60 00 cmp %g1, 0 40008bd0: 02 80 00 03 be 40008bdc <_RBTree_Extract+0x3b8> 40008bd4: da 20 e0 0c st %o5, [ %g3 + 0xc ] 40008bd8: c6 20 60 08 st %g3, [ %g1 + 8 ] 40008bdc: c2 00 e0 08 ld [ %g3 + 8 ], %g1 40008be0: 80 a0 60 00 cmp %g1, 0 40008be4: 02 80 00 3f be 40008ce0 <_RBTree_Extract+0x4bc> <== NEVER TAKEN 40008be8: c2 21 20 08 st %g1, [ %g4 + 8 ] 40008bec: da 00 40 00 ld [ %g1 ], %o5 40008bf0: 80 a0 c0 0d cmp %g3, %o5 40008bf4: 22 80 00 03 be,a 40008c00 <_RBTree_Extract+0x3dc> <== ALWAYS TAKEN 40008bf8: c8 20 40 00 st %g4, [ %g1 ] 40008bfc: c8 20 60 04 st %g4, [ %g1 + 4 ] <== NOT EXECUTED 40008c00: c6 21 00 00 st %g3, [ %g4 ] 40008c04: c8 20 e0 08 st %g4, [ %g3 + 8 ] 40008c08: c2 00 a0 0c ld [ %g2 + 0xc ], %g1 40008c0c: c8 00 80 00 ld [ %g2 ], %g4 40008c10: c2 21 20 0c st %g1, [ %g4 + 0xc ] 40008c14: c2 01 00 00 ld [ %g4 ], %g1 40008c18: 80 a0 60 00 cmp %g1, 0 40008c1c: 02 bf ff d0 be 40008b5c <_RBTree_Extract+0x338> <== NEVER TAKEN 40008c20: c0 20 a0 0c clr [ %g2 + 0xc ] 40008c24: 10 bf ff ce b 40008b5c <_RBTree_Extract+0x338> 40008c28: c0 20 60 0c clr [ %g1 + 0xc ] 40008c2c: c2 22 00 00 st %g1, [ %o0 ] 40008c30: 10 bf ff ae b 40008ae8 <_RBTree_Extract+0x2c4> 40008c34: 88 10 00 03 mov %g3, %g4 RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 40008c38: 12 bf ff 1a bne 400088a0 <_RBTree_Extract+0x7c> <== NOT EXECUTED 40008c3c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 40008c40: da 02 40 00 ld [ %o1 ], %o5 <== NOT EXECUTED 40008c44: da 20 c0 00 st %o5, [ %g3 ] 40008c48: da 02 60 04 ld [ %o1 + 4 ], %o5 40008c4c: da 20 e0 04 st %o5, [ %g3 + 4 ] 40008c50: da 02 60 08 ld [ %o1 + 8 ], %o5 40008c54: da 20 e0 08 st %o5, [ %g3 + 8 ] 40008c58: da 02 60 0c ld [ %o1 + 0xc ], %o5 40008c5c: da 20 e0 0c st %o5, [ %g3 + 0xc ] 40008c60: da 02 60 08 ld [ %o1 + 8 ], %o5 40008c64: 80 a3 60 00 cmp %o5, 0 40008c68: 12 bf ff 1a bne 400088d0 <_RBTree_Extract+0xac> 40008c6c: 84 10 00 03 mov %g3, %g2 40008c70: 10 bf ff 1d b 400088e4 <_RBTree_Extract+0xc0> 40008c74: c6 22 00 00 st %g3, [ %o0 ] RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 40008c78: 10 bf ff 9c b 40008ae8 <_RBTree_Extract+0x2c4> 40008c7c: 88 10 00 03 mov %g3, %g4 RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 40008c80: 10 bf ff cc b 40008bb0 <_RBTree_Extract+0x38c> <== NOT EXECUTED 40008c84: 86 10 00 01 mov %g1, %g3 <== NOT EXECUTED RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 40008c88: da 00 a0 04 ld [ %g2 + 4 ], %o5 40008c8c: c6 20 60 0c st %g3, [ %g1 + 0xc ] 40008c90: c0 20 a0 0c clr [ %g2 + 0xc ] 40008c94: c0 21 20 0c clr [ %g4 + 0xc ] 40008c98: c2 03 40 00 ld [ %o5 ], %g1 40008c9c: 80 a0 60 00 cmp %g1, 0 40008ca0: 02 80 00 03 be 40008cac <_RBTree_Extract+0x488> 40008ca4: c2 20 a0 04 st %g1, [ %g2 + 4 ] 40008ca8: c4 20 60 08 st %g2, [ %g1 + 8 ] 40008cac: c2 00 a0 08 ld [ %g2 + 8 ], %g1 40008cb0: 80 a0 60 00 cmp %g1, 0 40008cb4: 02 80 00 39 be 40008d98 <_RBTree_Extract+0x574> 40008cb8: c2 23 60 08 st %g1, [ %o5 + 8 ] 40008cbc: c6 00 40 00 ld [ %g1 ], %g3 40008cc0: 80 a0 80 03 cmp %g2, %g3 40008cc4: 22 80 00 3a be,a 40008dac <_RBTree_Extract+0x588> 40008cc8: da 20 40 00 st %o5, [ %g1 ] 40008ccc: da 20 60 04 st %o5, [ %g1 + 4 ] 40008cd0: c6 02 00 00 ld [ %o0 ], %g3 40008cd4: c4 23 40 00 st %g2, [ %o5 ] 40008cd8: 10 bf ff b3 b 40008ba4 <_RBTree_Extract+0x380> 40008cdc: da 20 a0 08 st %o5, [ %g2 + 8 ] 40008ce0: 10 bf ff c8 b 40008c00 <_RBTree_Extract+0x3dc> <== NOT EXECUTED 40008ce4: c8 22 00 00 st %g4, [ %o0 ] <== NOT EXECUTED 40008ce8: c8 22 00 00 st %g4, [ %o0 ] 40008cec: 86 10 00 04 mov %g4, %g3 40008cf0: c4 21 20 04 st %g2, [ %g4 + 4 ] 40008cf4: 10 bf ff ac b 40008ba4 <_RBTree_Extract+0x380> 40008cf8: c8 20 a0 08 st %g4, [ %g2 + 8 ] 40008cfc: 80 a1 20 00 cmp %g4, 0 40008d00: 22 80 00 07 be,a 40008d1c <_RBTree_Extract+0x4f8> 40008d04: c8 00 e0 04 ld [ %g3 + 4 ], %g4 40008d08: da 01 20 0c ld [ %g4 + 0xc ], %o5 40008d0c: 80 a3 60 00 cmp %o5, 0 40008d10: 32 bf ff de bne,a 40008c88 <_RBTree_Extract+0x464> 40008d14: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 40008d18: c8 00 e0 04 ld [ %g3 + 4 ], %g4 40008d1c: c0 20 e0 0c clr [ %g3 + 0xc ] 40008d20: 9a 10 20 01 mov 1, %o5 40008d24: c8 20 40 00 st %g4, [ %g1 ] 40008d28: 80 a1 20 00 cmp %g4, 0 40008d2c: 02 80 00 03 be 40008d38 <_RBTree_Extract+0x514> 40008d30: da 20 60 0c st %o5, [ %g1 + 0xc ] 40008d34: c2 21 20 08 st %g1, [ %g4 + 8 ] 40008d38: c8 00 60 08 ld [ %g1 + 8 ], %g4 40008d3c: 80 a1 20 00 cmp %g4, 0 40008d40: 02 80 00 1f be 40008dbc <_RBTree_Extract+0x598> <== NEVER TAKEN 40008d44: c8 20 e0 08 st %g4, [ %g3 + 8 ] 40008d48: da 01 00 00 ld [ %g4 ], %o5 40008d4c: 80 a0 40 0d cmp %g1, %o5 40008d50: 22 80 00 03 be,a 40008d5c <_RBTree_Extract+0x538> <== NEVER TAKEN 40008d54: c6 21 00 00 st %g3, [ %g4 ] <== NOT EXECUTED 40008d58: c6 21 20 04 st %g3, [ %g4 + 4 ] 40008d5c: c2 20 e0 04 st %g1, [ %g3 + 4 ] 40008d60: c6 20 60 08 st %g3, [ %g1 + 8 ] 40008d64: da 00 a0 04 ld [ %g2 + 4 ], %o5 40008d68: c2 00 a0 0c ld [ %g2 + 0xc ], %g1 40008d6c: c2 23 60 0c st %g1, [ %o5 + 0xc ] 40008d70: c8 03 60 04 ld [ %o5 + 4 ], %g4 40008d74: 80 a1 20 00 cmp %g4, 0 40008d78: 02 bf ff c8 be 40008c98 <_RBTree_Extract+0x474> <== NEVER TAKEN 40008d7c: c0 20 a0 0c clr [ %g2 + 0xc ] 40008d80: 10 bf ff c6 b 40008c98 <_RBTree_Extract+0x474> 40008d84: c0 21 20 0c clr [ %g4 + 0xc ] 40008d88: c6 02 00 00 ld [ %o0 ], %g3 40008d8c: c4 21 20 04 st %g2, [ %g4 + 4 ] 40008d90: 10 bf ff 85 b 40008ba4 <_RBTree_Extract+0x380> 40008d94: c8 20 a0 08 st %g4, [ %g2 + 8 ] 40008d98: da 22 00 00 st %o5, [ %o0 ] 40008d9c: 86 10 00 0d mov %o5, %g3 40008da0: c4 23 40 00 st %g2, [ %o5 ] 40008da4: 10 bf ff 80 b 40008ba4 <_RBTree_Extract+0x380> 40008da8: da 20 a0 08 st %o5, [ %g2 + 8 ] 40008dac: c6 02 00 00 ld [ %o0 ], %g3 40008db0: c4 23 40 00 st %g2, [ %o5 ] 40008db4: 10 bf ff 7c b 40008ba4 <_RBTree_Extract+0x380> 40008db8: da 20 a0 08 st %o5, [ %g2 + 8 ] 40008dbc: 10 bf ff e8 b 40008d5c <_RBTree_Extract+0x538> <== NOT EXECUTED 40008dc0: c6 22 00 00 st %g3, [ %o0 ] <== NOT EXECUTED =============================================================================== 40008dc4 <_RBTree_Insert_color>: #include "config.h" #endif #include RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline ) 40008dc4: c2 02 60 08 ld [ %o1 + 8 ], %g1 40008dc8: 80 a0 60 00 cmp %g1, 0 40008dcc: 02 80 00 2c be 40008e7c <_RBTree_Insert_color+0xb8> 40008dd0: 9a 10 20 01 mov 1, %o5 40008dd4: c4 00 60 0c ld [ %g1 + 0xc ], %g2 40008dd8: 80 a0 a0 01 cmp %g2, 1 40008ddc: 32 80 00 29 bne,a 40008e80 <_RBTree_Insert_color+0xbc> 40008de0: c2 02 00 00 ld [ %o0 ], %g1 40008de4: c4 00 60 08 ld [ %g1 + 8 ], %g2 40008de8: c6 00 80 00 ld [ %g2 ], %g3 40008dec: 80 a0 c0 01 cmp %g3, %g1 40008df0: 02 80 00 26 be 40008e88 <_RBTree_Insert_color+0xc4> 40008df4: 80 a0 e0 00 cmp %g3, 0 40008df8: 22 80 00 07 be,a 40008e14 <_RBTree_Insert_color+0x50> 40008dfc: c6 00 40 00 ld [ %g1 ], %g3 40008e00: c8 00 e0 0c ld [ %g3 + 0xc ], %g4 40008e04: 80 a1 20 01 cmp %g4, 1 40008e08: 22 80 00 54 be,a 40008f58 <_RBTree_Insert_color+0x194> 40008e0c: c0 20 e0 0c clr [ %g3 + 0xc ] 40008e10: c6 00 40 00 ld [ %g1 ], %g3 40008e14: 80 a0 c0 09 cmp %g3, %o1 40008e18: 22 80 00 3d be,a 40008f0c <_RBTree_Insert_color+0x148> 40008e1c: c6 02 60 04 ld [ %o1 + 4 ], %g3 40008e20: c6 00 a0 04 ld [ %g2 + 4 ], %g3 40008e24: c0 20 60 0c clr [ %g1 + 0xc ] 40008e28: c2 00 c0 00 ld [ %g3 ], %g1 40008e2c: c2 20 a0 04 st %g1, [ %g2 + 4 ] 40008e30: 80 a0 60 00 cmp %g1, 0 40008e34: 02 80 00 03 be 40008e40 <_RBTree_Insert_color+0x7c> 40008e38: da 20 a0 0c st %o5, [ %g2 + 0xc ] 40008e3c: c4 20 60 08 st %g2, [ %g1 + 8 ] 40008e40: c2 00 a0 08 ld [ %g2 + 8 ], %g1 40008e44: 80 a0 60 00 cmp %g1, 0 40008e48: 02 80 00 2f be 40008f04 <_RBTree_Insert_color+0x140> 40008e4c: c2 20 e0 08 st %g1, [ %g3 + 8 ] 40008e50: c8 00 40 00 ld [ %g1 ], %g4 40008e54: 80 a0 80 04 cmp %g2, %g4 40008e58: 22 80 00 03 be,a 40008e64 <_RBTree_Insert_color+0xa0> 40008e5c: c6 20 40 00 st %g3, [ %g1 ] 40008e60: c6 20 60 04 st %g3, [ %g1 + 4 ] 40008e64: c4 20 c0 00 st %g2, [ %g3 ] 40008e68: c6 20 a0 08 st %g3, [ %g2 + 8 ] 40008e6c: c2 02 60 08 ld [ %o1 + 8 ], %g1 40008e70: 80 a0 60 00 cmp %g1, 0 40008e74: 32 bf ff d9 bne,a 40008dd8 <_RBTree_Insert_color+0x14> 40008e78: c4 00 60 0c ld [ %g1 + 0xc ], %g2 40008e7c: c2 02 00 00 ld [ %o0 ], %g1 RBTree_Control *the_rbtree, RBTree_Node *the_node ) { RBTree_Control_RB_INSERT_COLOR( the_rbtree, the_node ); } 40008e80: 81 c3 e0 08 retl 40008e84: c0 20 60 0c clr [ %g1 + 0xc ] RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline ) 40008e88: c6 00 a0 04 ld [ %g2 + 4 ], %g3 40008e8c: 80 a0 e0 00 cmp %g3, 0 40008e90: 22 80 00 07 be,a 40008eac <_RBTree_Insert_color+0xe8> 40008e94: c8 00 60 04 ld [ %g1 + 4 ], %g4 40008e98: c8 00 e0 0c ld [ %g3 + 0xc ], %g4 40008e9c: 80 a1 20 01 cmp %g4, 1 40008ea0: 22 80 00 2e be,a 40008f58 <_RBTree_Insert_color+0x194> 40008ea4: c0 20 e0 0c clr [ %g3 + 0xc ] 40008ea8: c8 00 60 04 ld [ %g1 + 4 ], %g4 40008eac: 80 a1 00 09 cmp %g4, %o1 40008eb0: 02 80 00 32 be 40008f78 <_RBTree_Insert_color+0x1b4> 40008eb4: 86 10 00 01 mov %g1, %g3 40008eb8: c0 20 60 0c clr [ %g1 + 0xc ] 40008ebc: c2 00 e0 04 ld [ %g3 + 4 ], %g1 40008ec0: c2 20 80 00 st %g1, [ %g2 ] 40008ec4: 80 a0 60 00 cmp %g1, 0 40008ec8: 02 80 00 03 be 40008ed4 <_RBTree_Insert_color+0x110> 40008ecc: da 20 a0 0c st %o5, [ %g2 + 0xc ] 40008ed0: c4 20 60 08 st %g2, [ %g1 + 8 ] 40008ed4: c2 00 a0 08 ld [ %g2 + 8 ], %g1 40008ed8: 80 a0 60 00 cmp %g1, 0 40008edc: 02 80 00 23 be 40008f68 <_RBTree_Insert_color+0x1a4> 40008ee0: c2 20 e0 08 st %g1, [ %g3 + 8 ] 40008ee4: c8 00 40 00 ld [ %g1 ], %g4 40008ee8: 80 a0 80 04 cmp %g2, %g4 40008eec: 22 80 00 38 be,a 40008fcc <_RBTree_Insert_color+0x208> 40008ef0: c6 20 40 00 st %g3, [ %g1 ] 40008ef4: c6 20 60 04 st %g3, [ %g1 + 4 ] 40008ef8: c4 20 e0 04 st %g2, [ %g3 + 4 ] 40008efc: 10 bf ff dc b 40008e6c <_RBTree_Insert_color+0xa8> 40008f00: c6 20 a0 08 st %g3, [ %g2 + 8 ] 40008f04: 10 bf ff d8 b 40008e64 <_RBTree_Insert_color+0xa0> 40008f08: c6 22 00 00 st %g3, [ %o0 ] 40008f0c: 80 a0 e0 00 cmp %g3, 0 40008f10: 02 80 00 34 be 40008fe0 <_RBTree_Insert_color+0x21c> 40008f14: c6 20 40 00 st %g3, [ %g1 ] 40008f18: c2 20 e0 08 st %g1, [ %g3 + 8 ] 40008f1c: c6 00 60 08 ld [ %g1 + 8 ], %g3 40008f20: 80 a0 e0 00 cmp %g3, 0 40008f24: 02 80 00 2d be 40008fd8 <_RBTree_Insert_color+0x214> <== NEVER TAKEN 40008f28: c6 22 60 08 st %g3, [ %o1 + 8 ] 40008f2c: c8 00 c0 00 ld [ %g3 ], %g4 40008f30: 80 a1 00 01 cmp %g4, %g1 40008f34: 22 80 00 03 be,a 40008f40 <_RBTree_Insert_color+0x17c> <== NEVER TAKEN 40008f38: d2 20 c0 00 st %o1, [ %g3 ] <== NOT EXECUTED 40008f3c: d2 20 e0 04 st %o1, [ %g3 + 4 ] 40008f40: 86 10 00 09 mov %o1, %g3 40008f44: c2 22 60 04 st %g1, [ %o1 + 4 ] 40008f48: d2 20 60 08 st %o1, [ %g1 + 8 ] 40008f4c: 92 10 00 01 mov %g1, %o1 40008f50: 10 bf ff b4 b 40008e20 <_RBTree_Insert_color+0x5c> 40008f54: 82 10 00 03 mov %g3, %g1 40008f58: 92 10 00 02 mov %g2, %o1 40008f5c: c0 20 60 0c clr [ %g1 + 0xc ] 40008f60: 10 bf ff c3 b 40008e6c <_RBTree_Insert_color+0xa8> 40008f64: c8 20 a0 0c st %g4, [ %g2 + 0xc ] 40008f68: c6 22 00 00 st %g3, [ %o0 ] 40008f6c: c4 20 e0 04 st %g2, [ %g3 + 4 ] 40008f70: 10 bf ff bf b 40008e6c <_RBTree_Insert_color+0xa8> 40008f74: c6 20 a0 08 st %g3, [ %g2 + 8 ] 40008f78: c6 02 40 00 ld [ %o1 ], %g3 40008f7c: 80 a0 e0 00 cmp %g3, 0 40008f80: 02 80 00 20 be 40009000 <_RBTree_Insert_color+0x23c> 40008f84: c6 20 60 04 st %g3, [ %g1 + 4 ] 40008f88: c2 20 e0 08 st %g1, [ %g3 + 8 ] 40008f8c: c6 00 60 08 ld [ %g1 + 8 ], %g3 40008f90: 80 a0 e0 00 cmp %g3, 0 40008f94: 02 80 00 1f be 40009010 <_RBTree_Insert_color+0x24c> <== NEVER TAKEN 40008f98: c6 22 60 08 st %g3, [ %o1 + 8 ] 40008f9c: c8 00 c0 00 ld [ %g3 ], %g4 40008fa0: 80 a1 00 01 cmp %g4, %g1 40008fa4: 22 80 00 03 be,a 40008fb0 <_RBTree_Insert_color+0x1ec> <== ALWAYS TAKEN 40008fa8: d2 20 c0 00 st %o1, [ %g3 ] 40008fac: d2 20 e0 04 st %o1, [ %g3 + 4 ] <== NOT EXECUTED 40008fb0: 88 10 00 09 mov %o1, %g4 40008fb4: c2 22 40 00 st %g1, [ %o1 ] 40008fb8: c6 00 80 00 ld [ %g2 ], %g3 40008fbc: d2 20 60 08 st %o1, [ %g1 + 8 ] 40008fc0: 92 10 00 01 mov %g1, %o1 40008fc4: 10 bf ff bd b 40008eb8 <_RBTree_Insert_color+0xf4> 40008fc8: 82 10 00 04 mov %g4, %g1 40008fcc: c4 20 e0 04 st %g2, [ %g3 + 4 ] 40008fd0: 10 bf ff a7 b 40008e6c <_RBTree_Insert_color+0xa8> 40008fd4: c6 20 a0 08 st %g3, [ %g2 + 8 ] 40008fd8: 10 bf ff da b 40008f40 <_RBTree_Insert_color+0x17c> <== NOT EXECUTED 40008fdc: d2 22 00 00 st %o1, [ %o0 ] <== NOT EXECUTED 40008fe0: c4 22 60 08 st %g2, [ %o1 + 8 ] 40008fe4: 86 10 00 02 mov %g2, %g3 40008fe8: c8 00 c0 00 ld [ %g3 ], %g4 40008fec: 80 a1 00 01 cmp %g4, %g1 40008ff0: 32 bf ff d4 bne,a 40008f40 <_RBTree_Insert_color+0x17c> <== ALWAYS TAKEN 40008ff4: d2 20 e0 04 st %o1, [ %g3 + 4 ] 40008ff8: 10 bf ff d2 b 40008f40 <_RBTree_Insert_color+0x17c> <== NOT EXECUTED 40008ffc: d2 20 c0 00 st %o1, [ %g3 ] <== NOT EXECUTED 40009000: c4 22 60 08 st %g2, [ %o1 + 8 ] 40009004: 86 10 00 02 mov %g2, %g3 40009008: 10 bf ff ea b 40008fb0 <_RBTree_Insert_color+0x1ec> 4000900c: d2 20 c0 00 st %o1, [ %g3 ] 40009010: 10 bf ff e8 b 40008fb0 <_RBTree_Insert_color+0x1ec> <== NOT EXECUTED 40009014: d2 22 00 00 st %o1, [ %o0 ] <== NOT EXECUTED =============================================================================== 40006054 <_RBTree_Iterate>: void _RBTree_Iterate( const RBTree_Control *rbtree, RBTree_Visitor visitor, void *visitor_arg ) { 40006054: 9d e3 bf a0 save %sp, -96, %sp const RBTree_Node *current = _RBTree_Minimum( rbtree ); 40006058: 40 00 00 13 call 400060a4 <_RBTree_Minimum> 4000605c: 90 10 00 18 mov %i0, %o0 40006060: 10 80 00 0c b 40006090 <_RBTree_Iterate+0x3c> 40006064: ba 10 00 08 mov %o0, %i5 bool stop = false; while ( !stop && current != NULL ) { stop = ( *visitor )( current, visitor_arg ); 40006068: 9f c6 40 00 call %i1 4000606c: 90 10 00 1d mov %i5, %o0 40006070: 82 10 00 08 mov %o0, %g1 current = _RBTree_Successor( current ); 40006074: 90 10 00 1d mov %i5, %o0 40006078: 40 00 00 18 call 400060d8 <_RBTree_Successor> 4000607c: ba 10 00 01 mov %g1, %i5 while ( !stop && current != NULL ) { 40006080: 82 1f 60 01 xor %i5, 1, %g1 40006084: 80 88 60 ff btst 0xff, %g1 40006088: 02 80 00 05 be 4000609c <_RBTree_Iterate+0x48> <== NEVER TAKEN 4000608c: ba 10 00 08 mov %o0, %i5 40006090: 80 a7 60 00 cmp %i5, 0 40006094: 12 bf ff f5 bne 40006068 <_RBTree_Iterate+0x14> 40006098: 92 10 00 1a mov %i2, %o1 } } 4000609c: 81 c7 e0 08 ret 400060a0: 81 e8 00 00 restore =============================================================================== 40015a80 <_RBTree_Predecessor>: RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static ) 40015a80: c2 02 00 00 ld [ %o0 ], %g1 40015a84: 80 a0 60 00 cmp %g1, 0 40015a88: 22 80 00 09 be,a 40015aac <_RBTree_Predecessor+0x2c> 40015a8c: c4 02 20 08 ld [ %o0 + 8 ], %g2 40015a90: 84 10 00 01 mov %g1, %g2 40015a94: c2 00 60 04 ld [ %g1 + 4 ], %g1 40015a98: 80 a0 60 00 cmp %g1, 0 40015a9c: 32 bf ff fe bne,a 40015a94 <_RBTree_Predecessor+0x14> 40015aa0: 84 10 00 01 mov %g1, %g2 RBTree_Node *_RBTree_Predecessor( const RBTree_Node *node ) { return RB_PREV( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) ); } 40015aa4: 81 c3 e0 08 retl 40015aa8: 90 10 00 02 mov %g2, %o0 RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static ) 40015aac: 80 a0 a0 00 cmp %g2, 0 40015ab0: 02 bf ff fd be 40015aa4 <_RBTree_Predecessor+0x24> 40015ab4: 01 00 00 00 nop 40015ab8: c2 00 a0 04 ld [ %g2 + 4 ], %g1 40015abc: 80 a2 00 01 cmp %o0, %g1 40015ac0: 02 bf ff f9 be 40015aa4 <_RBTree_Predecessor+0x24> 40015ac4: 01 00 00 00 nop 40015ac8: c2 00 80 00 ld [ %g2 ], %g1 40015acc: 80 a0 40 08 cmp %g1, %o0 40015ad0: 12 bf ff f5 bne 40015aa4 <_RBTree_Predecessor+0x24> <== NEVER TAKEN 40015ad4: 01 00 00 00 nop 40015ad8: c2 00 a0 08 ld [ %g2 + 8 ], %g1 40015adc: 80 a0 60 00 cmp %g1, 0 40015ae0: 02 80 00 09 be 40015b04 <_RBTree_Predecessor+0x84> 40015ae4: 90 10 00 02 mov %g2, %o0 40015ae8: 84 10 00 01 mov %g1, %g2 40015aec: c2 00 80 00 ld [ %g2 ], %g1 40015af0: 80 a0 40 08 cmp %g1, %o0 40015af4: 22 bf ff fa be,a 40015adc <_RBTree_Predecessor+0x5c> 40015af8: c2 00 a0 08 ld [ %g2 + 8 ], %g1 } 40015afc: 81 c3 e0 08 retl 40015b00: 90 10 00 02 mov %g2, %o0 return RB_PREV( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) ); 40015b04: 10 bf ff e8 b 40015aa4 <_RBTree_Predecessor+0x24> 40015b08: 84 10 20 00 clr %g2 =============================================================================== 400159f4 <_RBTree_Successor>: RB_GENERATE_NEXT( RBTree_Control, RBTree_Node, Node, static ) 400159f4: c2 02 20 04 ld [ %o0 + 4 ], %g1 400159f8: 80 a0 60 00 cmp %g1, 0 400159fc: 22 80 00 09 be,a 40015a20 <_RBTree_Successor+0x2c> 40015a00: c4 02 20 08 ld [ %o0 + 8 ], %g2 40015a04: 84 10 00 01 mov %g1, %g2 40015a08: c2 00 40 00 ld [ %g1 ], %g1 40015a0c: 80 a0 60 00 cmp %g1, 0 40015a10: 32 bf ff fe bne,a 40015a08 <_RBTree_Successor+0x14> 40015a14: 84 10 00 01 mov %g1, %g2 RBTree_Node *_RBTree_Successor( const RBTree_Node *node ) { return RB_NEXT( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) ); } 40015a18: 81 c3 e0 08 retl 40015a1c: 90 10 00 02 mov %g2, %o0 RB_GENERATE_NEXT( RBTree_Control, RBTree_Node, Node, static ) 40015a20: 80 a0 a0 00 cmp %g2, 0 40015a24: 02 bf ff fd be 40015a18 <_RBTree_Successor+0x24> 40015a28: 01 00 00 00 nop 40015a2c: c2 00 80 00 ld [ %g2 ], %g1 40015a30: 80 a2 00 01 cmp %o0, %g1 40015a34: 02 bf ff f9 be 40015a18 <_RBTree_Successor+0x24> 40015a38: 01 00 00 00 nop 40015a3c: c2 00 a0 04 ld [ %g2 + 4 ], %g1 40015a40: 80 a0 40 08 cmp %g1, %o0 40015a44: 12 bf ff f5 bne 40015a18 <_RBTree_Successor+0x24> <== NEVER TAKEN 40015a48: 01 00 00 00 nop 40015a4c: c2 00 a0 08 ld [ %g2 + 8 ], %g1 40015a50: 80 a0 60 00 cmp %g1, 0 40015a54: 02 80 00 09 be 40015a78 <_RBTree_Successor+0x84> 40015a58: 90 10 00 02 mov %g2, %o0 40015a5c: 84 10 00 01 mov %g1, %g2 40015a60: c2 00 a0 04 ld [ %g2 + 4 ], %g1 40015a64: 80 a0 40 08 cmp %g1, %o0 40015a68: 22 bf ff fa be,a 40015a50 <_RBTree_Successor+0x5c> 40015a6c: c2 00 a0 08 ld [ %g2 + 8 ], %g1 } 40015a70: 81 c3 e0 08 retl 40015a74: 90 10 00 02 mov %g2, %o0 return RB_NEXT( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) ); 40015a78: 10 bf ff e8 b 40015a18 <_RBTree_Successor+0x24> 40015a7c: 84 10 20 00 clr %g2 =============================================================================== 4000f59c <_SMP_barrier_Wait>: SMP_barrier_Control *control, SMP_barrier_State *state, unsigned int count ) { unsigned int sense = ~state->sense; 4000f59c: c4 02 40 00 ld [ %o1 ], %g2 4000f5a0: 84 38 00 02 xnor %g0, %g2, %g2 unsigned int previous_value; bool performed_release; state->sense = sense; 4000f5a4: c4 22 40 00 st %g2, [ %o1 ] __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000f5a8: 91 d0 20 09 ta 9 *obj = val + arg; 4000f5ac: c6 02 00 00 ld [ %o0 ], %g3 4000f5b0: 86 00 e0 01 inc %g3 4000f5b4: c6 22 00 00 st %g3, [ %o0 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000f5b8: 91 d0 20 0a ta 0xa 4000f5bc: 01 00 00 00 nop &control->value, 1U, ATOMIC_ORDER_RELAXED ); if ( previous_value + 1U == count ) { 4000f5c0: 80 a2 80 03 cmp %o2, %g3 4000f5c4: 02 80 00 09 be 4000f5e8 <_SMP_barrier_Wait+0x4c> <== ALWAYS TAKEN 4000f5c8: 01 00 00 00 nop val = *obj; 4000f5cc: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED _Atomic_Store_uint( &control->value, 0U, ATOMIC_ORDER_RELAXED ); _Atomic_Store_uint( &control->sense, sense, ATOMIC_ORDER_RELEASE ); performed_release = true; } else { while ( 4000f5d0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 4000f5d4: 32 bf ff ff bne,a 4000f5d0 <_SMP_barrier_Wait+0x34> <== NOT EXECUTED 4000f5d8: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED _Atomic_Load_uint( &control->sense, ATOMIC_ORDER_ACQUIRE ) != sense ) { /* Wait */ } performed_release = false; 4000f5dc: 82 10 20 00 clr %g1 <== NOT EXECUTED } return performed_release; } 4000f5e0: 81 c3 e0 08 retl <== NOT EXECUTED 4000f5e4: 90 08 60 01 and %g1, 1, %o0 <== NOT EXECUTED *obj = desired; 4000f5e8: c0 22 00 00 clr [ %o0 ] performed_release = true; 4000f5ec: 82 10 20 01 mov 1, %g1 4000f5f0: c4 22 20 04 st %g2, [ %o0 + 4 ] } 4000f5f4: 81 c3 e0 08 retl 4000f5f8: 90 08 60 01 and %g1, 1, %o0 =============================================================================== 400063f4 <_Scheduler_CBS_Attach_thread>: int _Scheduler_CBS_Attach_thread ( Scheduler_CBS_Server_id server_id, rtems_id task_id ) { 400063f4: 9d e3 bf 98 save %sp, -104, %sp Scheduler_CBS_Server *server; ISR_lock_Context lock_context; Thread_Control *the_thread; Scheduler_CBS_Node *node; if ( server_id >= _Scheduler_CBS_Maximum_servers ) { 400063f8: 03 10 00 49 sethi %hi(0x40012400), %g1 400063fc: c2 00 61 f8 ld [ %g1 + 0x1f8 ], %g1 ! 400125f8 <_Scheduler_CBS_Maximum_servers> 40006400: 80 a0 40 18 cmp %g1, %i0 40006404: 08 80 00 2c bleu 400064b4 <_Scheduler_CBS_Attach_thread+0xc0> 40006408: 3b 10 00 5d sethi %hi(0x40017400), %i5 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; } server = &_Scheduler_CBS_Server_list[ server_id ]; 4000640c: b1 2e 20 05 sll %i0, 5, %i0 40006410: ba 17 61 78 or %i5, 0x178, %i5 40006414: b8 06 00 1d add %i0, %i5, %i4 if ( !server->initialized ) { 40006418: c2 0f 20 1c ldub [ %i4 + 0x1c ], %g1 4000641c: 80 a0 60 00 cmp %g1, 0 40006420: 02 80 00 27 be 400064bc <_Scheduler_CBS_Attach_thread+0xc8> 40006424: 01 00 00 00 nop return SCHEDULER_CBS_ERROR_NOSERVER; } if ( server->task_id != -1 ) { 40006428: c2 07 40 18 ld [ %i5 + %i0 ], %g1 4000642c: 80 a0 7f ff cmp %g1, -1 40006430: 12 80 00 1a bne 40006498 <_Scheduler_CBS_Attach_thread+0xa4> 40006434: 92 07 bf fc add %fp, -4, %o1 return SCHEDULER_CBS_ERROR_FULL; } the_thread = _Thread_Get( task_id, &lock_context ); 40006438: 40 00 05 63 call 400079c4 <_Thread_Get> 4000643c: 90 10 00 19 mov %i1, %o0 if ( the_thread == NULL ) { 40006440: 80 a2 20 00 cmp %o0, 0 40006444: 02 80 00 1c be 400064b4 <_Scheduler_CBS_Attach_thread+0xc0> 40006448: 01 00 00 00 nop return the_thread->Scheduler.nodes; 4000644c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; } node = _Scheduler_CBS_Thread_get_node( the_thread ); if ( node->cbs_server != NULL ) { 40006450: c4 00 60 50 ld [ %g1 + 0x50 ], %g2 40006454: 80 a0 a0 00 cmp %g2, 0 40006458: 12 80 00 12 bne 400064a0 <_Scheduler_CBS_Attach_thread+0xac> <== NEVER TAKEN 4000645c: 01 00 00 00 nop _ISR_lock_ISR_enable( &lock_context ); return SCHEDULER_CBS_ERROR_FULL; } node->cbs_server = server; 40006460: f8 20 60 50 st %i4, [ %g1 + 0x50 ] server->task_id = task_id; the_thread->budget_callout = _Scheduler_CBS_Budget_callout; 40006464: 03 10 00 19 sethi %hi(0x40006400), %g1 server->task_id = task_id; 40006468: f2 27 40 18 st %i1, [ %i5 + %i0 ] the_thread->budget_callout = _Scheduler_CBS_Budget_callout; 4000646c: 82 10 60 c4 or %g1, 0xc4, %g1 40006470: c2 22 20 94 st %g1, [ %o0 + 0x94 ] the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 40006474: 82 10 20 03 mov 3, %g1 40006478: c2 22 20 90 st %g1, [ %o0 + 0x90 ] the_thread->is_preemptible = true; 4000647c: 82 10 20 01 mov 1, %g1 40006480: c2 2a 20 89 stb %g1, [ %o0 + 0x89 ] register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40006484: c2 07 bf fc ld [ %fp + -4 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40006488: 91 d0 20 0a ta 0xa 4000648c: 01 00 00 00 nop _ISR_lock_ISR_enable( &lock_context ); return SCHEDULER_CBS_OK; 40006490: 81 c7 e0 08 ret 40006494: 91 e8 20 00 restore %g0, 0, %o0 } 40006498: 81 c7 e0 08 ret 4000649c: 91 e8 3f e6 restore %g0, -26, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400064a0: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400064a4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400064a8: 01 00 00 00 nop <== NOT EXECUTED return SCHEDULER_CBS_ERROR_FULL; 400064ac: 81 c7 e0 08 ret <== NOT EXECUTED 400064b0: 91 e8 3f e6 restore %g0, -26, %o0 <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 400064b4: 81 c7 e0 08 ret 400064b8: 91 e8 3f ee restore %g0, -18, %o0 return SCHEDULER_CBS_ERROR_NOSERVER; 400064bc: 81 c7 e0 08 ret 400064c0: 91 e8 3f e7 restore %g0, -25, %o0 =============================================================================== 400064c4 <_Scheduler_CBS_Budget_callout>: #include void _Scheduler_CBS_Budget_callout( Thread_Control *the_thread ) { 400064c4: 9d e3 bf 78 save %sp, -136, %sp 400064c8: fa 06 20 38 ld [ %i0 + 0x38 ], %i5 node = _Scheduler_CBS_Thread_get_node( the_thread ); /* Put violating task to background until the end of period. */ _Thread_queue_Context_clear_priority_updates( &queue_context ); _Scheduler_CBS_Cancel_job( 400064cc: d4 07 60 54 ld [ %i5 + 0x54 ], %o2 400064d0: 92 10 00 18 mov %i0, %o1 400064d4: 96 07 bf dc add %fp, -36, %o3 400064d8: 90 10 20 00 clr %o0 400064dc: 40 00 01 52 call 40006a24 <_Scheduler_CBS_Cancel_job> 400064e0: c0 27 bf f0 clr [ %fp + -16 ] NULL, the_thread, node->deadline_node, &queue_context ); _Thread_Priority_update( &queue_context ); 400064e4: 40 00 04 8e call 4000771c <_Thread_Priority_update> 400064e8: 90 07 bf dc add %fp, -36, %o0 /* Invoke callback function if any. */ if ( node->cbs_server->cbs_budget_overrun ) { 400064ec: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 400064f0: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 400064f4: 80 a0 a0 00 cmp %g2, 0 400064f8: 02 80 00 09 be 4000651c <_Scheduler_CBS_Budget_callout+0x58> <== NEVER TAKEN 400064fc: 01 00 00 00 nop _Scheduler_CBS_Get_server_id( 40006500: d0 00 40 00 ld [ %g1 ], %o0 40006504: 40 00 01 1b call 40006970 <_Scheduler_CBS_Get_server_id> 40006508: 92 07 bf d8 add %fp, -40, %o1 node->cbs_server->task_id, &server_id ); node->cbs_server->cbs_budget_overrun( server_id ); 4000650c: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 40006510: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 40006514: 9f c0 40 00 call %g1 40006518: d0 07 bf d8 ld [ %fp + -40 ], %o0 } } 4000651c: 81 c7 e0 08 ret 40006520: 81 e8 00 00 restore =============================================================================== 4000652c <_Scheduler_CBS_Cleanup>: #include #include int _Scheduler_CBS_Cleanup (void) { 4000652c: 9d e3 bf a0 save %sp, -96, %sp unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 40006530: 03 10 00 49 sethi %hi(0x40012400), %g1 40006534: f6 00 61 f8 ld [ %g1 + 0x1f8 ], %i3 ! 400125f8 <_Scheduler_CBS_Maximum_servers> 40006538: 80 a6 e0 00 cmp %i3, 0 4000653c: 02 80 00 13 be 40006588 <_Scheduler_CBS_Cleanup+0x5c> <== NEVER TAKEN 40006540: 39 10 00 5d sethi %hi(0x40017400), %i4 40006544: ba 10 20 00 clr %i5 40006548: 10 80 00 05 b 4000655c <_Scheduler_CBS_Cleanup+0x30> 4000654c: b8 17 21 94 or %i4, 0x194, %i4 40006550: 80 a7 40 1b cmp %i5, %i3 40006554: 02 80 00 0d be 40006588 <_Scheduler_CBS_Cleanup+0x5c> 40006558: 01 00 00 00 nop if ( _Scheduler_CBS_Server_list[ i ].initialized ) 4000655c: 83 2f 60 05 sll %i5, 5, %g1 40006560: c2 0f 00 01 ldub [ %i4 + %g1 ], %g1 40006564: 80 a0 60 00 cmp %g1, 0 40006568: 22 bf ff fa be,a 40006550 <_Scheduler_CBS_Cleanup+0x24> 4000656c: ba 07 60 01 inc %i5 _Scheduler_CBS_Destroy_server( i ); 40006570: 40 00 00 3e call 40006668 <_Scheduler_CBS_Destroy_server> 40006574: 90 10 00 1d mov %i5, %o0 for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 40006578: ba 07 60 01 inc %i5 4000657c: 80 a7 40 1b cmp %i5, %i3 40006580: 12 bf ff f8 bne 40006560 <_Scheduler_CBS_Cleanup+0x34> <== ALWAYS TAKEN 40006584: 83 2f 60 05 sll %i5, 5, %g1 } return SCHEDULER_CBS_OK; } 40006588: 81 c7 e0 08 ret 4000658c: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 40006590 <_Scheduler_CBS_Create_server>: ) { unsigned int i; Scheduler_CBS_Server *the_server; if ( params->budget <= 0 || 40006590: c2 02 20 08 ld [ %o0 + 8 ], %g1 40006594: 80 a0 60 00 cmp %g1, 0 40006598: 04 80 00 25 ble 4000662c <_Scheduler_CBS_Create_server+0x9c> <== ALWAYS TAKEN 4000659c: 01 00 00 00 nop 400065a0: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 400065a4: 80 a0 60 00 cmp %g1, 0 400065a8: 04 80 00 29 ble 4000664c <_Scheduler_CBS_Create_server+0xbc> <== ALWAYS TAKEN 400065ac: 03 10 00 49 sethi %hi(0x40012400), %g1 params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 400065b0: da 00 61 f8 ld [ %g1 + 0x1f8 ], %o5 ! 400125f8 <_Scheduler_CBS_Maximum_servers> 400065b4: 80 a3 60 00 cmp %o5, 0 400065b8: 02 80 00 1b be 40006624 <_Scheduler_CBS_Create_server+0x94> <== NEVER TAKEN 400065bc: 09 10 00 5d sethi %hi(0x40017400), %g4 400065c0: 82 10 20 00 clr %g1 400065c4: 10 80 00 05 b 400065d8 <_Scheduler_CBS_Create_server+0x48> 400065c8: 88 11 21 94 or %g4, 0x194, %g4 400065cc: 80 a3 40 01 cmp %o5, %g1 400065d0: 02 80 00 15 be 40006624 <_Scheduler_CBS_Create_server+0x94> 400065d4: 01 00 00 00 nop if ( !_Scheduler_CBS_Server_list[i].initialized ) 400065d8: 85 28 60 05 sll %g1, 5, %g2 400065dc: c6 09 00 02 ldub [ %g4 + %g2 ], %g3 400065e0: 80 a0 e0 00 cmp %g3, 0 400065e4: 32 bf ff fa bne,a 400065cc <_Scheduler_CBS_Create_server+0x3c> 400065e8: 82 00 60 01 inc %g1 if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; the_server = &_Scheduler_CBS_Server_list[*server_id]; the_server->parameters = *params; 400065ec: d8 1a 00 00 ldd [ %o0 ], %o4 *server_id = i; 400065f0: c2 22 80 00 st %g1, [ %o2 ] the_server->parameters = *params; 400065f4: 88 01 3f e4 add %g4, -28, %g4 400065f8: 82 01 00 02 add %g4, %g2, %g1 400065fc: d8 38 60 08 std %o4, [ %g1 + 8 ] the_server->task_id = -1; 40006600: 86 10 3f ff mov -1, %g3 the_server->parameters = *params; 40006604: d8 1a 20 08 ldd [ %o0 + 8 ], %o4 40006608: d8 38 60 10 std %o4, [ %g1 + 0x10 ] the_server->cbs_budget_overrun = budget_overrun_callback; the_server->initialized = true; return SCHEDULER_CBS_OK; 4000660c: 90 10 20 00 clr %o0 the_server->task_id = -1; 40006610: c6 21 00 02 st %g3, [ %g4 + %g2 ] the_server->initialized = true; 40006614: 84 10 20 01 mov 1, %g2 the_server->cbs_budget_overrun = budget_overrun_callback; 40006618: d2 20 60 18 st %o1, [ %g1 + 0x18 ] return SCHEDULER_CBS_OK; 4000661c: 81 c3 e0 08 retl 40006620: c4 28 60 1c stb %g2, [ %g1 + 0x1c ] } 40006624: 81 c3 e0 08 retl 40006628: 90 10 3f e6 mov -26, %o0 if ( params->budget <= 0 || 4000662c: 12 80 00 06 bne 40006644 <_Scheduler_CBS_Create_server+0xb4> 40006630: 01 00 00 00 nop 40006634: c2 02 20 0c ld [ %o0 + 0xc ], %g1 40006638: 80 a0 60 00 cmp %g1, 0 4000663c: 32 bf ff da bne,a 400065a4 <_Scheduler_CBS_Create_server+0x14> <== ALWAYS TAKEN 40006640: c2 02 00 00 ld [ %o0 ], %g1 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 40006644: 81 c3 e0 08 retl 40006648: 90 10 3f ee mov -18, %o0 if ( params->budget <= 0 || 4000664c: 12 bf ff fe bne 40006644 <_Scheduler_CBS_Create_server+0xb4> 40006650: 01 00 00 00 nop 40006654: c2 02 20 04 ld [ %o0 + 4 ], %g1 40006658: 80 a0 60 00 cmp %g1, 0 4000665c: 12 bf ff d5 bne 400065b0 <_Scheduler_CBS_Create_server+0x20> <== ALWAYS TAKEN 40006660: 03 10 00 49 sethi %hi(0x40012400), %g1 40006664: 30 bf ff f8 b,a 40006644 <_Scheduler_CBS_Create_server+0xb4> <== NOT EXECUTED =============================================================================== 40006970 <_Scheduler_CBS_Get_server_id>: rtems_id task_id, Scheduler_CBS_Server_id *server_id ) { unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 40006970: 03 10 00 49 sethi %hi(0x40012400), %g1 40006974: c8 00 61 f8 ld [ %g1 + 0x1f8 ], %g4 ! 400125f8 <_Scheduler_CBS_Maximum_servers> 40006978: 80 a1 20 00 cmp %g4, 0 4000697c: 02 80 00 10 be 400069bc <_Scheduler_CBS_Get_server_id+0x4c> <== NEVER TAKEN 40006980: 03 10 00 5d sethi %hi(0x40017400), %g1 40006984: 84 10 20 00 clr %g2 40006988: 82 10 61 78 or %g1, 0x178, %g1 if ( _Scheduler_CBS_Server_list[i].initialized && 4000698c: c6 08 60 1c ldub [ %g1 + 0x1c ], %g3 40006990: 80 a0 e0 00 cmp %g3, 0 40006994: 22 80 00 07 be,a 400069b0 <_Scheduler_CBS_Get_server_id+0x40> 40006998: 84 00 a0 01 inc %g2 4000699c: c6 00 40 00 ld [ %g1 ], %g3 400069a0: 80 a0 c0 08 cmp %g3, %o0 400069a4: 22 80 00 08 be,a 400069c4 <_Scheduler_CBS_Get_server_id+0x54> 400069a8: c4 22 40 00 st %g2, [ %o1 ] for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 400069ac: 84 00 a0 01 inc %g2 400069b0: 80 a0 80 04 cmp %g2, %g4 400069b4: 12 bf ff f6 bne 4000698c <_Scheduler_CBS_Get_server_id+0x1c> 400069b8: 82 00 60 20 add %g1, 0x20, %g1 *server_id = i; return SCHEDULER_CBS_OK; } } return SCHEDULER_CBS_ERROR_NOSERVER; } 400069bc: 81 c3 e0 08 retl 400069c0: 90 10 3f e7 mov -25, %o0 return SCHEDULER_CBS_OK; 400069c4: 81 c3 e0 08 retl 400069c8: 90 10 20 00 clr %o0 =============================================================================== 40006a50 <_Scheduler_CBS_Set_parameters>: int _Scheduler_CBS_Set_parameters ( Scheduler_CBS_Server_id server_id, Scheduler_CBS_Parameters *params ) { if ( server_id >= _Scheduler_CBS_Maximum_servers ) 40006a50: 03 10 00 49 sethi %hi(0x40012400), %g1 40006a54: c2 00 61 f8 ld [ %g1 + 0x1f8 ], %g1 ! 400125f8 <_Scheduler_CBS_Maximum_servers> 40006a58: 80 a0 40 08 cmp %g1, %o0 40006a5c: 08 80 00 1e bleu 40006ad4 <_Scheduler_CBS_Set_parameters+0x84> 40006a60: 01 00 00 00 nop return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( params->budget <= 0 || 40006a64: c2 02 60 08 ld [ %o1 + 8 ], %g1 40006a68: 80 a0 60 00 cmp %g1, 0 40006a6c: 04 80 00 14 ble 40006abc <_Scheduler_CBS_Set_parameters+0x6c> <== ALWAYS TAKEN 40006a70: 01 00 00 00 nop 40006a74: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED 40006a78: 80 a0 60 00 cmp %g1, 0 40006a7c: 04 80 00 1a ble 40006ae4 <_Scheduler_CBS_Set_parameters+0x94> <== ALWAYS TAKEN 40006a80: 01 00 00 00 nop params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id].initialized ) 40006a84: 91 2a 20 05 sll %o0, 5, %o0 <== NOT EXECUTED 40006a88: 03 10 00 5d sethi %hi(0x40017400), %g1 40006a8c: 82 10 61 78 or %g1, 0x178, %g1 ! 40017578 <_Scheduler_CBS_Server_list> 40006a90: 82 00 40 08 add %g1, %o0, %g1 40006a94: c4 08 60 1c ldub [ %g1 + 0x1c ], %g2 40006a98: 80 a0 a0 00 cmp %g2, 0 40006a9c: 02 80 00 10 be 40006adc <_Scheduler_CBS_Set_parameters+0x8c> 40006aa0: 01 00 00 00 nop return SCHEDULER_CBS_ERROR_NOSERVER; _Scheduler_CBS_Server_list[server_id].parameters = *params; 40006aa4: c4 1a 40 00 ldd [ %o1 ], %g2 40006aa8: c4 38 60 08 std %g2, [ %g1 + 8 ] return SCHEDULER_CBS_OK; 40006aac: 90 10 20 00 clr %o0 _Scheduler_CBS_Server_list[server_id].parameters = *params; 40006ab0: c4 1a 60 08 ldd [ %o1 + 8 ], %g2 return SCHEDULER_CBS_OK; 40006ab4: 81 c3 e0 08 retl 40006ab8: c4 38 60 10 std %g2, [ %g1 + 0x10 ] if ( params->budget <= 0 || 40006abc: 12 80 00 06 bne 40006ad4 <_Scheduler_CBS_Set_parameters+0x84> 40006ac0: 01 00 00 00 nop 40006ac4: c2 02 60 0c ld [ %o1 + 0xc ], %g1 40006ac8: 80 a0 60 00 cmp %g1, 0 40006acc: 32 bf ff eb bne,a 40006a78 <_Scheduler_CBS_Set_parameters+0x28> <== ALWAYS TAKEN 40006ad0: c2 02 40 00 ld [ %o1 ], %g1 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 40006ad4: 81 c3 e0 08 retl 40006ad8: 90 10 3f ee mov -18, %o0 } 40006adc: 81 c3 e0 08 retl 40006ae0: 90 10 3f e7 mov -25, %o0 if ( params->budget <= 0 || 40006ae4: 12 bf ff fc bne 40006ad4 <_Scheduler_CBS_Set_parameters+0x84> 40006ae8: 01 00 00 00 nop 40006aec: c2 02 60 04 ld [ %o1 + 4 ], %g1 40006af0: 80 a0 60 00 cmp %g1, 0 40006af4: 32 bf ff e5 bne,a 40006a88 <_Scheduler_CBS_Set_parameters+0x38> <== ALWAYS TAKEN 40006af8: 91 2a 20 05 sll %o0, 5, %o0 40006afc: 30 bf ff f6 b,a 40006ad4 <_Scheduler_CBS_Set_parameters+0x84> <== NOT EXECUTED =============================================================================== 40005d10 <_Scheduler_CBS_Unblock>: void _Scheduler_CBS_Unblock( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 40005d10: 9d e3 bf 78 save %sp, -136, %sp Scheduler_CBS_Node *the_node; Scheduler_CBS_Server *serv_info; Priority_Control priority; the_node = _Scheduler_CBS_Node_downcast( node ); serv_info = the_node->cbs_server; 40005d14: c2 06 a0 50 ld [ %i2 + 0x50 ], %g1 priority = _Scheduler_Node_get_priority( &the_node->Base.Base ); priority = SCHEDULER_PRIORITY_PURIFY( priority ); 40005d18: c8 06 a0 34 ld [ %i2 + 0x34 ], %g4 40005d1c: c4 06 a0 30 ld [ %i2 + 0x30 ], %g2 * Late unblock rule for deadline-driven tasks. The remaining time to * deadline must be sufficient to serve the remaining computation time * without increased utilization of this task. It might cause a deadline * miss of another task. */ if ( serv_info != NULL && ( priority & SCHEDULER_EDF_PRIO_MSB ) == 0 ) { 40005d20: 80 a0 60 00 cmp %g1, 0 40005d24: 02 80 00 1c be 40005d94 <_Scheduler_CBS_Unblock+0x84> 40005d28: 86 09 3f fe and %g4, -2, %g3 40005d2c: 80 a0 a0 00 cmp %g2, 0 40005d30: 06 80 00 19 bl 40005d94 <_Scheduler_CBS_Unblock+0x84> 40005d34: 09 10 00 5a sethi %hi(0x40016800), %g4 time_t deadline = serv_info->parameters.deadline; time_t budget = serv_info->parameters.budget; uint32_t deadline_left = the_thread->cpu_time_budget; Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot; if ( deadline * budget_left > budget * deadline_left ) { 40005d38: fa 00 60 08 ld [ %g1 + 8 ], %i5 Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot; 40005d3c: c8 01 21 20 ld [ %g4 + 0x120 ], %g4 40005d40: 9a a0 c0 04 subcc %g3, %g4, %o5 if ( deadline * budget_left > budget * deadline_left ) { 40005d44: f6 06 60 8c ld [ %i1 + 0x8c ], %i3 Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot; 40005d48: 98 60 a0 00 subx %g2, 0, %o4 if ( deadline * budget_left > budget * deadline_left ) { 40005d4c: f8 00 60 14 ld [ %g1 + 0x14 ], %i4 40005d50: c4 00 60 0c ld [ %g1 + 0xc ], %g2 40005d54: ba 5f 40 0d smul %i5, %o5, %i5 40005d58: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 40005d5c: 88 58 80 0c smul %g2, %o4, %g4 40005d60: 82 58 40 1b smul %g1, %i3, %g1 40005d64: 88 01 00 1d add %g4, %i5, %g4 40005d68: 86 50 80 0d umul %g2, %o5, %g3 40005d6c: 85 40 00 00 rd %y, %g2 40005d70: ba 57 00 1b umul %i4, %i3, %i5 40005d74: b9 40 00 00 rd %y, %i4 40005d78: 84 01 00 02 add %g4, %g2, %g2 40005d7c: b8 00 40 1c add %g1, %i4, %i4 40005d80: 80 a0 80 1c cmp %g2, %i4 40005d84: 38 80 00 09 bgu,a 40005da8 <_Scheduler_CBS_Unblock+0x98> <== NEVER TAKEN 40005d88: d4 06 a0 54 ld [ %i2 + 0x54 ], %o2 <== NOT EXECUTED 40005d8c: 02 80 00 04 be 40005d9c <_Scheduler_CBS_Unblock+0x8c> <== ALWAYS TAKEN 40005d90: 80 a0 c0 1d cmp %g3, %i5 &queue_context ); } } _Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base ); 40005d94: 40 00 01 17 call 400061f0 <_Scheduler_EDF_Unblock> 40005d98: 81 e8 00 00 restore if ( deadline * budget_left > budget * deadline_left ) { 40005d9c: 08 bf ff fe bleu 40005d94 <_Scheduler_CBS_Unblock+0x84> <== NEVER TAKEN 40005da0: 01 00 00 00 nop _Scheduler_CBS_Cancel_job( 40005da4: d4 06 a0 54 ld [ %i2 + 0x54 ], %o2 */ RTEMS_INLINE_ROUTINE void _Thread_queue_Context_clear_priority_updates( Thread_queue_Context *queue_context ) { queue_context->Priority.update_count = 0; 40005da8: c0 27 bf f0 clr [ %fp + -16 ] 40005dac: 96 07 bf dc add %fp, -36, %o3 40005db0: 92 10 00 19 mov %i1, %o1 40005db4: 7f ff ff cc call 40005ce4 <_Scheduler_CBS_Cancel_job> 40005db8: 90 10 00 18 mov %i0, %o0 _Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base ); 40005dbc: 40 00 01 0d call 400061f0 <_Scheduler_EDF_Unblock> 40005dc0: 81 e8 00 00 restore =============================================================================== 40005e9c <_Scheduler_EDF_Block>: void _Scheduler_EDF_Block( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 40005e9c: 9d e3 bf a0 save %sp, -96, %sp RTEMS_INLINE_ROUTINE void _Scheduler_EDF_Extract( Scheduler_EDF_Context *context, Scheduler_EDF_Node *node ) { _RBTree_Extract( &context->Ready, &node->Node ); 40005ea0: d0 06 00 00 ld [ %i0 ], %o0 40005ea4: 40 00 11 f9 call 4000a688 <_RBTree_Extract> 40005ea8: 92 06 a0 38 add %i2, 0x38, %o1 { ( *extract )( scheduler, the_thread, node ); /* TODO: flash critical section? */ if ( _Thread_Is_executing( the_thread ) || _Thread_Is_heir( the_thread ) ) { 40005eac: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2 40005eb0: 80 a6 40 02 cmp %i1, %g2 40005eb4: 02 80 00 08 be 40005ed4 <_Scheduler_EDF_Block+0x38> 40005eb8: 01 00 00 00 nop 40005ebc: c2 01 a0 24 ld [ %g6 + 0x24 ], %g1 40005ec0: 80 a6 40 01 cmp %i1, %g1 40005ec4: 02 80 00 04 be 40005ed4 <_Scheduler_EDF_Block+0x38> <== NEVER TAKEN 40005ec8: 01 00 00 00 nop the_thread, node, _Scheduler_EDF_Extract_body, _Scheduler_EDF_Schedule_body ); } 40005ecc: 81 c7 e0 08 ret 40005ed0: 81 e8 00 00 restore Scheduler_EDF_Node *node; (void) the_thread; context = _Scheduler_EDF_Get_context( scheduler ); first = _RBTree_Minimum( &context->Ready ); 40005ed4: 40 00 13 ea call 4000ae7c <_RBTree_Minimum> 40005ed8: d0 06 00 00 ld [ %i0 ], %o0 node = RTEMS_CONTAINER_OF( first, Scheduler_EDF_Node, Node ); _Scheduler_Update_heir( node->Base.owner, force_dispatch ); 40005edc: f6 02 3f c8 ld [ %o0 + -56 ], %i3 RTEMS_INLINE_ROUTINE void _Scheduler_Update_heir( Thread_Control *new_heir, bool force_dispatch ) { Thread_Control *heir = _Thread_Heir; 40005ee0: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40005ee4: 80 a6 c0 1d cmp %i3, %i5 40005ee8: 02 bf ff f9 be 40005ecc <_Scheduler_EDF_Block+0x30> <== NEVER TAKEN 40005eec: b8 10 00 06 mov %g6, %i4 *time = _Timecounter_Sbinuptime(); 40005ef0: 7f ff fe 3c call 400057e0 <_Timecounter_Sbinuptime> 40005ef4: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 40005ef8: 84 10 00 08 mov %o0, %g2 40005efc: 86 10 00 09 mov %o1, %g3 40005f00: c4 3f 20 28 std %g2, [ %i4 + 0x28 ] const Timestamp_Control *_start, const Timestamp_Control *_end, Timestamp_Control *_result ) { *_result = *_end - *_start; 40005f04: b2 a2 40 11 subcc %o1, %l1, %i1 *_time += *_add; 40005f08: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4 *_result = *_end - *_start; 40005f0c: b0 60 80 10 subx %g2, %l0, %i0 *_time += *_add; 40005f10: 86 83 40 19 addcc %o5, %i1, %g3 40005f14: 84 43 00 18 addx %o4, %i0, %g2 40005f18: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] heir->Scheduler.state = THREAD_SCHEDULER_BLOCKED; new_heir->Scheduler.state = THREAD_SCHEDULER_SCHEDULED; #endif _Thread_Update_CPU_time_used( heir, _Thread_Get_CPU( heir ) ); _Thread_Heir = new_heir; _Thread_Dispatch_necessary = true; 40005f1c: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 40005f20: f6 21 a0 24 st %i3, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 40005f24: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] 40005f28: 81 c7 e0 08 ret 40005f2c: 81 e8 00 00 restore =============================================================================== 40006178 <_Scheduler_EDF_Schedule>: void _Scheduler_EDF_Schedule( const Scheduler_Control *scheduler, Thread_Control *the_thread ) { 40006178: 9d e3 bf a0 save %sp, -96, %sp first = _RBTree_Minimum( &context->Ready ); 4000617c: 40 00 13 40 call 4000ae7c <_RBTree_Minimum> 40006180: d0 06 00 00 ld [ %i0 ], %o0 _Scheduler_Update_heir( node->Base.owner, force_dispatch ); 40006184: f6 02 3f c8 ld [ %o0 + -56 ], %i3 Thread_Control *heir = _Thread_Heir; 40006188: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000618c: 80 a6 c0 1d cmp %i3, %i5 40006190: 02 80 00 06 be 400061a8 <_Scheduler_EDF_Schedule+0x30> <== ALWAYS TAKEN 40006194: b8 10 00 06 mov %g6, %i4 40006198: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1 <== NOT EXECUTED 4000619c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400061a0: 12 80 00 04 bne 400061b0 <_Scheduler_EDF_Schedule+0x38> <== NOT EXECUTED 400061a4: 01 00 00 00 nop <== NOT EXECUTED _Scheduler_EDF_Schedule_body( scheduler, the_thread, false ); } 400061a8: 81 c7 e0 08 ret 400061ac: 81 e8 00 00 restore 400061b0: 7f ff fd 8c call 400057e0 <_Timecounter_Sbinuptime> <== NOT EXECUTED 400061b4: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 <== NOT EXECUTED 400061b8: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED 400061bc: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED 400061c0: c4 3f 20 28 std %g2, [ %i4 + 0x28 ] <== NOT EXECUTED *_result = *_end - *_start; 400061c4: b2 a2 40 11 subcc %o1, %l1, %i1 <== NOT EXECUTED *_time += *_add; 400061c8: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4 <== NOT EXECUTED *_result = *_end - *_start; 400061cc: b0 60 80 10 subx %g2, %l0, %i0 <== NOT EXECUTED *_time += *_add; 400061d0: 86 83 40 19 addcc %o5, %i1, %g3 <== NOT EXECUTED 400061d4: 84 43 00 18 addx %o4, %i0, %g2 <== NOT EXECUTED 400061d8: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 400061dc: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = new_heir; 400061e0: f6 21 a0 24 st %i3, [ %g6 + 0x24 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 400061e4: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] <== NOT EXECUTED 400061e8: 81 c7 e0 08 ret <== NOT EXECUTED 400061ec: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 400061f0 <_Scheduler_EDF_Unblock>: void _Scheduler_EDF_Unblock( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 400061f0: 9d e3 bf a0 save %sp, -96, %sp Priority_Control insert_priority; context = _Scheduler_EDF_Get_context( scheduler ); the_node = _Scheduler_EDF_Node_downcast( node ); priority = _Scheduler_Node_get_priority( &the_node->Base ); priority = SCHEDULER_PRIORITY_PURIFY( priority ); 400061f4: c8 06 a0 34 ld [ %i2 + 0x34 ], %g4 400061f8: fa 06 a0 30 ld [ %i2 + 0x30 ], %i5 return scheduler->context; 400061fc: d0 06 00 00 ld [ %i0 ], %o0 40006200: b6 09 3f fe and %g4, -2, %i3 insert_priority = SCHEDULER_PRIORITY_APPEND( priority ); the_node->priority = priority; 40006204: fa 26 a0 48 st %i5, [ %i2 + 0x48 ] insert_priority = SCHEDULER_PRIORITY_APPEND( priority ); 40006208: 88 11 20 01 or %g4, 1, %g4 the_node->priority = priority; 4000620c: f6 26 a0 4c st %i3, [ %i2 + 0x4c ] while ( *link != NULL ) { 40006210: c2 02 00 00 ld [ %o0 ], %g1 40006214: 80 a0 60 00 cmp %g1, 0 40006218: 02 80 00 49 be 4000633c <_Scheduler_EDF_Unblock+0x14c> 4000621c: 92 06 a0 38 add %i2, 0x38, %o1 if ( ( *less )( key, parent ) ) { 40006220: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 40006224: 80 a0 80 1d cmp %g2, %i5 40006228: 2a 80 00 13 bcs,a 40006274 <_Scheduler_EDF_Unblock+0x84> <== NEVER TAKEN 4000622c: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED 40006230: 12 80 00 07 bne 4000624c <_Scheduler_EDF_Unblock+0x5c> 40006234: 86 10 00 01 mov %g1, %g3 40006238: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 4000623c: 80 a0 80 04 cmp %g2, %g4 40006240: 2a 80 00 0d bcs,a 40006274 <_Scheduler_EDF_Unblock+0x84> 40006244: c4 00 60 04 ld [ %g1 + 4 ], %g2 return &RB_LEFT( the_node, Node ); 40006248: 86 10 00 01 mov %g1, %g3 while ( *link != NULL ) { 4000624c: c4 00 c0 00 ld [ %g3 ], %g2 40006250: 80 a0 a0 00 cmp %g2, 0 40006254: 22 80 00 0c be,a 40006284 <_Scheduler_EDF_Unblock+0x94> 40006258: c2 26 a0 40 st %g1, [ %i2 + 0x40 ] 4000625c: 82 10 00 02 mov %g2, %g1 if ( ( *less )( key, parent ) ) { 40006260: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 40006264: 80 a0 80 1d cmp %g2, %i5 40006268: 1a bf ff f2 bcc 40006230 <_Scheduler_EDF_Unblock+0x40> 4000626c: 01 00 00 00 nop while ( *link != NULL ) { 40006270: c4 00 60 04 ld [ %g1 + 4 ], %g2 40006274: 80 a0 a0 00 cmp %g2, 0 40006278: 12 bf ff f9 bne 4000625c <_Scheduler_EDF_Unblock+0x6c> 4000627c: 86 00 60 04 add %g1, 4, %g3 RB_SET( child, parent, Node ); 40006280: c2 26 a0 40 st %g1, [ %i2 + 0x40 ] 40006284: 82 10 20 01 mov 1, %g1 40006288: c0 26 a0 3c clr [ %i2 + 0x3c ] 4000628c: c2 26 a0 44 st %g1, [ %i2 + 0x44 ] 40006290: c0 26 a0 38 clr [ %i2 + 0x38 ] _RBTree_Insert_color( the_rbtree, the_node ); 40006294: 40 00 12 65 call 4000ac28 <_RBTree_Insert_color> 40006298: d2 20 c0 00 st %o1, [ %g3 ] * 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 ) ) { 4000629c: f8 01 a0 24 ld [ %g6 + 0x24 ], %i4 */ RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_priority( const Priority_Aggregation *aggregation ) { return aggregation->Node.priority; 400062a0: c2 07 20 38 ld [ %i4 + 0x38 ], %g1 400062a4: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 400062a8: 80 a0 80 1d cmp %g2, %i5 400062ac: 18 80 00 09 bgu 400062d0 <_Scheduler_EDF_Unblock+0xe0> 400062b0: b4 10 00 06 mov %g6, %i2 400062b4: 22 80 00 04 be,a 400062c4 <_Scheduler_EDF_Unblock+0xd4> 400062b8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 _Scheduler_Update_heir( the_thread, priority == ( SCHEDULER_EDF_PRIO_MSB | PRIORITY_PSEUDO_ISR ) ); } } 400062bc: 81 c7 e0 08 ret 400062c0: 81 e8 00 00 restore if ( priority < _Thread_Get_priority( _Thread_Heir ) ) { 400062c4: 80 a0 40 1b cmp %g1, %i3 400062c8: 08 80 00 1b bleu 40006334 <_Scheduler_EDF_Unblock+0x144> 400062cc: 01 00 00 00 nop if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 400062d0: 80 a7 00 19 cmp %i4, %i1 400062d4: 02 bf ff fa be 400062bc <_Scheduler_EDF_Unblock+0xcc> <== NEVER TAKEN 400062d8: 03 20 00 00 sethi %hi(0x80000000), %g1 _Scheduler_Update_heir( 400062dc: ba 1f 40 01 xor %i5, %g1, %i5 400062e0: 80 97 40 1b orcc %i5, %i3, %g0 400062e4: 02 80 00 06 be 400062fc <_Scheduler_EDF_Unblock+0x10c> <== NEVER TAKEN 400062e8: 01 00 00 00 nop 400062ec: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1 400062f0: 80 a0 60 00 cmp %g1, 0 400062f4: 02 80 00 10 be 40006334 <_Scheduler_EDF_Unblock+0x144> 400062f8: 01 00 00 00 nop 400062fc: 7f ff fd 39 call 400057e0 <_Timecounter_Sbinuptime> 40006300: e0 1e a0 28 ldd [ %i2 + 0x28 ], %l0 40006304: 84 10 00 08 mov %o0, %g2 40006308: 86 10 00 09 mov %o1, %g3 4000630c: c4 3e a0 28 std %g2, [ %i2 + 0x28 ] *_result = *_end - *_start; 40006310: b6 a2 40 11 subcc %o1, %l1, %i3 *_time += *_add; 40006314: d8 1f 20 98 ldd [ %i4 + 0x98 ], %o4 *_result = *_end - *_start; 40006318: b4 60 80 10 subx %g2, %l0, %i2 *_time += *_add; 4000631c: 86 83 40 1b addcc %o5, %i3, %g3 40006320: 84 43 00 1a addx %o4, %i2, %g2 40006324: c4 3f 20 98 std %g2, [ %i4 + 0x98 ] _Thread_Dispatch_necessary = true; 40006328: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 4000632c: f2 21 a0 24 st %i1, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 40006330: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] } 40006334: 81 c7 e0 08 ret 40006338: 81 e8 00 00 restore link = _RBTree_Root_reference( the_rbtree ); 4000633c: 10 bf ff d1 b 40006280 <_Scheduler_EDF_Unblock+0x90> 40006340: 86 10 00 08 mov %o0, %g3 =============================================================================== 400060d8 <_Scheduler_EDF_Unmap_priority>: Priority_Control _Scheduler_EDF_Unmap_priority( const Scheduler_Control *scheduler, Priority_Control priority ) { return SCHEDULER_PRIORITY_UNMAP( priority & ~SCHEDULER_EDF_PRIO_MSB ); 400060d8: 95 32 a0 01 srl %o2, 1, %o2 <== NOT EXECUTED 400060dc: 83 2a 60 1f sll %o1, 0x1f, %g1 <== NOT EXECUTED 400060e0: 91 2a 60 01 sll %o1, 1, %o0 <== NOT EXECUTED } 400060e4: 92 10 40 0a or %g1, %o2, %o1 <== NOT EXECUTED 400060e8: 81 c3 e0 08 retl <== NOT EXECUTED 400060ec: 91 32 20 02 srl %o0, 2, %o0 <== NOT EXECUTED =============================================================================== 40005f3c <_Scheduler_EDF_Update_priority>: void _Scheduler_EDF_Update_priority( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 40005f3c: 9d e3 bf 98 save %sp, -104, %sp Scheduler_EDF_Context *context; Scheduler_EDF_Node *the_node; Priority_Control priority; Priority_Control insert_priority; if ( !_Thread_Is_ready( the_thread ) ) { 40005f40: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 40005f44: 80 a0 60 00 cmp %g1, 0 40005f48: 12 80 00 53 bne 40006094 <_Scheduler_EDF_Update_priority+0x158> 40005f4c: 01 00 00 00 nop do { seq = _SMP_sequence_lock_Read_begin( &node->Priority.Lock ); #endif priority = node->Priority.value; 40005f50: fa 06 a0 30 ld [ %i2 + 0x30 ], %i5 40005f54: f8 06 a0 34 ld [ %i2 + 0x34 ], %i4 the_node = _Scheduler_EDF_Node_downcast( node ); insert_priority = _Scheduler_Node_get_priority( &the_node->Base ); priority = SCHEDULER_PRIORITY_PURIFY( insert_priority ); if ( priority == the_node->priority ) { 40005f58: c4 06 a0 48 ld [ %i2 + 0x48 ], %g2 40005f5c: 80 a0 80 1d cmp %g2, %i5 40005f60: 02 80 00 3a be 40006048 <_Scheduler_EDF_Update_priority+0x10c> 40005f64: 82 0f 3f fe and %i4, -2, %g1 /* Nothing to do */ return; } the_node->priority = priority; 40005f68: c2 26 a0 4c st %g1, [ %i2 + 0x4c ] _RBTree_Extract( &context->Ready, &node->Node ); 40005f6c: 92 06 a0 38 add %i2, 0x38, %o1 40005f70: fa 26 a0 48 st %i5, [ %i2 + 0x48 ] return scheduler->context; 40005f74: f6 06 00 00 ld [ %i0 ], %i3 40005f78: d2 27 bf fc st %o1, [ %fp + -4 ] 40005f7c: 40 00 11 c3 call 4000a688 <_RBTree_Extract> 40005f80: 90 10 00 1b mov %i3, %o0 link = _RBTree_Root_reference( the_rbtree ); parent = NULL; is_new_minimum = true; while ( *link != NULL ) { 40005f84: c2 06 c0 00 ld [ %i3 ], %g1 40005f88: 80 a0 60 00 cmp %g1, 0 40005f8c: 02 80 00 44 be 4000609c <_Scheduler_EDF_Update_priority+0x160> <== NEVER TAKEN 40005f90: d2 07 bf fc ld [ %fp + -4 ], %o1 parent = *link; if ( ( *less )( key, parent ) ) { 40005f94: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 40005f98: 80 a0 80 1d cmp %g2, %i5 40005f9c: 2a 80 00 13 bcs,a 40005fe8 <_Scheduler_EDF_Update_priority+0xac> 40005fa0: c4 00 60 04 ld [ %g1 + 4 ], %g2 40005fa4: 12 80 00 07 bne 40005fc0 <_Scheduler_EDF_Update_priority+0x84> 40005fa8: 86 10 00 01 mov %g1, %g3 40005fac: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 40005fb0: 80 a0 80 1c cmp %g2, %i4 40005fb4: 2a 80 00 0d bcs,a 40005fe8 <_Scheduler_EDF_Update_priority+0xac> 40005fb8: c4 00 60 04 ld [ %g1 + 4 ], %g2 return &RB_LEFT( the_node, Node ); 40005fbc: 86 10 00 01 mov %g1, %g3 while ( *link != NULL ) { 40005fc0: c4 00 c0 00 ld [ %g3 ], %g2 40005fc4: 80 a0 a0 00 cmp %g2, 0 40005fc8: 22 80 00 0c be,a 40005ff8 <_Scheduler_EDF_Update_priority+0xbc> 40005fcc: c2 26 a0 40 st %g1, [ %i2 + 0x40 ] 40005fd0: 82 10 00 02 mov %g2, %g1 if ( ( *less )( key, parent ) ) { 40005fd4: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 40005fd8: 80 a0 80 1d cmp %g2, %i5 40005fdc: 1a bf ff f2 bcc 40005fa4 <_Scheduler_EDF_Update_priority+0x68> <== ALWAYS TAKEN 40005fe0: 01 00 00 00 nop while ( *link != NULL ) { 40005fe4: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED 40005fe8: 80 a0 a0 00 cmp %g2, 0 40005fec: 12 bf ff f9 bne 40005fd0 <_Scheduler_EDF_Update_priority+0x94> <== ALWAYS TAKEN 40005ff0: 86 00 60 04 add %g1, 4, %g3 RB_SET( child, parent, Node ); 40005ff4: c2 26 a0 40 st %g1, [ %i2 + 0x40 ] <== NOT EXECUTED 40005ff8: b2 10 20 01 mov 1, %i1 40005ffc: c0 26 a0 3c clr [ %i2 + 0x3c ] is_new_minimum = false; } } _RBTree_Add_child( the_node, parent, link ); _RBTree_Insert_color( the_rbtree, the_node ); 40006000: 90 10 00 1b mov %i3, %o0 RB_SET( child, parent, Node ); 40006004: c0 26 a0 38 clr [ %i2 + 0x38 ] 40006008: f2 26 a0 44 st %i1, [ %i2 + 0x44 ] _RBTree_Insert_color( the_rbtree, the_node ); 4000600c: 40 00 13 07 call 4000ac28 <_RBTree_Insert_color> 40006010: d2 20 c0 00 st %o1, [ %g3 ] first = _RBTree_Minimum( &context->Ready ); 40006014: 40 00 13 9a call 4000ae7c <_RBTree_Minimum> 40006018: d0 06 00 00 ld [ %i0 ], %o0 _Scheduler_Update_heir( node->Base.owner, force_dispatch ); 4000601c: f6 02 3f c8 ld [ %o0 + -56 ], %i3 Thread_Control *heir = _Thread_Heir; 40006020: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40006024: 80 a6 c0 1d cmp %i3, %i5 40006028: 02 80 00 06 be 40006040 <_Scheduler_EDF_Update_priority+0x104> 4000602c: b8 10 00 06 mov %g6, %i4 40006030: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1 40006034: 80 a0 60 00 cmp %g1, 0 40006038: 12 80 00 0a bne 40006060 <_Scheduler_EDF_Update_priority+0x124> <== ALWAYS TAKEN 4000603c: 01 00 00 00 nop context = _Scheduler_EDF_Get_context( scheduler ); _Scheduler_EDF_Extract( context, the_node ); _Scheduler_EDF_Enqueue( context, the_node, insert_priority ); _Scheduler_EDF_Schedule_body( scheduler, the_thread, false ); } 40006040: 81 c7 e0 08 ret 40006044: 81 e8 00 00 restore if ( priority == the_node->priority ) { 40006048: c4 06 a0 4c ld [ %i2 + 0x4c ], %g2 4000604c: 80 a0 80 01 cmp %g2, %g1 40006050: 32 bf ff c7 bne,a 40005f6c <_Scheduler_EDF_Update_priority+0x30> <== ALWAYS TAKEN 40006054: c2 26 a0 4c st %g1, [ %i2 + 0x4c ] } 40006058: 81 c7 e0 08 ret <== NOT EXECUTED 4000605c: 81 e8 00 00 restore <== NOT EXECUTED 40006060: 7f ff fd e0 call 400057e0 <_Timecounter_Sbinuptime> 40006064: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 40006068: 84 10 00 08 mov %o0, %g2 4000606c: 86 10 00 09 mov %o1, %g3 40006070: c4 3f 20 28 std %g2, [ %i4 + 0x28 ] *_result = *_end - *_start; 40006074: 96 a2 40 11 subcc %o1, %l1, %o3 *_time += *_add; 40006078: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4 *_result = *_end - *_start; 4000607c: 94 60 80 10 subx %g2, %l0, %o2 *_time += *_add; 40006080: 86 83 40 0b addcc %o5, %o3, %g3 40006084: 84 43 00 0a addx %o4, %o2, %g2 40006088: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] _Thread_Heir = new_heir; 4000608c: f6 21 a0 24 st %i3, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 40006090: f2 29 a0 1c stb %i1, [ %g6 + 0x1c ] 40006094: 81 c7 e0 08 ret 40006098: 81 e8 00 00 restore link = _RBTree_Root_reference( the_rbtree ); 4000609c: 10 bf ff d6 b 40005ff4 <_Scheduler_EDF_Update_priority+0xb8> <== NOT EXECUTED 400060a0: 86 10 00 1b mov %i3, %g3 <== NOT EXECUTED =============================================================================== 40006344 <_Scheduler_EDF_Yield>: void _Scheduler_EDF_Yield( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 40006344: 9d e3 bf 98 save %sp, -104, %sp return scheduler->context; 40006348: fa 06 00 00 ld [ %i0 ], %i5 _RBTree_Extract( &context->Ready, &node->Node ); 4000634c: 92 06 a0 38 add %i2, 0x38, %o1 40006350: 90 10 00 1d mov %i5, %o0 40006354: 40 00 10 cd call 4000a688 <_RBTree_Extract> 40006358: d2 27 bf fc st %o1, [ %fp + -4 ] while ( *link != NULL ) { 4000635c: c2 07 40 00 ld [ %i5 ], %g1 context = _Scheduler_EDF_Get_context( scheduler ); the_node = _Scheduler_EDF_Node_downcast( node ); _Scheduler_EDF_Extract( context, the_node ); _Scheduler_EDF_Enqueue( context, the_node, the_node->priority ); 40006360: c8 06 a0 48 ld [ %i2 + 0x48 ], %g4 40006364: f8 06 a0 4c ld [ %i2 + 0x4c ], %i4 40006368: 80 a0 60 00 cmp %g1, 0 4000636c: 02 80 00 38 be 4000644c <_Scheduler_EDF_Yield+0x108> <== NEVER TAKEN 40006370: d2 07 bf fc ld [ %fp + -4 ], %o1 if ( ( *less )( key, parent ) ) { 40006374: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 40006378: 80 a0 80 04 cmp %g2, %g4 4000637c: 2a 80 00 13 bcs,a 400063c8 <_Scheduler_EDF_Yield+0x84> <== NEVER TAKEN 40006380: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED 40006384: 12 80 00 07 bne 400063a0 <_Scheduler_EDF_Yield+0x5c> <== NEVER TAKEN 40006388: 86 10 00 01 mov %g1, %g3 4000638c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 40006390: 80 a0 80 1c cmp %g2, %i4 40006394: 2a 80 00 0d bcs,a 400063c8 <_Scheduler_EDF_Yield+0x84> 40006398: c4 00 60 04 ld [ %g1 + 4 ], %g2 return &RB_LEFT( the_node, Node ); 4000639c: 86 10 00 01 mov %g1, %g3 while ( *link != NULL ) { 400063a0: c4 00 c0 00 ld [ %g3 ], %g2 400063a4: 80 a0 a0 00 cmp %g2, 0 400063a8: 22 80 00 0c be,a 400063d8 <_Scheduler_EDF_Yield+0x94> <== NEVER TAKEN 400063ac: c2 26 a0 40 st %g1, [ %i2 + 0x40 ] <== NOT EXECUTED 400063b0: 82 10 00 02 mov %g2, %g1 if ( ( *less )( key, parent ) ) { 400063b4: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 400063b8: 80 a0 80 04 cmp %g2, %g4 400063bc: 1a bf ff f2 bcc 40006384 <_Scheduler_EDF_Yield+0x40> <== ALWAYS TAKEN 400063c0: 01 00 00 00 nop while ( *link != NULL ) { 400063c4: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED 400063c8: 80 a0 a0 00 cmp %g2, 0 400063cc: 12 bf ff f9 bne 400063b0 <_Scheduler_EDF_Yield+0x6c> 400063d0: 86 00 60 04 add %g1, 4, %g3 RB_SET( child, parent, Node ); 400063d4: c2 26 a0 40 st %g1, [ %i2 + 0x40 ] 400063d8: b6 10 20 01 mov 1, %i3 400063dc: c0 26 a0 3c clr [ %i2 + 0x3c ] _RBTree_Insert_color( the_rbtree, the_node ); 400063e0: 90 10 00 1d mov %i5, %o0 RB_SET( child, parent, Node ); 400063e4: c0 26 a0 38 clr [ %i2 + 0x38 ] 400063e8: f6 26 a0 44 st %i3, [ %i2 + 0x44 ] _RBTree_Insert_color( the_rbtree, the_node ); 400063ec: 40 00 12 0f call 4000ac28 <_RBTree_Insert_color> 400063f0: d2 20 c0 00 st %o1, [ %g3 ] first = _RBTree_Minimum( &context->Ready ); 400063f4: 40 00 12 a2 call 4000ae7c <_RBTree_Minimum> 400063f8: d0 06 00 00 ld [ %i0 ], %o0 _Scheduler_Update_heir( node->Base.owner, force_dispatch ); 400063fc: f4 02 3f c8 ld [ %o0 + -56 ], %i2 Thread_Control *heir = _Thread_Heir; 40006400: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40006404: 80 a6 80 1d cmp %i2, %i5 40006408: 02 80 00 0f be 40006444 <_Scheduler_EDF_Yield+0x100> <== NEVER TAKEN 4000640c: b8 10 00 06 mov %g6, %i4 40006410: 7f ff fc f4 call 400057e0 <_Timecounter_Sbinuptime> 40006414: f0 19 a0 28 ldd [ %g6 + 0x28 ], %i0 40006418: 84 10 00 08 mov %o0, %g2 4000641c: 86 10 00 09 mov %o1, %g3 40006420: c4 3f 20 28 std %g2, [ %i4 + 0x28 ] *_result = *_end - *_start; 40006424: 9a a2 40 19 subcc %o1, %i1, %o5 40006428: 98 60 80 18 subx %g2, %i0, %o4 *_time += *_add; 4000642c: f0 1f 60 98 ldd [ %i5 + 0x98 ], %i0 40006430: 86 86 40 0d addcc %i1, %o5, %g3 40006434: 84 46 00 0c addx %i0, %o4, %g2 40006438: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] _Thread_Heir = new_heir; 4000643c: f4 21 a0 24 st %i2, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 40006440: f6 29 a0 1c stb %i3, [ %g6 + 0x1c ] _Scheduler_EDF_Schedule_body( scheduler, the_thread, true ); } 40006444: 81 c7 e0 08 ret 40006448: 81 e8 00 00 restore link = _RBTree_Root_reference( the_rbtree ); 4000644c: 10 bf ff e2 b 400063d4 <_Scheduler_EDF_Yield+0x90> <== NOT EXECUTED 40006450: 86 10 00 1d mov %i5, %g3 <== NOT EXECUTED =============================================================================== 40008424 <_Scheduler_Set_affinity>: bool _Scheduler_Set_affinity( Thread_Control *the_thread, size_t cpusetsize, const cpu_set_t *cpuset ) { 40008424: 9d e3 bf 98 save %sp, -104, %sp Processor_mask *dst, size_t src_size, const cpu_set_t *src ) { return _Processor_mask_Copy( 40008428: 92 10 20 04 mov 4, %o1 4000842c: 96 10 00 19 mov %i1, %o3 40008430: 94 10 00 1a mov %i2, %o2 40008434: 90 07 bf fc add %fp, -4, %o0 40008438: 40 00 12 c0 call 4000cf38 <_Processor_mask_Copy> 4000843c: b0 10 20 00 clr %i0 Scheduler_Node *node; ISR_lock_Context lock_context; bool ok; status = _Processor_mask_From_cpu_set_t( &affinity, cpusetsize, cpuset ); if ( !_Processor_mask_Is_at_most_partial_loss( status ) ) { 40008440: 80 a2 20 01 cmp %o0, 1 40008444: 18 80 00 07 bgu 40008460 <_Scheduler_Set_affinity+0x3c> <== NEVER TAKEN 40008448: 03 10 02 68 sethi %hi(0x4009a000), %g1 BIT_AND2( CPU_MAXIMUM_PROCESSORS, a, b, c ); 4000844c: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 4009a1e0 <_Processor_mask_The_one_and_only> return BIT_SUBSET( CPU_MAXIMUM_PROCESSORS, big, small ); 40008450: c2 07 bf fc ld [ %fp + -4 ], %g1 40008454: 82 28 80 01 andn %g2, %g1, %g1 40008458: 80 a0 00 01 cmp %g0, %g1 4000845c: b0 60 3f ff subx %g0, -1, %i0 ); #endif _Scheduler_Release_critical( scheduler, &lock_context ); return ok; } 40008460: b0 0e 20 01 and %i0, 1, %i0 40008464: 81 c7 e0 08 ret 40008468: 81 e8 00 00 restore =============================================================================== 400050ac <_Scheduler_default_Tick>: void _Scheduler_default_Tick( const Scheduler_Control *scheduler, Thread_Control *executing ) { 400050ac: 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 ) 400050b0: c2 0e 60 89 ldub [ %i1 + 0x89 ], %g1 400050b4: 80 a0 60 00 cmp %g1, 0 400050b8: 02 80 00 26 be 40005150 <_Scheduler_default_Tick+0xa4> 400050bc: 01 00 00 00 nop return; if ( !_States_Is_ready( executing->current_state ) ) 400050c0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 400050c4: 80 a0 60 00 cmp %g1, 0 400050c8: 12 80 00 22 bne 40005150 <_Scheduler_default_Tick+0xa4> 400050cc: 01 00 00 00 nop /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 400050d0: c2 06 60 90 ld [ %i1 + 0x90 ], %g1 400050d4: 80 a0 60 02 cmp %g1, 2 400050d8: 18 80 00 07 bgu 400050f4 <_Scheduler_default_Tick+0x48> 400050dc: 80 a0 60 03 cmp %g1, 3 400050e0: 80 a0 60 00 cmp %g1, 0 400050e4: 32 80 00 10 bne,a 40005124 <_Scheduler_default_Tick+0x78> 400050e8: c2 06 60 8c ld [ %i1 + 0x8c ], %g1 if ( --executing->cpu_time_budget == 0 ) (*executing->budget_callout)( executing ); break; #endif } } 400050ec: 81 c7 e0 08 ret 400050f0: 81 e8 00 00 restore switch ( executing->budget_algorithm ) { 400050f4: 12 80 00 17 bne 40005150 <_Scheduler_default_Tick+0xa4> <== NEVER TAKEN 400050f8: 01 00 00 00 nop if ( --executing->cpu_time_budget == 0 ) 400050fc: c2 06 60 8c ld [ %i1 + 0x8c ], %g1 40005100: 82 00 7f ff add %g1, -1, %g1 40005104: 80 a0 60 00 cmp %g1, 0 40005108: 12 bf ff f9 bne 400050ec <_Scheduler_default_Tick+0x40> 4000510c: c2 26 60 8c st %g1, [ %i1 + 0x8c ] (*executing->budget_callout)( executing ); 40005110: c2 06 60 94 ld [ %i1 + 0x94 ], %g1 40005114: 9f c0 40 00 call %g1 40005118: 90 10 00 19 mov %i1, %o0 } 4000511c: 81 c7 e0 08 ret 40005120: 81 e8 00 00 restore if ( (int)(--executing->cpu_time_budget) <= 0 ) { 40005124: 82 00 7f ff add %g1, -1, %g1 40005128: 80 a0 60 00 cmp %g1, 0 4000512c: 14 bf ff f0 bg 400050ec <_Scheduler_default_Tick+0x40> 40005130: c2 26 60 8c st %g1, [ %i1 + 0x8c ] _Thread_Yield( executing ); 40005134: 40 00 04 14 call 40006184 <_Thread_Yield> 40005138: 90 10 00 19 mov %i1, %o0 executing->cpu_time_budget = 4000513c: 03 10 00 5f sethi %hi(0x40017c00), %g1 40005140: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 ! 40017dd0 <_Watchdog_Ticks_per_timeslice> 40005144: c2 26 60 8c st %g1, [ %i1 + 0x8c ] 40005148: 81 c7 e0 08 ret 4000514c: 81 e8 00 00 restore 40005150: 81 c7 e0 08 ret 40005154: 81 e8 00 00 restore =============================================================================== 4000554c <_Scheduler_priority_Schedule>: void _Scheduler_priority_Schedule( const Scheduler_Control *scheduler, Thread_Control *the_thread ) { 4000554c: 9d e3 bf a0 save %sp, -96, %sp _Scheduler_priority_Schedule_body( scheduler, the_thread, false ); 40005550: f8 06 00 00 ld [ %i0 ], %i4 bit_number = (unsigned int) __builtin_clz( value ) 40005554: 40 00 24 1d call 4000e5c8 <__clzsi2> 40005558: d0 17 00 00 lduh [ %i4 ], %o0 4000555c: ba 02 3f f0 add %o0, -16, %i5 minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 40005560: 83 2f 60 01 sll %i5, 1, %g1 40005564: 82 07 00 01 add %i4, %g1, %g1 bit_number = (unsigned int) __builtin_clz( value ) 40005568: 40 00 24 18 call 4000e5c8 <__clzsi2> 4000556c: d0 10 60 02 lduh [ %g1 + 2 ], %o0 return (_Priority_Bits_index( major ) << 4) + 40005570: bb 2f 60 04 sll %i5, 4, %i5 40005574: 90 02 00 1d add %o0, %i5, %o0 Thread_Control *heir = _Thread_Heir; 40005578: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 4000557c: 90 02 3f f0 add %o0, -16, %o0 return _Chain_Immutable_head( the_chain )->next; 40005580: 83 2a 20 01 sll %o0, 1, %g1 40005584: 90 00 40 08 add %g1, %o0, %o0 40005588: 91 2a 20 02 sll %o0, 2, %o0 4000558c: b8 07 00 08 add %i4, %o0, %i4 40005590: f8 07 20 24 ld [ %i4 + 0x24 ], %i4 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40005594: 80 a7 40 1c cmp %i5, %i4 40005598: 02 80 00 06 be 400055b0 <_Scheduler_priority_Schedule+0x64> 4000559c: b6 10 00 06 mov %g6, %i3 400055a0: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1 400055a4: 80 a0 60 00 cmp %g1, 0 400055a8: 12 80 00 04 bne 400055b8 <_Scheduler_priority_Schedule+0x6c> <== ALWAYS TAKEN 400055ac: 01 00 00 00 nop } 400055b0: 81 c7 e0 08 ret 400055b4: 81 e8 00 00 restore 400055b8: 7f ff fd a6 call 40004c50 <_Timecounter_Sbinuptime> 400055bc: f0 19 a0 28 ldd [ %g6 + 0x28 ], %i0 400055c0: 84 10 00 08 mov %o0, %g2 400055c4: 86 10 00 09 mov %o1, %g3 400055c8: c4 3e e0 28 std %g2, [ %i3 + 0x28 ] *_result = *_end - *_start; 400055cc: b6 a2 40 19 subcc %o1, %i1, %i3 400055d0: b4 60 80 18 subx %g2, %i0, %i2 *_time += *_add; 400055d4: f0 1f 60 98 ldd [ %i5 + 0x98 ], %i0 400055d8: 86 86 40 1b addcc %i1, %i3, %g3 400055dc: 84 46 00 1a addx %i0, %i2, %g2 400055e0: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] _Thread_Dispatch_necessary = true; 400055e4: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 400055e8: f8 21 a0 24 st %i4, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 400055ec: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] 400055f0: 81 c7 e0 08 ret 400055f4: 81 e8 00 00 restore =============================================================================== 400055f8 <_Scheduler_priority_Unblock>: void _Scheduler_priority_Unblock ( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 400055f8: 9d e3 bf a0 save %sp, -96, %sp do { seq = _SMP_sequence_lock_Read_begin( &node->Priority.Lock ); #endif priority = node->Priority.value; 400055fc: f8 06 a0 34 ld [ %i2 + 0x34 ], %i4 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 ) { 40005600: c2 06 a0 38 ld [ %i2 + 0x38 ], %g1 unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority ); 40005604: 89 37 20 01 srl %i4, 1, %g4 if ( unmapped_priority != the_node->Ready_queue.current_priority ) { 40005608: 80 a0 40 04 cmp %g1, %g4 4000560c: 12 80 00 38 bne 400056ec <_Scheduler_priority_Unblock+0xf4> 40005610: c6 06 00 00 ld [ %i0 ], %g3 Chain_Control *ready_chain = ready_queue->ready_chain; 40005614: c4 06 a0 3c ld [ %i2 + 0x3c ], %g2 *bit_map_info->minor |= bit_map_info->ready_minor; 40005618: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1 4000561c: f0 16 a0 46 lduh [ %i2 + 0x46 ], %i0 old_last = tail->previous; 40005620: c8 00 a0 08 ld [ %g2 + 8 ], %g4 return &the_chain->Tail.Node; 40005624: ba 00 a0 04 add %g2, 4, %i5 the_node->next = tail; 40005628: fa 26 40 00 st %i5, [ %i1 ] tail->previous = the_node; 4000562c: f2 20 a0 08 st %i1, [ %g2 + 8 ] old_last->next = the_node; 40005630: f2 21 00 00 st %i1, [ %g4 ] 40005634: c4 10 40 00 lduh [ %g1 ], %g2 the_node->previous = old_last; 40005638: c8 26 60 04 st %g4, [ %i1 + 4 ] 4000563c: 84 10 80 18 or %g2, %i0, %g2 40005640: 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 ) ) { 40005644: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 bit_map->major_bit_map |= bit_map_info->ready_major; 40005648: c2 10 c0 00 lduh [ %g3 ], %g1 4000564c: c8 16 a0 44 lduh [ %i2 + 0x44 ], %g4 */ RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_priority( const Priority_Aggregation *aggregation ) { return aggregation->Node.priority; 40005650: c4 07 60 38 ld [ %i5 + 0x38 ], %g2 40005654: 82 10 40 04 or %g1, %g4, %g1 40005658: c2 30 c0 00 sth %g1, [ %g3 ] 4000565c: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1 40005660: 80 a0 60 00 cmp %g1, 0 40005664: 18 80 00 09 bgu 40005688 <_Scheduler_priority_Unblock+0x90> <== NEVER TAKEN 40005668: b6 10 00 06 mov %g6, %i3 4000566c: 22 80 00 04 be,a 4000567c <_Scheduler_priority_Unblock+0x84> <== ALWAYS TAKEN 40005670: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 _Scheduler_Update_heir( the_thread, priority == PRIORITY_PSEUDO_ISR ); } } 40005674: 81 c7 e0 08 ret <== NOT EXECUTED 40005678: 81 e8 00 00 restore <== NOT EXECUTED if ( priority < _Thread_Get_priority( _Thread_Heir ) ) { 4000567c: 80 a0 40 1c cmp %g1, %i4 40005680: 08 80 00 19 bleu 400056e4 <_Scheduler_priority_Unblock+0xec> 40005684: 01 00 00 00 nop if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40005688: 80 a7 40 19 cmp %i5, %i1 4000568c: 02 bf ff fa be 40005674 <_Scheduler_priority_Unblock+0x7c> <== NEVER TAKEN 40005690: 80 a7 20 00 cmp %i4, 0 40005694: 02 80 00 06 be 400056ac <_Scheduler_priority_Unblock+0xb4> 40005698: 01 00 00 00 nop 4000569c: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1 400056a0: 80 a0 60 00 cmp %g1, 0 400056a4: 02 80 00 10 be 400056e4 <_Scheduler_priority_Unblock+0xec> 400056a8: 01 00 00 00 nop 400056ac: 7f ff fd 69 call 40004c50 <_Timecounter_Sbinuptime> 400056b0: e0 1e e0 28 ldd [ %i3 + 0x28 ], %l0 400056b4: 84 10 00 08 mov %o0, %g2 400056b8: 86 10 00 09 mov %o1, %g3 400056bc: c4 3e e0 28 std %g2, [ %i3 + 0x28 ] *_result = *_end - *_start; 400056c0: b6 a2 40 11 subcc %o1, %l1, %i3 *_time += *_add; 400056c4: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4 *_result = *_end - *_start; 400056c8: b4 60 80 10 subx %g2, %l0, %i2 *_time += *_add; 400056cc: 86 83 40 1b addcc %o5, %i3, %g3 400056d0: 84 43 00 1a addx %o4, %i2, %g2 400056d4: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] _Thread_Dispatch_necessary = true; 400056d8: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 400056dc: f2 21 a0 24 st %i1, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 400056e0: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] } 400056e4: 81 c7 e0 08 ret 400056e8: 81 e8 00 00 restore return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 400056ec: 3b 00 00 20 sethi %hi(0x8000), %i5 ready_queue->ready_chain = &ready_queues[ new_priority ]; 400056f0: b7 29 20 01 sll %g4, 1, %i3 return the_priority % 16; 400056f4: b0 09 20 0f and %g4, 0xf, %i0 400056f8: b6 06 c0 04 add %i3, %g4, %i3 400056fc: b7 2e e0 02 sll %i3, 2, %i3 return the_priority / 16; 40005700: 83 37 20 05 srl %i4, 5, %g1 ready_queue->current_priority = new_priority; 40005704: c8 26 a0 38 st %g4, [ %i2 + 0x38 ] return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 40005708: 9f 37 40 01 srl %i5, %g1, %o7 4000570c: 89 37 40 18 srl %i5, %i0, %g4 _Scheduler_priority_Ready_queue_update( 40005710: 84 00 e0 24 add %g3, 0x24, %g2 bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 40005714: 82 00 60 01 inc %g1 ready_queue->ready_chain = &ready_queues[ new_priority ]; 40005718: 84 00 80 1b add %g2, %i3, %g2 4000571c: 83 28 60 01 sll %g1, 1, %g1 bit_map_info->block_major = (Priority_bit_map_Word) ~mask; 40005720: b6 38 00 0f xnor %g0, %o7, %i3 bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 40005724: 82 00 c0 01 add %g3, %g1, %g1 bit_map_info->block_minor = (Priority_bit_map_Word) ~mask; 40005728: ba 38 00 04 xnor %g0, %g4, %i5 4000572c: c4 26 a0 3c st %g2, [ %i2 + 0x3c ] return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 40005730: b0 10 00 04 mov %g4, %i0 bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 40005734: c2 26 a0 40 st %g1, [ %i2 + 0x40 ] bit_map_info->ready_major = mask; 40005738: de 36 a0 44 sth %o7, [ %i2 + 0x44 ] bit_map_info->block_major = (Priority_bit_map_Word) ~mask; 4000573c: f6 36 a0 48 sth %i3, [ %i2 + 0x48 ] bit_map_info->ready_minor = mask; 40005740: c8 36 a0 46 sth %g4, [ %i2 + 0x46 ] _Priority_bit_map_Initialize_information( bit_map, &ready_queue->Priority_map, new_priority ); } 40005744: 10 bf ff b7 b 40005620 <_Scheduler_priority_Unblock+0x28> 40005748: fa 36 a0 4a sth %i5, [ %i2 + 0x4a ] =============================================================================== 40005c24 <_Scheduler_simple_Block>: void _Scheduler_simple_Block( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 40005c24: 9d e3 bf a0 save %sp, -96, %sp previous = the_node->previous; 40005c28: c2 06 60 04 ld [ %i1 + 4 ], %g1 next = the_node->next; 40005c2c: c4 06 40 00 ld [ %i1 ], %g2 next->previous = previous; 40005c30: c2 20 a0 04 st %g1, [ %g2 + 4 ] return ( the_thread == _Thread_Executing ); 40005c34: ba 10 00 06 mov %g6, %i5 previous->next = next; 40005c38: c4 20 40 00 st %g2, [ %g1 ] { ( *extract )( scheduler, the_thread, node ); /* TODO: flash critical section? */ if ( _Thread_Is_executing( the_thread ) || _Thread_Is_heir( the_thread ) ) { 40005c3c: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1 40005c40: 80 a6 40 01 cmp %i1, %g1 40005c44: 02 80 00 07 be 40005c60 <_Scheduler_simple_Block+0x3c> 40005c48: f8 01 a0 24 ld [ %g6 + 0x24 ], %i4 40005c4c: 80 a6 40 1c cmp %i1, %i4 40005c50: 22 80 00 05 be,a 40005c64 <_Scheduler_simple_Block+0x40> <== NEVER TAKEN 40005c54: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED the_thread, node, _Scheduler_simple_Extract, _Scheduler_simple_Schedule_body ); } 40005c58: 81 c7 e0 08 ret 40005c5c: 81 e8 00 00 restore return _Chain_Immutable_head( the_chain )->next; 40005c60: c2 06 00 00 ld [ %i0 ], %g1 40005c64: f6 00 40 00 ld [ %g1 ], %i3 bool force_dispatch ) { Thread_Control *heir = _Thread_Heir; if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40005c68: 80 a7 00 1b cmp %i4, %i3 40005c6c: 02 80 00 10 be 40005cac <_Scheduler_simple_Block+0x88> <== NEVER TAKEN 40005c70: 01 00 00 00 nop *time = _Timecounter_Sbinuptime(); 40005c74: 7f ff fe 78 call 40005654 <_Timecounter_Sbinuptime> 40005c78: e0 1f 60 28 ldd [ %i5 + 0x28 ], %l0 40005c7c: 84 10 00 08 mov %o0, %g2 40005c80: 86 10 00 09 mov %o1, %g3 40005c84: c4 3f 60 28 std %g2, [ %i5 + 0x28 ] const Timestamp_Control *_start, const Timestamp_Control *_end, Timestamp_Control *_result ) { *_result = *_end - *_start; 40005c88: b2 a2 40 11 subcc %o1, %l1, %i1 *_time += *_add; 40005c8c: d8 1f 20 98 ldd [ %i4 + 0x98 ], %o4 *_result = *_end - *_start; 40005c90: b0 60 80 10 subx %g2, %l0, %i0 *_time += *_add; 40005c94: 86 83 40 19 addcc %o5, %i1, %g3 40005c98: 84 43 00 18 addx %o4, %i0, %g2 40005c9c: c4 3f 20 98 std %g2, [ %i4 + 0x98 ] heir->Scheduler.state = THREAD_SCHEDULER_BLOCKED; new_heir->Scheduler.state = THREAD_SCHEDULER_SCHEDULED; #endif _Thread_Update_CPU_time_used( heir, _Thread_Get_CPU( heir ) ); _Thread_Heir = new_heir; _Thread_Dispatch_necessary = true; 40005ca0: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 40005ca4: f6 21 a0 24 st %i3, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 40005ca8: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] 40005cac: 81 c7 e0 08 ret 40005cb0: 81 e8 00 00 restore =============================================================================== 40005dc4 <_Scheduler_simple_Schedule>: void _Scheduler_simple_Schedule( const Scheduler_Control *scheduler, Thread_Control *the_thread ) { 40005dc4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED 40005dc8: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED 40005dcc: f6 00 40 00 ld [ %g1 ], %i3 <== NOT EXECUTED Thread_Control *heir = _Thread_Heir; 40005dd0: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 <== NOT EXECUTED if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40005dd4: 80 a6 c0 1d cmp %i3, %i5 <== NOT EXECUTED 40005dd8: 02 80 00 06 be 40005df0 <_Scheduler_simple_Schedule+0x2c> <== NOT EXECUTED 40005ddc: b8 10 00 06 mov %g6, %i4 <== NOT EXECUTED 40005de0: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1 <== NOT EXECUTED 40005de4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40005de8: 12 80 00 04 bne 40005df8 <_Scheduler_simple_Schedule+0x34> <== NOT EXECUTED 40005dec: 01 00 00 00 nop <== NOT EXECUTED _Scheduler_simple_Schedule_body( scheduler, the_thread, false ); } 40005df0: 81 c7 e0 08 ret <== NOT EXECUTED 40005df4: 81 e8 00 00 restore <== NOT EXECUTED 40005df8: 7f ff fe 17 call 40005654 <_Timecounter_Sbinuptime> <== NOT EXECUTED 40005dfc: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 <== NOT EXECUTED 40005e00: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED 40005e04: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED 40005e08: c4 3f 20 28 std %g2, [ %i4 + 0x28 ] <== NOT EXECUTED *_result = *_end - *_start; 40005e0c: b2 a2 40 11 subcc %o1, %l1, %i1 <== NOT EXECUTED *_time += *_add; 40005e10: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4 <== NOT EXECUTED *_result = *_end - *_start; 40005e14: b0 60 80 10 subx %g2, %l0, %i0 <== NOT EXECUTED *_time += *_add; 40005e18: 86 83 40 19 addcc %o5, %i1, %g3 <== NOT EXECUTED 40005e1c: 84 43 00 18 addx %o4, %i0, %g2 <== NOT EXECUTED 40005e20: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 40005e24: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = new_heir; 40005e28: f6 21 a0 24 st %i3, [ %g6 + 0x24 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 40005e2c: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] <== NOT EXECUTED 40005e30: 81 c7 e0 08 ret <== NOT EXECUTED 40005e34: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40005e38 <_Scheduler_simple_Unblock>: void _Scheduler_simple_Unblock( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 40005e38: 9d e3 bf a0 save %sp, -96, %sp return scheduler->context; 40005e3c: c8 06 00 00 ld [ %i0 ], %g4 40005e40: c2 06 60 38 ld [ %i1 + 0x38 ], %g1 40005e44: f8 00 60 1c ld [ %g1 + 0x1c ], %i4 40005e48: c2 01 00 00 ld [ %g4 ], %g1 return &the_chain->Tail.Node; 40005e4c: 88 01 20 04 add %g4, 4, %g4 while ( next != tail && !( *order )( left, next ) ) { 40005e50: 80 a1 00 01 cmp %g4, %g1 40005e54: 02 80 00 0f be 40005e90 <_Scheduler_simple_Unblock+0x58> 40005e58: ba 17 20 01 or %i4, 1, %i5 40005e5c: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 40005e60: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 40005e64: 80 a0 e0 00 cmp %g3, 0 40005e68: 32 80 00 0b bne,a 40005e94 <_Scheduler_simple_Unblock+0x5c> <== NEVER TAKEN 40005e6c: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED 40005e70: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 40005e74: 80 a0 80 1d cmp %g2, %i5 40005e78: 3a 80 00 07 bcc,a 40005e94 <_Scheduler_simple_Unblock+0x5c> 40005e7c: c2 00 60 04 ld [ %g1 + 4 ], %g1 return the_node->next; 40005e80: c2 00 40 00 ld [ %g1 ], %g1 while ( next != tail && !( *order )( left, next ) ) { 40005e84: 80 a1 00 01 cmp %g4, %g1 40005e88: 32 bf ff f6 bne,a 40005e60 <_Scheduler_simple_Unblock+0x28> 40005e8c: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 return the_node->previous; 40005e90: c2 00 60 04 ld [ %g1 + 4 ], %g1 the_node->previous = after_node; 40005e94: c2 26 60 04 st %g1, [ %i1 + 4 ] before_node = after_node->next; 40005e98: c4 00 40 00 ld [ %g1 ], %g2 after_node->next = the_node; 40005e9c: f2 20 40 00 st %i1, [ %g1 ] the_node->next = before_node; 40005ea0: c4 26 40 00 st %g2, [ %i1 ] * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( priority < _Thread_Get_priority( _Thread_Heir ) ) { 40005ea4: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 40005ea8: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 before_node->previous = the_node; 40005eac: f2 20 a0 04 st %i1, [ %g2 + 4 ] 40005eb0: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 40005eb4: 80 a0 a0 00 cmp %g2, 0 40005eb8: 18 80 00 09 bgu 40005edc <_Scheduler_simple_Unblock+0xa4> <== NEVER TAKEN 40005ebc: b6 10 00 06 mov %g6, %i3 40005ec0: 22 80 00 04 be,a 40005ed0 <_Scheduler_simple_Unblock+0x98> <== ALWAYS TAKEN 40005ec4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 _Scheduler_Update_heir( the_thread, priority == PRIORITY_PSEUDO_ISR ); } } 40005ec8: 81 c7 e0 08 ret <== NOT EXECUTED 40005ecc: 81 e8 00 00 restore <== NOT EXECUTED if ( priority < _Thread_Get_priority( _Thread_Heir ) ) { 40005ed0: 80 a0 40 1c cmp %g1, %i4 40005ed4: 08 80 00 19 bleu 40005f38 <_Scheduler_simple_Unblock+0x100> 40005ed8: 01 00 00 00 nop if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40005edc: 80 a7 40 19 cmp %i5, %i1 40005ee0: 02 bf ff fa be 40005ec8 <_Scheduler_simple_Unblock+0x90> <== NEVER TAKEN 40005ee4: 80 a7 20 00 cmp %i4, 0 40005ee8: 02 80 00 06 be 40005f00 <_Scheduler_simple_Unblock+0xc8> 40005eec: 01 00 00 00 nop 40005ef0: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1 40005ef4: 80 a0 60 00 cmp %g1, 0 40005ef8: 02 80 00 10 be 40005f38 <_Scheduler_simple_Unblock+0x100> 40005efc: 01 00 00 00 nop 40005f00: 7f ff fd d5 call 40005654 <_Timecounter_Sbinuptime> 40005f04: e0 1e e0 28 ldd [ %i3 + 0x28 ], %l0 40005f08: 84 10 00 08 mov %o0, %g2 40005f0c: 86 10 00 09 mov %o1, %g3 40005f10: c4 3e e0 28 std %g2, [ %i3 + 0x28 ] *_result = *_end - *_start; 40005f14: b6 a2 40 11 subcc %o1, %l1, %i3 *_time += *_add; 40005f18: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4 *_result = *_end - *_start; 40005f1c: b4 60 80 10 subx %g2, %l0, %i2 *_time += *_add; 40005f20: 86 83 40 1b addcc %o5, %i3, %g3 40005f24: 84 43 00 1a addx %o4, %i2, %g2 40005f28: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] _Thread_Dispatch_necessary = true; 40005f2c: 84 10 20 01 mov 1, %g2 _Thread_Heir = new_heir; 40005f30: f2 21 a0 24 st %i1, [ %g6 + 0x24 ] _Thread_Dispatch_necessary = true; 40005f34: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] } 40005f38: 81 c7 e0 08 ret 40005f3c: 81 e8 00 00 restore =============================================================================== 40005ccc <_Scheduler_simple_Update_priority>: void _Scheduler_simple_Update_priority( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 40005ccc: 9d e3 bf a0 save %sp, -96, %sp Scheduler_simple_Context *context; unsigned int new_priority; if ( !_Thread_Is_ready( the_thread ) ) { 40005cd0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 40005cd4: 80 a0 60 00 cmp %g1, 0 40005cd8: 22 80 00 04 be,a 40005ce8 <_Scheduler_simple_Update_priority+0x1c> <== ALWAYS TAKEN 40005cdc: c2 06 60 04 ld [ %i1 + 4 ], %g1 new_priority = (unsigned int ) _Scheduler_Node_get_priority( node ); _Scheduler_simple_Extract( scheduler, the_thread, node ); _Scheduler_simple_Insert( &context->Ready, the_thread, new_priority ); _Scheduler_simple_Schedule_body( scheduler, the_thread, false ); } 40005ce0: 81 c7 e0 08 ret 40005ce4: 81 e8 00 00 restore next = the_node->next; 40005ce8: c4 06 40 00 ld [ %i1 ], %g2 40005cec: fa 06 00 00 ld [ %i0 ], %i5 do { seq = _SMP_sequence_lock_Read_begin( &node->Priority.Lock ); #endif priority = node->Priority.value; 40005cf0: f8 06 a0 34 ld [ %i2 + 0x34 ], %i4 next->previous = previous; 40005cf4: c2 20 a0 04 st %g1, [ %g2 + 4 ] return &the_chain->Tail.Node; 40005cf8: 88 07 60 04 add %i5, 4, %g4 previous->next = next; 40005cfc: c4 20 40 00 st %g2, [ %g1 ] return _Chain_Immutable_head( the_chain )->next; 40005d00: c2 07 40 00 ld [ %i5 ], %g1 ) { const Chain_Node *tail = _Chain_Immutable_tail( the_chain ); Chain_Node *next = _Chain_First( the_chain ); while ( next != tail && !( *order )( left, next ) ) { 40005d04: 80 a1 00 01 cmp %g4, %g1 40005d08: 32 80 00 0c bne,a 40005d38 <_Scheduler_simple_Update_priority+0x6c> <== ALWAYS TAKEN 40005d0c: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 return the_node->previous; 40005d10: 10 80 00 0f b 40005d4c <_Scheduler_simple_Update_priority+0x80> <== NOT EXECUTED 40005d14: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED while ( next != tail && !( *order )( left, next ) ) { 40005d18: 80 a0 80 1c cmp %g2, %i4 40005d1c: 3a 80 00 0c bcc,a 40005d4c <_Scheduler_simple_Update_priority+0x80> 40005d20: c2 00 60 04 ld [ %g1 + 4 ], %g1 return the_node->next; 40005d24: c2 00 40 00 ld [ %g1 ], %g1 while ( next != tail && !( *order )( left, next ) ) { 40005d28: 80 a1 00 01 cmp %g4, %g1 40005d2c: 22 80 00 08 be,a 40005d4c <_Scheduler_simple_Update_priority+0x80> 40005d30: c2 00 60 04 ld [ %g1 + 4 ], %g1 return aggregation->Node.priority; 40005d34: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 40005d38: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 40005d3c: 80 a0 e0 00 cmp %g3, 0 40005d40: 22 bf ff f6 be,a 40005d18 <_Scheduler_simple_Update_priority+0x4c> <== ALWAYS TAKEN 40005d44: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 return the_node->previous; 40005d48: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED the_node->previous = after_node; 40005d4c: c2 26 60 04 st %g1, [ %i1 + 4 ] before_node = after_node->next; 40005d50: c4 00 40 00 ld [ %g1 ], %g2 after_node->next = the_node; 40005d54: f2 20 40 00 st %i1, [ %g1 ] the_node->next = before_node; 40005d58: c4 26 40 00 st %g2, [ %i1 ] before_node->previous = the_node; 40005d5c: f2 20 a0 04 st %i1, [ %g2 + 4 ] return _Chain_Immutable_head( the_chain )->next; 40005d60: f6 07 40 00 ld [ %i5 ], %i3 Thread_Control *heir = _Thread_Heir; 40005d64: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40005d68: 80 a6 c0 1d cmp %i3, %i5 40005d6c: 02 bf ff dd be 40005ce0 <_Scheduler_simple_Update_priority+0x14> 40005d70: b8 10 00 06 mov %g6, %i4 40005d74: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1 40005d78: 80 a0 60 00 cmp %g1, 0 40005d7c: 02 80 00 10 be 40005dbc <_Scheduler_simple_Update_priority+0xf0> <== ALWAYS TAKEN 40005d80: 01 00 00 00 nop 40005d84: 7f ff fe 34 call 40005654 <_Timecounter_Sbinuptime> <== NOT EXECUTED 40005d88: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 <== NOT EXECUTED 40005d8c: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED 40005d90: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED 40005d94: c4 3f 20 28 std %g2, [ %i4 + 0x28 ] <== NOT EXECUTED *_result = *_end - *_start; 40005d98: b2 a2 40 11 subcc %o1, %l1, %i1 <== NOT EXECUTED *_time += *_add; 40005d9c: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4 <== NOT EXECUTED *_result = *_end - *_start; 40005da0: b0 60 80 10 subx %g2, %l0, %i0 <== NOT EXECUTED *_time += *_add; 40005da4: 86 83 40 19 addcc %o5, %i1, %g3 <== NOT EXECUTED 40005da8: 84 43 00 18 addx %o4, %i0, %g2 <== NOT EXECUTED 40005dac: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 40005db0: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = new_heir; 40005db4: f6 21 a0 24 st %i3, [ %g6 + 0x24 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 40005db8: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] <== NOT EXECUTED 40005dbc: 81 c7 e0 08 ret 40005dc0: 81 e8 00 00 restore =============================================================================== 40005f40 <_Scheduler_simple_Yield>: void _Scheduler_simple_Yield( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 40005f40: 9d e3 bf a0 save %sp, -96, %sp next = the_node->next; 40005f44: c4 06 40 00 ld [ %i1 ], %g2 previous = the_node->previous; 40005f48: c2 06 60 04 ld [ %i1 + 4 ], %g1 return scheduler->context; 40005f4c: fa 06 00 00 ld [ %i0 ], %i5 next->previous = previous; 40005f50: c2 20 a0 04 st %g1, [ %g2 + 4 ] return &the_chain->Tail.Node; 40005f54: 88 07 60 04 add %i5, 4, %g4 previous->next = next; 40005f58: c4 20 40 00 st %g2, [ %g1 ] 40005f5c: c2 06 60 38 ld [ %i1 + 0x38 ], %g1 context = _Scheduler_simple_Get_context( scheduler ); (void) node; _Chain_Extract_unprotected( &the_thread->Object.Node ); insert_priority = (unsigned int) _Thread_Get_priority( the_thread ); 40005f60: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 return _Chain_Immutable_head( the_chain )->next; 40005f64: c2 07 40 00 ld [ %i5 ], %g1 while ( next != tail && !( *order )( left, next ) ) { 40005f68: 80 a1 00 01 cmp %g4, %g1 40005f6c: 02 80 00 0f be 40005fa8 <_Scheduler_simple_Yield+0x68> <== NEVER TAKEN 40005f70: b8 10 a0 01 or %g2, 1, %i4 40005f74: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 40005f78: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 40005f7c: 80 a0 e0 00 cmp %g3, 0 40005f80: 32 80 00 0b bne,a 40005fac <_Scheduler_simple_Yield+0x6c> <== NEVER TAKEN 40005f84: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED 40005f88: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 40005f8c: 80 a0 80 1c cmp %g2, %i4 40005f90: 3a 80 00 07 bcc,a 40005fac <_Scheduler_simple_Yield+0x6c> 40005f94: c2 00 60 04 ld [ %g1 + 4 ], %g1 return the_node->next; 40005f98: c2 00 40 00 ld [ %g1 ], %g1 while ( next != tail && !( *order )( left, next ) ) { 40005f9c: 80 a1 00 01 cmp %g4, %g1 40005fa0: 32 bf ff f6 bne,a 40005f78 <_Scheduler_simple_Yield+0x38> <== ALWAYS TAKEN 40005fa4: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 return the_node->previous; 40005fa8: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED the_node->previous = after_node; 40005fac: c2 26 60 04 st %g1, [ %i1 + 4 ] before_node = after_node->next; 40005fb0: c4 00 40 00 ld [ %g1 ], %g2 after_node->next = the_node; 40005fb4: f2 20 40 00 st %i1, [ %g1 ] the_node->next = before_node; 40005fb8: c4 26 40 00 st %g2, [ %i1 ] before_node->previous = the_node; 40005fbc: f2 20 a0 04 st %i1, [ %g2 + 4 ] return _Chain_Immutable_head( the_chain )->next; 40005fc0: f6 07 40 00 ld [ %i5 ], %i3 Thread_Control *heir = _Thread_Heir; 40005fc4: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5 if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40005fc8: 80 a6 c0 1d cmp %i3, %i5 40005fcc: 02 80 00 06 be 40005fe4 <_Scheduler_simple_Yield+0xa4> 40005fd0: b8 10 00 06 mov %g6, %i4 40005fd4: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1 40005fd8: 80 a0 60 00 cmp %g1, 0 40005fdc: 12 80 00 04 bne 40005fec <_Scheduler_simple_Yield+0xac> <== NEVER TAKEN 40005fe0: 01 00 00 00 nop insert_priority = SCHEDULER_PRIORITY_APPEND( insert_priority ); _Scheduler_simple_Insert( &context->Ready, the_thread, insert_priority ); _Scheduler_simple_Schedule_body( scheduler, the_thread, false ); } 40005fe4: 81 c7 e0 08 ret 40005fe8: 81 e8 00 00 restore 40005fec: 7f ff fd 9a call 40005654 <_Timecounter_Sbinuptime> <== NOT EXECUTED 40005ff0: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0 <== NOT EXECUTED 40005ff4: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED 40005ff8: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED 40005ffc: c4 3f 20 28 std %g2, [ %i4 + 0x28 ] <== NOT EXECUTED *_result = *_end - *_start; 40006000: b2 a2 40 11 subcc %o1, %l1, %i1 <== NOT EXECUTED *_time += *_add; 40006004: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4 <== NOT EXECUTED *_result = *_end - *_start; 40006008: b0 60 80 10 subx %g2, %l0, %i0 <== NOT EXECUTED *_time += *_add; 4000600c: 86 83 40 19 addcc %o5, %i1, %g3 <== NOT EXECUTED 40006010: 84 43 00 18 addx %o4, %i0, %g2 <== NOT EXECUTED 40006014: c4 3f 60 98 std %g2, [ %i5 + 0x98 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 40006018: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = new_heir; 4000601c: f6 21 a0 24 st %i3, [ %g6 + 0x24 ] <== NOT EXECUTED _Thread_Dispatch_necessary = true; 40006020: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] <== NOT EXECUTED 40006024: 81 c7 e0 08 ret <== NOT EXECUTED 40006028: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000a800 <_TLS_Get_allocation_size>: #include static uintptr_t _TLS_Allocation_size; uintptr_t _TLS_Get_allocation_size( void ) { 4000a800: 9d e3 bf a0 save %sp, -96, %sp /* * We must be careful with using _TLS_Size here since this could lead GCC to * assume that this symbol is not 0 and the tests for 0 will be optimized * away. */ size = (uintptr_t) _TLS_Size; 4000a804: 31 00 00 00 sethi %hi(0), %i0 4000a808: b0 16 20 00 mov %i0, %i0 ! 0 uintptr_t allocation_size; uintptr_t alignment; size = _TLS_Get_size(); if ( size == 0 ) { 4000a80c: 80 a6 20 00 cmp %i0, 0 4000a810: 02 80 00 1b be 4000a87c <_TLS_Get_allocation_size+0x7c> 4000a814: 05 10 00 73 sethi %hi(0x4001cc00), %g2 return 0; } allocation_size = _TLS_Allocation_size; 4000a818: c2 00 a0 7c ld [ %g2 + 0x7c ], %g1 ! 4001cc7c <_TLS_Allocation_size> if ( allocation_size == 0 ) { 4000a81c: 80 a0 60 00 cmp %g1, 0 4000a820: 32 80 00 17 bne,a 4000a87c <_TLS_Get_allocation_size+0x7c> 4000a824: b0 10 00 01 mov %g1, %i0 */ static inline uintptr_t _TLS_Heap_align_up( uintptr_t val ) { uintptr_t msk = CPU_HEAP_ALIGNMENT - 1; return (val + msk) & ~msk; 4000a828: b0 06 20 07 add %i0, 7, %i0 4000a82c: 82 0e 3f f8 and %i0, -8, %g1 4000a830: 31 00 00 00 sethi %hi(0), %i0 4000a834: b0 16 20 01 or %i0, 1, %i0 ! 1 <_TLS_Alignment> 4000a838: b0 06 20 07 add %i0, 7, %i0 4000a83c: b0 0e 3f f8 and %i0, -8, %i0 /* * The stack allocator does not support aligned allocations. Allocate * enough to do the alignment manually. */ if ( alignment > CPU_HEAP_ALIGNMENT ) { 4000a840: 80 a6 20 08 cmp %i0, 8 4000a844: 38 80 00 03 bgu,a 4000a850 <_TLS_Get_allocation_size+0x50> 4000a848: 82 00 40 18 add %g1, %i0, %g1 static inline uintptr_t _TLS_Get_thread_control_block_area_size( uintptr_t alignment ) { return alignment <= sizeof(TLS_Thread_control_block) ? sizeof(TLS_Thread_control_block) : alignment; 4000a84c: 80 a6 20 08 cmp %i0, 8 4000a850: 0a 80 00 0f bcs 4000a88c <_TLS_Get_allocation_size+0x8c> <== NEVER TAKEN 4000a854: 07 10 00 5e sethi %hi(0x40017800), %g3 #ifndef __i386__ allocation_size += sizeof(TLS_Dynamic_thread_vector); #endif if ( _Thread_Maximum_TLS_size != 0 ) { 4000a858: c6 00 e0 b8 ld [ %g3 + 0xb8 ], %g3 ! 400178b8 <_Thread_Maximum_TLS_size> allocation_size += sizeof(TLS_Dynamic_thread_vector); 4000a85c: b0 06 20 08 add %i0, 8, %i0 if ( _Thread_Maximum_TLS_size != 0 ) { 4000a860: 80 a0 e0 00 cmp %g3, 0 4000a864: 02 80 00 05 be 4000a878 <_TLS_Get_allocation_size+0x78> 4000a868: b0 06 00 01 add %i0, %g1, %i0 if ( allocation_size <= _Thread_Maximum_TLS_size ) { 4000a86c: 80 a0 c0 18 cmp %g3, %i0 4000a870: 0a 80 00 0f bcs 4000a8ac <_TLS_Get_allocation_size+0xac> 4000a874: b0 10 00 03 mov %g3, %i0 } else { _Internal_error( INTERNAL_ERROR_TOO_LARGE_TLS_SIZE ); } } _TLS_Allocation_size = allocation_size; 4000a878: f0 20 a0 7c st %i0, [ %g2 + 0x7c ] 4000a87c: 81 c7 e0 08 ret 4000a880: 81 e8 00 00 restore } return allocation_size; } 4000a884: 81 c7 e0 08 ret <== NOT EXECUTED 4000a888: 81 e8 00 00 restore <== NOT EXECUTED if ( _Thread_Maximum_TLS_size != 0 ) { 4000a88c: c6 00 e0 b8 ld [ %g3 + 0xb8 ], %g3 <== NOT EXECUTED 4000a890: b0 10 20 08 mov 8, %i0 <== NOT EXECUTED 4000a894: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED allocation_size += sizeof(TLS_Dynamic_thread_vector); 4000a898: b0 06 20 08 add %i0, 8, %i0 <== NOT EXECUTED if ( _Thread_Maximum_TLS_size != 0 ) { 4000a89c: 02 bf ff f7 be 4000a878 <_TLS_Get_allocation_size+0x78> <== NOT EXECUTED 4000a8a0: b0 06 00 01 add %i0, %g1, %i0 <== NOT EXECUTED if ( allocation_size <= _Thread_Maximum_TLS_size ) { 4000a8a4: 10 bf ff f3 b 4000a870 <_TLS_Get_allocation_size+0x70> <== NOT EXECUTED 4000a8a8: 80 a0 c0 18 cmp %g3, %i0 <== NOT EXECUTED _Internal_error( INTERNAL_ERROR_TOO_LARGE_TLS_SIZE ); 4000a8ac: 7f ff e8 44 call 400049bc <_Internal_error> 4000a8b0: 90 10 20 29 mov 0x29, %o0 4000a8b4: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40005e90 <_TOD_Set>: Status_Control _TOD_Set( const struct timespec *tod, ISR_lock_Context *lock_context ) { 40005e90: 9d e3 bf 88 save %sp, -120, %sp && (unsigned long) ts->tv_nsec < WATCHDOG_NANOSECONDS_PER_SECOND; 40005e94: ba 96 20 00 orcc %i0, 0, %i5 40005e98: 02 80 00 07 be 40005eb4 <_TOD_Set+0x24> <== NEVER TAKEN 40005e9c: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 40005ea0: c4 07 60 08 ld [ %i5 + 8 ], %g2 40005ea4: 82 10 61 ff or %g1, 0x1ff, %g1 40005ea8: 80 a0 80 01 cmp %g2, %g1 40005eac: 28 80 00 09 bleu,a 40005ed0 <_TOD_Set+0x40> 40005eb0: d8 1f 40 00 ldd [ %i5 ], %o4 return STATUS_INVALID_NUMBER; 40005eb4: 31 00 00 05 sethi %hi(0x1400), %i0 40005eb8: b0 16 22 0a or %i0, 0x20a, %i0 ! 160a <_ISR_Stack_size+0x60a> register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40005ebc: c2 06 40 00 ld [ %i1 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40005ec0: 91 d0 20 0a ta 0xa 40005ec4: 01 00 00 00 nop _Assert( _TOD_Is_owner() ); status = _TOD_Check_time_of_day_and_run_hooks( tod ); if ( status != STATUS_SUCCESSFUL ) { _TOD_Release( lock_context ); return status; 40005ec8: 81 c7 e0 08 ret 40005ecc: 81 e8 00 00 restore if ( _Watchdog_Is_far_future_timespec( tod ) ) { 40005ed0: 37 37 89 46 sethi %hi(0xde251800), %i3 40005ed4: b6 16 e3 00 or %i3, 0x300, %i3 ! de251b00 40005ed8: 86 83 40 1b addcc %o5, %i3, %g3 40005edc: b4 10 3f ff mov -1, %i2 40005ee0: 84 43 00 1a addx %o4, %i2, %g2 40005ee4: 80 a0 a0 03 cmp %g2, 3 40005ee8: 18 bf ff f4 bgu 40005eb8 <_TOD_Set+0x28> 40005eec: 31 00 00 05 sethi %hi(0x1400), %i0 40005ef0: 02 80 00 31 be 40005fb4 <_TOD_Set+0x124> 40005ef4: 03 37 89 46 sethi %hi(0xde251800), %g1 return _TOD_Hook_Run( TOD_ACTION_SET_CLOCK, tod ); 40005ef8: 92 10 00 1d mov %i5, %o1 40005efc: 40 00 12 d5 call 4000aa50 <_TOD_Hook_Run> 40005f00: 90 10 20 00 clr %o0 if ( status != STATUS_SUCCESSFUL ) { 40005f04: b0 92 20 00 orcc %o0, 0, %i0 40005f08: 12 bf ff ed bne 40005ebc <_TOD_Set+0x2c> 40005f0c: 07 12 e0 be sethi %hi(0x4b82f800), %g3 _bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL; 40005f10: c4 07 60 08 ld [ %i5 + 8 ], %g2 40005f14: 89 28 a0 02 sll %g2, 2, %g4 _bt->sec = _ts->tv_sec; 40005f18: f4 1f 40 00 ldd [ %i5 ], %i2 _bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL; 40005f1c: 83 38 a0 1f sra %g2, 0x1f, %g1 40005f20: 86 10 e2 09 or %g3, 0x209, %g3 40005f24: 82 58 40 03 smul %g1, %g3, %g1 40005f28: 86 50 80 03 umul %g2, %g3, %g3 40005f2c: 85 40 00 00 rd %y, %g2 40005f30: 82 00 40 04 add %g1, %g4, %g1 40005f34: 84 00 40 02 add %g1, %g2, %g2 _bt->sec = _ts->tv_sec; 40005f38: f4 3f bf f0 std %i2, [ %fp + -16 ] } timespec2bintime( tod, &tod_as_bintime ); _Timecounter_Set_clock( &tod_as_bintime, lock_context ); 40005f3c: 92 10 00 19 mov %i1, %o1 _bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL; 40005f40: c4 3f bf f8 std %g2, [ %fp + -8 ] 40005f44: 40 00 01 b2 call 4000660c <_Timecounter_Set_clock> 40005f48: 90 07 bf f0 add %fp, -16, %o0 ticks = (uint64_t) ts->tv_sec; 40005f4c: c6 07 40 00 ld [ %i5 ], %g3 40005f50: c4 07 60 04 ld [ %i5 + 4 ], %g2 ticks |= (uint32_t) ts->tv_nsec; 40005f54: d6 07 60 08 ld [ %i5 + 8 ], %o3 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40005f58: 91 d0 20 09 ta 9 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 ); 40005f5c: c2 27 bf ec st %g1, [ %fp + -20 ] return (Watchdog_Control *) header->first; 40005f60: 11 10 00 62 sethi %hi(0x40018800), %o0 40005f64: 90 12 23 00 or %o0, 0x300, %o0 ! 40018b00 <_Per_CPU_Information> 40005f68: d2 02 20 44 ld [ %o0 + 0x44 ], %o1 first = _Watchdog_Header_first( header ); if ( first != NULL ) { 40005f6c: 80 a2 60 00 cmp %o1, 0 40005f70: 02 80 00 09 be 40005f94 <_TOD_Set+0x104> 40005f74: 95 30 a0 02 srl %g2, 2, %o2 ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS; 40005f78: 87 28 e0 1e sll %g3, 0x1e, %g3 40005f7c: 85 28 a0 1e sll %g2, 0x1e, %g2 _Watchdog_Tickle( 40005f80: 98 07 bf ec add %fp, -20, %o4 40005f84: 94 12 80 03 or %o2, %g3, %o2 40005f88: 96 12 c0 02 or %o3, %g2, %o3 40005f8c: 40 00 0b ed call 40008f40 <_Watchdog_Do_tickle> 40005f90: 90 02 20 40 add %o0, 0x40, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40005f94: c2 07 bf ec ld [ %fp + -20 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40005f98: 91 d0 20 0a ta 0xa 40005f9c: 01 00 00 00 nop } _ISR_lock_Release_and_ISR_enable( &cpu->Watchdog.Lock, &lock_context ); } _TOD.is_set = true; 40005fa0: 03 10 00 62 sethi %hi(0x40018800), %g1 40005fa4: 84 10 20 01 mov 1, %g2 40005fa8: c4 28 62 c8 stb %g2, [ %g1 + 0x2c8 ] return STATUS_SUCCESSFUL; } 40005fac: 81 c7 e0 08 ret 40005fb0: 81 e8 00 00 restore if ( _Watchdog_Is_far_future_timespec( tod ) ) { 40005fb4: 82 10 62 ff or %g1, 0x2ff, %g1 40005fb8: 80 a0 c0 01 cmp %g3, %g1 40005fbc: 08 bf ff d0 bleu 40005efc <_TOD_Set+0x6c> <== NEVER TAKEN 40005fc0: 92 10 00 1d mov %i5, %o1 return STATUS_INVALID_NUMBER; 40005fc4: 10 bf ff bd b 40005eb8 <_TOD_Set+0x28> 40005fc8: 31 00 00 05 sethi %hi(0x1400), %i0 =============================================================================== 40004970 <_Terminate>: void _Terminate( Internal_errors_Source the_source, Internal_errors_t the_error ) { 40004970: 9d e3 bf 98 save %sp, -104, %sp Internal_errors_t error ) { User_extensions_Fatal_context ctx = { source, error }; _User_extensions_Iterate( 40004974: 94 10 20 00 clr %o2 40004978: 90 07 bf f8 add %fp, -8, %o0 User_extensions_Fatal_context ctx = { source, error }; 4000497c: f0 27 bf f8 st %i0, [ %fp + -8 ] _User_extensions_Iterate( 40004980: 13 10 00 18 sethi %hi(0x40006000), %o1 User_extensions_Fatal_context ctx = { source, error }; 40004984: f2 27 bf fc st %i1, [ %fp + -4 ] _User_extensions_Iterate( 40004988: 40 00 06 85 call 4000639c <_User_extensions_Iterate> 4000498c: 92 12 63 4c or %o1, 0x34c, %o1 _User_extensions_Fatal( the_source, the_error ); _Internal_errors_What_happened.the_source = the_source; 40004990: 03 10 00 71 sethi %hi(0x4001c400), %g1 40004994: 84 10 63 b4 or %g1, 0x3b4, %g2 ! 4001c7b4 <_Internal_errors_What_happened> 40004998: f0 20 63 b4 st %i0, [ %g1 + 0x3b4 ] */ RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 4000499c: 03 10 00 71 sethi %hi(0x4001c400), %g1 _Internal_errors_What_happened.the_error = the_error; 400049a0: f2 20 a0 04 st %i1, [ %g2 + 4 ] 400049a4: 84 10 20 03 mov 3, %g2 _System_state_Set( SYSTEM_STATE_TERMINATED ); _SMP_Request_shutdown(); _CPU_Fatal_halt( the_source, the_error ); 400049a8: 92 10 00 19 mov %i1, %o1 400049ac: c4 20 63 bc st %g2, [ %g1 + 0x3bc ] 400049b0: 40 00 1e ef call 4000c56c <_CPU_Fatal_halt> 400049b4: 90 10 00 18 mov %i0, %o0 400049b8: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40009e68 <_Thread_Allocate_unlimited>: } } } Objects_Control *_Thread_Allocate_unlimited( Objects_Information *information ) { 40009e68: 9d e3 bf a0 save %sp, -96, %sp 40009e6c: ba 10 00 18 mov %i0, %i5 return _Chain_Immutable_head( the_chain )->next; 40009e70: f0 06 20 18 ld [ %i0 + 0x18 ], %i0 return &the_chain->Tail.Node; 40009e74: b8 07 60 1c add %i5, 0x1c, %i4 if ( !_Chain_Is_empty(the_chain)) 40009e78: 80 a6 00 1c cmp %i0, %i4 40009e7c: 02 80 00 1e be 40009ef4 <_Thread_Allocate_unlimited+0x8c> 40009e80: b6 07 60 18 add %i5, 0x18, %i3 new_first = old_first->next; 40009e84: c2 06 00 00 ld [ %i0 ], %g1 head->next = new_first; 40009e88: c2 27 60 18 st %g1, [ %i5 + 0x18 ] new_first->previous = head; 40009e8c: f6 20 60 04 st %i3, [ %g1 + 4 ] _Assert( _Objects_Is_auto_extend( information ) ); objects_per_block = information->objects_per_block; block = _Objects_Get_index( the_object->id ) - OBJECTS_INDEX_MINIMUM; if ( block > objects_per_block ) { 40009e90: c4 17 60 12 lduh [ %i5 + 0x12 ], %g2 40009e94: c2 06 20 08 ld [ %i0 + 8 ], %g1 block = _Objects_Get_index( the_object->id ) - OBJECTS_INDEX_MINIMUM; 40009e98: 82 00 7f ff add %g1, -1, %g1 if ( block > objects_per_block ) { 40009e9c: 83 28 60 10 sll %g1, 0x10, %g1 40009ea0: 83 30 60 10 srl %g1, 0x10, %g1 40009ea4: 80 a0 80 01 cmp %g2, %g1 40009ea8: 1a 80 00 11 bcc 40009eec <_Thread_Allocate_unlimited+0x84> 40009eac: 01 00 00 00 nop block /= objects_per_block; information->inactive_per_block[ block ]--; 40009eb0: c6 07 60 24 ld [ %i5 + 0x24 ], %g3 40009eb4: 81 80 20 00 wr %g0, %y 40009eb8: 01 00 00 00 nop 40009ebc: 01 00 00 00 nop 40009ec0: 01 00 00 00 nop 40009ec4: 82 70 40 02 udiv %g1, %g2, %g1 40009ec8: 83 28 60 01 sll %g1, 1, %g1 40009ecc: c4 10 c0 01 lduh [ %g3 + %g1 ], %g2 40009ed0: 84 00 bf ff add %g2, -1, %g2 40009ed4: c4 30 c0 01 sth %g2, [ %g3 + %g1 ] information->inactive--; 40009ed8: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1 40009edc: 82 00 7f ff add %g1, -1, %g1 40009ee0: c2 37 60 10 sth %g1, [ %i5 + 0x10 ] return _Objects_Allocate_with_extend( 40009ee4: 81 c7 e0 08 ret 40009ee8: 81 e8 00 00 restore information, _Thread_Extend_information ); } 40009eec: 81 c7 e0 08 ret 40009ef0: 81 e8 00 00 restore block = _Objects_Extend_information( &information->Objects ); 40009ef4: 7f ff fc c7 call 40009210 <_Objects_Extend_information> 40009ef8: 90 10 00 1d mov %i5, %o0 if ( block > 0 ) { 40009efc: 91 2a 20 10 sll %o0, 0x10, %o0 40009f00: b5 32 20 10 srl %o0, 0x10, %i2 40009f04: 80 a6 a0 00 cmp %i2, 0 40009f08: 32 80 00 08 bne,a 40009f28 <_Thread_Allocate_unlimited+0xc0> <== ALWAYS TAKEN 40009f0c: d4 17 60 12 lduh [ %i5 + 0x12 ], %o2 return _Chain_Immutable_head( the_chain )->next; 40009f10: f0 07 60 18 ld [ %i5 + 0x18 ], %i0 <== NOT EXECUTED if ( !_Chain_Is_empty(the_chain)) 40009f14: 80 a7 00 18 cmp %i4, %i0 40009f18: 32 bf ff dc bne,a 40009e88 <_Thread_Allocate_unlimited+0x20> <== ALWAYS TAKEN 40009f1c: c2 06 00 00 ld [ %i0 ], %g1 return NULL; 40009f20: 81 c7 e0 08 ret <== NOT EXECUTED 40009f24: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED new_heads = _Freechain_Extend( 40009f28: 96 10 20 48 mov 0x48, %o3 40009f2c: 90 07 60 30 add %i5, 0x30, %o0 40009f30: 13 10 00 30 sethi %hi(0x4000c000), %o1 40009f34: 40 00 23 d2 call 40012e7c <_Freechain_Extend> 40009f38: 92 12 60 ec or %o1, 0xec, %o1 ! 4000c0ec <_Workspace_Allocate> if ( new_heads == NULL ) { 40009f3c: 80 a2 20 00 cmp %o0, 0 40009f40: 32 bf ff f5 bne,a 40009f14 <_Thread_Allocate_unlimited+0xac> <== ALWAYS TAKEN 40009f44: f0 07 60 18 ld [ %i5 + 0x18 ], %i0 _Objects_Free_objects_block( &information->Objects, block ); 40009f48: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 40009f4c: 7f ff fd 7b call 40009538 <_Objects_Free_objects_block> <== NOT EXECUTED 40009f50: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 40009f54: 10 bf ff f0 b 40009f14 <_Thread_Allocate_unlimited+0xac> <== NOT EXECUTED 40009f58: f0 07 60 18 ld [ %i5 + 0x18 ], %i0 <== NOT EXECUTED =============================================================================== 4000b7cc <_Thread_Cancel>: void _Thread_Cancel( Thread_Control *the_thread, Thread_Control *executing, void *exit_value ) { 4000b7cc: 9d e3 bf 98 save %sp, -104, %sp 4000b7d0: ba 10 00 18 mov %i0, %i5 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b7d4: 91 d0 20 09 ta 9 return psr; 4000b7d8: c2 27 bf fc st %g1, [ %fp + -4 ] the_thread->Life.exit_value = exit_value; 4000b7dc: f4 26 21 78 st %i2, [ %i0 + 0x178 ] _Assert( the_thread != executing ); _Thread_State_acquire( the_thread, &lock_context ); _Thread_Set_exit_value( the_thread, exit_value ); previous = _Thread_Change_life_locked( 4000b7e0: 90 10 00 18 mov %i0, %o0 4000b7e4: 96 10 20 00 clr %o3 4000b7e8: 94 10 20 04 mov 4, %o2 4000b7ec: 7f ff ff 04 call 4000b3fc <_Thread_Change_life_locked> 4000b7f0: 92 10 20 00 clr %o1 disable_level = cpu_self->thread_dispatch_disable_level; 4000b7f4: c4 01 a0 18 ld [ %g6 + 0x18 ], %g2 cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000b7f8: 84 00 a0 01 inc %g2 4000b7fc: c4 21 a0 18 st %g2, [ %g6 + 0x18 ] return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000b800: b0 10 00 06 mov %g6, %i0 ); cpu_self = _Thread_Dispatch_disable_critical( &lock_context ); priority = _Thread_Get_priority( executing ); if ( _States_Is_dormant( the_thread->current_state ) ) { 4000b804: c4 07 60 1c ld [ %i5 + 0x1c ], %g2 4000b808: 80 a0 a0 00 cmp %g2, 0 4000b80c: 06 80 00 2e bl 4000b8c4 <_Thread_Cancel+0xf8> 4000b810: c2 07 bf fc ld [ %fp + -4 ], %g1 return aggregation->Node.priority; 4000b814: c6 06 60 38 ld [ %i1 + 0x38 ], %g3 pending_requests = the_thread->Life.pending_life_change_requests; 4000b818: c4 07 61 74 ld [ %i5 + 0x174 ], %g2 4000b81c: f4 18 e0 18 ldd [ %g3 + 0x18 ], %i2 the_thread->Life.pending_life_change_requests = pending_requests + 1; 4000b820: 86 00 a0 01 add %g2, 1, %g3 _Thread_State_release( the_thread, &lock_context ); _Thread_Make_zombie( the_thread ); } else if ( _Thread_Is_life_change_allowed( previous ) ) { 4000b824: 80 8a 20 09 btst 9, %o0 4000b828: 02 80 00 1a be 4000b890 <_Thread_Cancel+0xc4> 4000b82c: c6 27 61 74 st %g3, [ %i5 + 0x174 ] if ( pending_requests == 0 ) { 4000b830: 80 a0 a0 00 cmp %g2, 0 4000b834: 22 80 00 31 be,a 4000b8f8 <_Thread_Cancel+0x12c> <== ALWAYS TAKEN 4000b838: c2 27 bf fc st %g1, [ %fp + -4 ] _Thread_State_release( the_thread, &lock_context ); _Thread_Finalize_life_change( the_thread, priority ); } else { _Thread_Add_life_change_request( the_thread ); _Thread_Clear_state_locked( the_thread, STATES_SUSPENDED ); 4000b83c: c2 27 bf fc st %g1, [ %fp + -4 ] 4000b840: 13 00 00 20 sethi %hi(0x8000), %o1 4000b844: 40 00 19 5e call 40011dbc <_Thread_Clear_state_locked> 4000b848: 90 10 00 1d mov %i5, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000b84c: c2 07 bf fc ld [ %fp + -4 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b850: 91 d0 20 0a ta 0xa 4000b854: 01 00 00 00 nop _Thread_State_release( the_thread, &lock_context ); _Thread_Raise_real_priority( the_thread, priority ); 4000b858: 92 10 00 1a mov %i2, %o1 4000b85c: 94 10 00 1b mov %i3, %o2 4000b860: 7f ff fe c3 call 4000b36c <_Thread_Raise_real_priority> 4000b864: 90 10 00 1d mov %i5, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b868: 91 d0 20 09 ta 9 pending_requests = the_thread->Life.pending_life_change_requests; 4000b86c: c4 07 61 74 ld [ %i5 + 0x174 ], %g2 the_thread->Life.pending_life_change_requests = pending_requests - 1; 4000b870: 86 00 bf ff add %g2, -1, %g3 if ( pending_requests == 1 ) { 4000b874: 80 a0 a0 01 cmp %g2, 1 4000b878: 02 80 00 19 be 4000b8dc <_Thread_Cancel+0x110> <== ALWAYS TAKEN 4000b87c: c6 27 61 74 st %g3, [ %i5 + 0x174 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b880: 91 d0 20 0a ta 0xa 4000b884: 01 00 00 00 nop _Thread_Remove_life_change_request( the_thread ); } _Thread_Dispatch_enable( cpu_self ); 4000b888: 7f ff fa f7 call 4000a464 <_Thread_Dispatch_enable> 4000b88c: 81 e8 00 00 restore if ( pending_requests == 0 ) { 4000b890: 80 a0 a0 00 cmp %g2, 0 4000b894: 22 80 00 1e be,a 4000b90c <_Thread_Cancel+0x140> <== ALWAYS TAKEN 4000b898: c2 27 bf fc st %g1, [ %fp + -4 ] 4000b89c: 91 d0 20 0a ta 0xa 4000b8a0: 01 00 00 00 nop _Thread_queue_Extract_with_proxy( the_thread ); 4000b8a4: 40 00 1a 5f call 40012220 <_Thread_queue_Extract_with_proxy> 4000b8a8: 90 10 00 1d mov %i5, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b8ac: 91 d0 20 09 ta 9 return psr; 4000b8b0: c2 27 bf fc st %g1, [ %fp + -4 ] 4000b8b4: d0 07 60 60 ld [ %i5 + 0x60 ], %o0 4000b8b8: 40 00 02 20 call 4000c138 <_Watchdog_Remove> 4000b8bc: 92 07 60 68 add %i5, 0x68, %o1 _Per_CPU_Get(), #endif the_thread->Timer.header ); _ISR_lock_Release_and_ISR_enable( &the_thread->Timer.Lock, &lock_context ); 4000b8c0: 30 bf ff e3 b,a 4000b84c <_Thread_Cancel+0x80> __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b8c4: 91 d0 20 0a ta 0xa 4000b8c8: 01 00 00 00 nop _Thread_Make_zombie( the_thread ); 4000b8cc: 7f ff fe ef call 4000b488 <_Thread_Make_zombie> 4000b8d0: 90 10 00 1d mov %i5, %o0 _Thread_Dispatch_enable( cpu_self ); 4000b8d4: 7f ff fa e4 call 4000a464 <_Thread_Dispatch_enable> 4000b8d8: 81 e8 00 00 restore 4000b8dc: c2 27 bf fc st %g1, [ %fp + -4 ] _Thread_Clear_state_locked( 4000b8e0: 90 10 00 1d mov %i5, %o0 4000b8e4: 13 0c 00 a0 sethi %hi(0x30028000), %o1 4000b8e8: 40 00 19 35 call 40011dbc <_Thread_Clear_state_locked> 4000b8ec: 92 12 63 0c or %o1, 0x30c, %o1 ! 3002830c 4000b8f0: 10 bf ff e4 b 4000b880 <_Thread_Cancel+0xb4> 4000b8f4: c2 07 bf fc ld [ %fp + -4 ], %g1 _Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING ); 4000b8f8: 13 00 00 80 sethi %hi(0x20000), %o1 4000b8fc: 40 00 00 71 call 4000bac0 <_Thread_Set_state_locked> 4000b900: 90 10 00 1d mov %i5, %o0 4000b904: 10 bf ff ce b 4000b83c <_Thread_Cancel+0x70> 4000b908: c2 07 bf fc ld [ %fp + -4 ], %g1 4000b90c: 13 00 00 80 sethi %hi(0x20000), %o1 4000b910: 40 00 00 6c call 4000bac0 <_Thread_Set_state_locked> 4000b914: 90 10 00 1d mov %i5, %o0 4000b918: 10 bf ff e1 b 4000b89c <_Thread_Cancel+0xd0> 4000b91c: c2 07 bf fc ld [ %fp + -4 ], %g1 =============================================================================== 40005ea0 <_Thread_Change_life>: Thread_Life_state _Thread_Change_life( Thread_Life_state clear, Thread_Life_state set, Thread_Life_state ignore ) { 40005ea0: 9d e3 bf a0 save %sp, -96, %sp __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40005ea4: 91 d0 20 09 ta 9 executing = _Thread_Executing; 40005ea8: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2 previous = the_thread->Life.state; 40005eac: fa 00 a1 70 ld [ %g2 + 0x170 ], %i5 state &= ~clear; 40005eb0: 86 2f 40 18 andn %i5, %i0, %g3 state |= set; 40005eb4: b2 16 40 03 or %i1, %g3, %i1 the_thread->Life.state = state; 40005eb8: f2 20 a1 70 st %i1, [ %g2 + 0x170 ] state &= ~ignore; 40005ebc: b2 2e 40 1a andn %i1, %i2, %i1 if ( 40005ec0: 80 8e 60 09 btst 9, %i1 40005ec4: 12 80 00 14 bne 40005f14 <_Thread_Change_life+0x74> 40005ec8: 90 10 00 06 mov %g6, %o0 && _Thread_Is_life_changing( state ) 40005ecc: 80 8e 60 06 btst 6, %i1 40005ed0: 02 80 00 11 be 40005f14 <_Thread_Change_life+0x74> 40005ed4: 01 00 00 00 nop the_thread->budget_callout = the_thread->Start.budget_callout; 40005ed8: c6 00 a0 b4 ld [ %g2 + 0xb4 ], %g3 the_thread->is_preemptible = the_thread->Start.is_preemptible; 40005edc: f8 08 a0 ac ldub [ %g2 + 0xac ], %i4 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 40005ee0: c8 00 a0 b0 ld [ %g2 + 0xb0 ], %g4 the_thread->budget_callout = the_thread->Start.budget_callout; 40005ee4: c6 20 a0 94 st %g3, [ %g2 + 0x94 ] action->handler = handler; 40005ee8: 07 10 00 17 sethi %hi(0x40005c00), %g3 the_thread->is_preemptible = the_thread->Start.is_preemptible; 40005eec: f8 28 a0 89 stb %i4, [ %g2 + 0x89 ] 40005ef0: 86 10 e0 04 or %g3, 4, %g3 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 40005ef4: c8 20 a0 90 st %g4, [ %g2 + 0x90 ] 40005ef8: c6 20 a1 6c st %g3, [ %g2 + 0x16c ] cpu_self->dispatch_necessary = true; 40005efc: 86 10 20 01 mov 1, %g3 40005f00: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ] if ( _Chain_Is_node_off_chain( the_node ) ) { 40005f04: c6 00 a1 64 ld [ %g2 + 0x164 ], %g3 40005f08: 80 a0 e0 00 cmp %g3, 0 40005f0c: 22 80 00 0b be,a 40005f38 <_Thread_Change_life+0x98> <== ALWAYS TAKEN 40005f10: c6 00 a0 e8 ld [ %g2 + 0xe8 ], %g3 disable_level = cpu_self->thread_dispatch_disable_level; 40005f14: c4 02 20 18 ld [ %o0 + 0x18 ], %g2 cpu_self->thread_dispatch_disable_level = disable_level + 1; 40005f18: 84 00 a0 01 inc %g2 40005f1c: c4 22 20 18 st %g2, [ %o0 + 0x18 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40005f20: 91 d0 20 0a ta 0xa 40005f24: 01 00 00 00 nop previous = _Thread_Change_life_locked( executing, clear, set, ignore ); cpu_self = _Thread_Dispatch_disable_critical( &lock_context ); _Thread_State_release( executing, &lock_context ); _Thread_Dispatch_enable( cpu_self ); 40005f28: 7f ff fe 8e call 40005960 <_Thread_Dispatch_enable> 40005f2c: b0 10 00 1d mov %i5, %i0 return previous; } 40005f30: 81 c7 e0 08 ret 40005f34: 81 e8 00 00 restore _Chain_Append_if_is_off_chain_unprotected( 40005f38: 88 00 a1 64 add %g2, 0x164, %g4 return &the_chain->Tail.Node; 40005f3c: b8 00 a0 e4 add %g2, 0xe4, %i4 tail->previous = the_node; 40005f40: c8 20 a0 e8 st %g4, [ %g2 + 0xe8 ] the_node->next = tail; 40005f44: f8 20 a1 64 st %i4, [ %g2 + 0x164 ] old_last->next = the_node; 40005f48: c8 20 c0 00 st %g4, [ %g3 ] } 40005f4c: 10 bf ff f2 b 40005f14 <_Thread_Change_life+0x74> 40005f50: c6 20 a1 68 st %g3, [ %g2 + 0x168 ] =============================================================================== 40009428 <_Thread_Clear_state_locked>: States_Control _Thread_Clear_state_locked( Thread_Control *the_thread, States_Control state ) { 40009428: 9d e3 bf a0 save %sp, -96, %sp States_Control previous_state; _Assert( state != 0 ); _Assert( _Thread_State_is_owner( the_thread ) ); previous_state = the_thread->current_state; 4000942c: fa 06 20 1c ld [ %i0 + 0x1c ], %i5 if ( ( previous_state & state ) != 0 ) { 40009430: 80 8f 40 19 btst %i5, %i1 40009434: 02 80 00 0b be 40009460 <_Thread_Clear_state_locked+0x38> 40009438: b2 2f 40 19 andn %i5, %i1, %i1 States_Control next_state; next_state = _States_Clear( state, previous_state ); the_thread->current_state = next_state; if ( _States_Is_ready( next_state ) ) { 4000943c: 80 a6 60 00 cmp %i1, 0 40009440: 12 80 00 08 bne 40009460 <_Thread_Clear_state_locked+0x38> <== NEVER TAKEN 40009444: f2 26 20 1c st %i1, [ %i0 + 0x1c ] ( *scheduler->Operations.unblock )( scheduler, the_thread, scheduler_node ); 40009448: 11 10 00 5e sethi %hi(0x40017800), %o0 4000944c: d4 06 20 38 ld [ %i0 + 0x38 ], %o2 40009450: 90 12 20 c0 or %o0, 0xc0, %o0 40009454: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 40009458: 9f c0 40 00 call %g1 4000945c: 92 10 00 18 mov %i0, %o1 _Scheduler_Unblock( the_thread ); } } return previous_state; } 40009460: 81 c7 e0 08 ret 40009464: 91 e8 00 1d restore %g0, %i5, %o0 =============================================================================== 40006090 <_Thread_Continue>: #include #include void _Thread_Continue( Thread_Control *the_thread, Status_Control status ) { 40006090: 9d e3 bf 78 save %sp, -136, %sp queue_context->Priority.update_count = 0; 40006094: c0 27 bf f0 clr [ %fp + -16 ] __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40006098: 91 d0 20 09 ta 9 _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 4000609c: c2 27 bf dc st %g1, [ %fp + -36 ] return the_thread->Wait.flags; 400060a0: 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 ) { 400060a4: 80 8f 60 04 btst 4, %i5 400060a8: 32 80 00 23 bne,a 40006134 <_Thread_Continue+0xa4> 400060ac: ba 10 20 00 clr %i5 ( *the_thread->Wait.operations->extract )( 400060b0: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 400060b4: c2 00 60 08 ld [ %g1 + 8 ], %g1 400060b8: d0 06 20 54 ld [ %i0 + 0x54 ], %o0 400060bc: b8 07 bf dc add %fp, -36, %i4 400060c0: 92 10 00 18 mov %i0, %o1 400060c4: 9f c0 40 00 call %g1 400060c8: 94 10 00 1c mov %i4, %o2 the_thread->Wait.operations = &_Thread_queue_Operations_default; 400060cc: 03 10 00 5f sethi %hi(0x40017c00), %g1 400060d0: 82 10 62 90 or %g1, 0x290, %g1 ! 40017e90 <_Thread_queue_Operations_default> 400060d4: 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; 400060d8: 03 00 00 3f sethi %hi(0xfc00), %g1 400060dc: 82 10 63 00 or %g1, 0x300, %g1 ! ff00 <_ISR_Stack_size+0xef00> if ( success ) { 400060e0: c4 06 20 50 ld [ %i0 + 0x50 ], %g2 400060e4: ba 0f 40 01 and %i5, %g1, %i5 the_thread->Wait.queue = NULL; 400060e8: c0 26 20 54 clr [ %i0 + 0x54 ] ready_again = wait_class | THREAD_WAIT_STATE_READY_AGAIN; success = _Thread_Wait_flags_try_change_release( 400060ec: 82 17 60 01 or %i5, 1, %g1 the_thread->Wait.return_code = status; 400060f0: f2 26 20 4c st %i1, [ %i0 + 0x4c ] ready_again = wait_class | THREAD_WAIT_STATE_READY_AGAIN; 400060f4: ba 17 60 04 or %i5, 4, %i5 the_thread->Wait.flags = desired_flags; 400060f8: fa 26 20 50 st %i5, [ %i0 + 0x50 ] if ( success ) { 400060fc: 80 a0 40 02 cmp %g1, %g2 40006100: 02 80 00 03 be 4000610c <_Thread_Continue+0x7c> 40006104: ba 10 20 00 clr %i5 _Assert( _Thread_Wait_flags_get( the_thread ) == ( wait_class | THREAD_WAIT_STATE_BLOCKED ) ); _Thread_Wait_flags_set( the_thread, ready_again ); unblock = true; 40006108: ba 10 20 01 mov 1, %i5 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000610c: c2 07 bf dc ld [ %fp + -36 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40006110: 91 d0 20 0a ta 0xa 40006114: 01 00 00 00 nop } else { unblock = false; } _Thread_Wait_release( the_thread, &queue_context ); _Thread_Priority_update( &queue_context ); 40006118: 40 00 0c ab call 400093c4 <_Thread_Priority_update> 4000611c: 90 10 00 1c mov %i4, %o0 if ( unblock ) { 40006120: 80 8f 60 ff btst 0xff, %i5 40006124: 12 80 00 0d bne 40006158 <_Thread_Continue+0xc8> 40006128: 90 10 00 18 mov %i0, %o0 if ( !_Objects_Is_local_id( the_thread->Object.id ) ) { _Thread_MP_Free_proxy( the_thread ); } #endif } } 4000612c: 81 c7 e0 08 ret 40006130: 81 e8 00 00 restore 40006134: b8 07 bf dc add %fp, -36, %i4 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40006138: c2 07 bf dc ld [ %fp + -36 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000613c: 91 d0 20 0a ta 0xa 40006140: 01 00 00 00 nop _Thread_Priority_update( &queue_context ); 40006144: 40 00 0c a0 call 400093c4 <_Thread_Priority_update> 40006148: 90 10 00 1c mov %i4, %o0 if ( unblock ) { 4000614c: 80 8f 60 ff btst 0xff, %i5 40006150: 02 bf ff f7 be 4000612c <_Thread_Continue+0x9c> <== ALWAYS TAKEN 40006154: 90 10 00 18 mov %i0, %o0 _Thread_Clear_state( the_thread, STATES_BLOCKED ); 40006158: 13 0c 00 57 sethi %hi(0x30015c00), %o1 4000615c: 40 00 0c c3 call 40009468 <_Thread_Clear_state> 40006160: 92 12 63 ff or %o1, 0x3ff, %o1 ! 30015fff } 40006164: 81 c7 e0 08 ret 40006168: 81 e8 00 00 restore =============================================================================== 4000581c <_Thread_Do_dispatch>: _Thread_State_release( executing, &lock_context ); } void _Thread_Do_dispatch( Per_CPU_Control *cpu_self, ISR_Level level ) { 4000581c: 9d e3 bf 98 save %sp, -104, %sp ) { _Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT ); } #endif executing = cpu_self->executing; 40005820: f6 06 20 20 ld [ %i0 + 0x20 ], %i3 { 40005824: 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(); 40005828: 23 10 00 5f sethi %hi(0x40017c00), %l1 return _Chain_Immutable_head( the_chain )->next; 4000582c: 33 10 00 6b sethi %hi(0x4001ac00), %i1 #if !defined(RTEMS_SMP) _User_extensions_Thread_switch( executing, heir ); #endif _Thread_Save_fp( executing ); _Context_Switch( &executing->Registers, &heir->Registers ); 40005830: a0 06 e0 f0 add %i3, 0xf0, %l0 40005834: b2 16 61 50 or %i1, 0x150, %i1 if ( node != tail ) { 40005838: b4 06 60 04 add %i1, 4, %i2 heir = cpu_self->heir; 4000583c: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 cpu_self->dispatch_necessary = false; 40005840: c0 2e 20 1c clrb [ %i0 + 0x1c ] if ( heir == executing ) 40005844: 80 a6 c0 1c cmp %i3, %i4 40005848: 02 80 00 1e be 400058c0 <_Thread_Do_dispatch+0xa4> 4000584c: f8 26 20 20 st %i4, [ %i0 + 0x20 ] if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) 40005850: c4 07 20 90 ld [ %i4 + 0x90 ], %g2 40005854: 80 a0 a0 01 cmp %g2, 1 40005858: 12 80 00 03 bne 40005864 <_Thread_Do_dispatch+0x48> 4000585c: c4 04 61 d0 ld [ %l1 + 0x1d0 ], %g2 heir->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice(); 40005860: c4 27 20 8c st %g2, [ %i4 + 0x8c ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40005864: 91 d0 20 0a ta 0xa 40005868: 01 00 00 00 nop 4000586c: fa 06 40 00 ld [ %i1 ], %i5 40005870: 80 a7 40 1a cmp %i5, %i2 40005874: 02 80 00 0b be 400058a0 <_Thread_Do_dispatch+0x84> 40005878: 92 07 20 f0 add %i4, 0xf0, %o1 (*extension->thread_switch)( executing, heir ); 4000587c: c2 07 60 08 ld [ %i5 + 8 ], %g1 40005880: 92 10 00 1c mov %i4, %o1 return the_node->next; 40005884: fa 07 40 00 ld [ %i5 ], %i5 40005888: 9f c0 40 00 call %g1 4000588c: 90 10 00 1b mov %i3, %o0 while ( node != tail ) { 40005890: 80 a7 40 1a cmp %i5, %i2 40005894: 32 bf ff fb bne,a 40005880 <_Thread_Do_dispatch+0x64> 40005898: c2 07 60 08 ld [ %i5 + 8 ], %g1 _Context_Switch( &executing->Registers, &heir->Registers ); 4000589c: 92 07 20 f0 add %i4, 0xf0, %o1 400058a0: 40 00 03 db call 4000680c <_CPU_Context_switch> 400058a4: 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(); 400058a8: b0 10 00 06 mov %g6, %i0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400058ac: 91 d0 20 09 ta 9 _ISR_Local_disable( level ); } while ( cpu_self->dispatch_necessary ); 400058b0: c4 09 a0 1c ldub [ %g6 + 0x1c ], %g2 400058b4: 80 a0 a0 00 cmp %g2, 0 400058b8: 32 bf ff e2 bne,a 40005840 <_Thread_Do_dispatch+0x24> 400058bc: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 post_switch: _Assert( cpu_self->thread_dispatch_disable_level == 1 ); cpu_self->thread_dispatch_disable_level = 0; 400058c0: c0 26 20 18 clr [ %i0 + 0x18 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400058c4: 91 d0 20 0a ta 0xa 400058c8: 01 00 00 00 nop __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400058cc: 91 d0 20 09 ta 9 _ISR_lock_ISR_disable( lock_context ); 400058d0: c2 27 bf fc st %g1, [ %fp + -4 ] return _Chain_Immutable_head( the_chain )->next; 400058d4: d2 06 e0 e0 ld [ %i3 + 0xe0 ], %o1 return &the_chain->Tail.Node; 400058d8: ba 06 e0 e4 add %i3, 0xe4, %i5 if ( !_Chain_Is_empty(the_chain)) 400058dc: 80 a2 40 1d cmp %o1, %i5 400058e0: 02 80 00 10 be 40005920 <_Thread_Do_dispatch+0x104> 400058e4: b8 06 e0 e0 add %i3, 0xe0, %i4 new_first = old_first->next; 400058e8: c2 02 40 00 ld [ %o1 ], %g1 head->next = new_first; 400058ec: c2 26 e0 e0 st %g1, [ %i3 + 0xe0 ] ( *action->handler )( executing, action, &lock_context ); 400058f0: 94 07 bf fc add %fp, -4, %o2 new_first->previous = head; 400058f4: f8 20 60 04 st %i4, [ %g1 + 4 ] node->next = NULL; 400058f8: c0 22 40 00 clr [ %o1 ] 400058fc: c2 02 60 08 ld [ %o1 + 8 ], %g1 40005900: 9f c0 40 00 call %g1 40005904: 90 10 00 1b mov %i3, %o0 40005908: 91 d0 20 09 ta 9 4000590c: c2 27 bf fc st %g1, [ %fp + -4 ] return _Chain_Immutable_head( the_chain )->next; 40005910: d2 06 e0 e0 ld [ %i3 + 0xe0 ], %o1 if ( !_Chain_Is_empty(the_chain)) 40005914: 80 a7 40 09 cmp %i5, %o1 40005918: 32 bf ff f5 bne,a 400058ec <_Thread_Do_dispatch+0xd0> <== NEVER TAKEN 4000591c: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40005920: c2 07 bf fc ld [ %fp + -4 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40005924: 91 d0 20 0a ta 0xa 40005928: 01 00 00 00 nop _Profiling_Thread_dispatch_enable( cpu_self, 0 ); _ISR_Local_enable( level ); _Thread_Run_post_switch_actions( executing ); } 4000592c: 81 c7 e0 08 ret 40005930: 81 e8 00 00 restore =============================================================================== 4000b970 <_Thread_Exit>: __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4000b970: 91 d0 20 09 ta 9 state |= set; 4000b974: c4 02 21 70 ld [ %o0 + 0x170 ], %g2 4000b978: 92 12 40 02 or %o1, %g2, %o1 the_thread->Life.exit_value = exit_value; 4000b97c: d4 22 21 78 st %o2, [ %o0 + 0x178 ] && _Thread_Is_life_changing( state ) 4000b980: 80 8a 60 06 btst 6, %o1 4000b984: 02 80 00 11 be 4000b9c8 <_Thread_Exit+0x58> <== NEVER TAKEN 4000b988: d2 22 21 70 st %o1, [ %o0 + 0x170 ] the_thread->budget_callout = the_thread->Start.budget_callout; 4000b98c: c4 02 20 b4 ld [ %o0 + 0xb4 ], %g2 the_thread->is_preemptible = the_thread->Start.is_preemptible; 4000b990: c8 0a 20 ac ldub [ %o0 + 0xac ], %g4 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000b994: c6 02 20 b0 ld [ %o0 + 0xb0 ], %g3 the_thread->budget_callout = the_thread->Start.budget_callout; 4000b998: c4 22 20 94 st %g2, [ %o0 + 0x94 ] action->handler = handler; 4000b99c: 05 10 00 2d sethi %hi(0x4000b400), %g2 the_thread->is_preemptible = the_thread->Start.is_preemptible; 4000b9a0: c8 2a 20 89 stb %g4, [ %o0 + 0x89 ] 4000b9a4: 84 10 a1 30 or %g2, 0x130, %g2 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000b9a8: c6 22 20 90 st %g3, [ %o0 + 0x90 ] 4000b9ac: c4 22 21 6c st %g2, [ %o0 + 0x16c ] cpu_self->dispatch_necessary = true; 4000b9b0: 84 10 20 01 mov 1, %g2 4000b9b4: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ] if ( _Chain_Is_node_off_chain( the_node ) ) { 4000b9b8: c4 02 21 64 ld [ %o0 + 0x164 ], %g2 4000b9bc: 80 a0 a0 00 cmp %g2, 0 4000b9c0: 22 80 00 06 be,a 4000b9d8 <_Thread_Exit+0x68> <== ALWAYS TAKEN 4000b9c4: c4 02 20 e8 ld [ %o0 + 0xe8 ], %g2 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000b9c8: 91 d0 20 0a ta 0xa 4000b9cc: 01 00 00 00 nop 0, set, THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED ); _Thread_State_release( executing, &lock_context ); } 4000b9d0: 81 c3 e0 08 retl 4000b9d4: 01 00 00 00 nop _Chain_Append_if_is_off_chain_unprotected( 4000b9d8: 86 02 21 64 add %o0, 0x164, %g3 return &the_chain->Tail.Node; 4000b9dc: 88 02 20 e4 add %o0, 0xe4, %g4 tail->previous = the_node; 4000b9e0: c6 22 20 e8 st %g3, [ %o0 + 0xe8 ] the_node->next = tail; 4000b9e4: c8 22 21 64 st %g4, [ %o0 + 0x164 ] old_last->next = the_node; 4000b9e8: c6 20 80 00 st %g3, [ %g2 ] } 4000b9ec: 10 bf ff f7 b 4000b9c8 <_Thread_Exit+0x58> 4000b9f0: c4 22 21 68 st %g2, [ %o0 + 0x168 ] =============================================================================== 400074fc <_Thread_Get_name>: size_t _Thread_Get_name( const Thread_Control *the_thread, char *buffer, size_t buffer_size ) { 400074fc: 9d e3 bf 98 save %sp, -104, %sp const char *name; name = the_thread->Join_queue.Queue.name; 40007500: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 { 40007504: 94 10 00 19 mov %i1, %o2 if ( name != NULL && name[ 0 ] != '\0' ) { 40007508: 80 a0 60 00 cmp %g1, 0 4000750c: 02 80 00 06 be 40007524 <_Thread_Get_name+0x28> <== NEVER TAKEN 40007510: 96 10 00 1a mov %i2, %o3 40007514: c4 48 40 00 ldsb [ %g1 ], %g2 40007518: 80 a0 a0 00 cmp %g2, 0 4000751c: 12 80 00 09 bne 40007540 <_Thread_Get_name+0x44> 40007520: b2 10 00 01 mov %g1, %i1 return strlcpy( buffer, name, buffer_size ); } else { return _Objects_Name_to_string( 40007524: c2 06 20 0c ld [ %i0 + 0xc ], %g1 40007528: c2 27 bf fc st %g1, [ %fp + -4 ] 4000752c: 92 10 20 00 clr %o1 40007530: 40 00 12 a7 call 4000bfcc <_Objects_Name_to_string> 40007534: 90 07 bf fc add %fp, -4, %o0 false, buffer, buffer_size ); } } 40007538: 81 c7 e0 08 ret 4000753c: 91 e8 00 08 restore %g0, %o0, %o0 return strlcpy( buffer, name, buffer_size ); 40007540: 40 00 27 7c call 40011330 40007544: 91 e8 00 0a restore %g0, %o2, %o0 =============================================================================== 400095f4 <_Thread_Initialize>: bool _Thread_Initialize( Thread_Information *information, Thread_Control *the_thread, const Thread_Configuration *config ) { 400095f4: 9d e3 bf 98 save %sp, -104, %sp Per_CPU_Control *cpu = _Per_CPU_Get_by_index( 0 ); memset( &the_thread->Join_queue, 0, information->Objects.object_size - offsetof( Thread_Control, Join_queue ) 400095f8: d4 16 20 14 lduh [ %i0 + 0x14 ], %o2 memset( 400095fc: 94 02 bf f0 add %o2, -16, %o2 40009600: 92 10 20 00 clr %o1 40009604: 40 00 1a 93 call 40010050 40009608: 90 06 60 10 add %i1, 0x10, %o0 ); for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) { 4000960c: 03 10 00 5e sethi %hi(0x40017800), %g1 40009610: fa 00 60 8c ld [ %g1 + 0x8c ], %i5 ! 4001788c <_Thread_Control_add_on_count> 40009614: 80 a7 60 00 cmp %i5, 0 40009618: 02 80 00 0d be 4000964c <_Thread_Initialize+0x58> <== NEVER TAKEN 4000961c: b8 10 00 18 mov %i0, %i4 40009620: 03 10 00 5e sethi %hi(0x40017800), %g1 40009624: 86 10 20 00 clr %g3 40009628: 82 10 60 90 or %g1, 0x90, %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; 4000962c: c4 00 60 04 ld [ %g1 + 4 ], %g2 *(void **) ( (char *) the_thread + add_on->destination_offset ) = 40009630: c8 00 40 00 ld [ %g1 ], %g4 (char *) the_thread + add_on->source_offset; 40009634: 84 06 40 02 add %i1, %g2, %g2 *(void **) ( (char *) the_thread + add_on->destination_offset ) = 40009638: c4 26 40 04 st %g2, [ %i1 + %g4 ] for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) { 4000963c: 86 00 e0 01 inc %g3 40009640: 80 a0 c0 1d cmp %g3, %i5 40009644: 12 bf ff fa bne 4000962c <_Thread_Initialize+0x38> 40009648: 82 00 60 08 add %g1, 8, %g1 } /* Set everything to perform the error case clean up */ the_thread->Start.stack_free = config->stack_free; 4000964c: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 40009650: c2 26 60 c8 st %g1, [ %i1 + 0xc8 ] ) { goto failed; } #endif stack_begin = config->stack_area; 40009654: f6 06 a0 04 ld [ %i2 + 4 ], %i3 stack_end = stack_begin + config->stack_size; 40009658: fa 06 a0 08 ld [ %i2 + 8 ], %i5 /* Allocate floating-point context in stack area */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( config->is_fp ) { 4000965c: c2 0e a0 28 ldub [ %i2 + 0x28 ], %g1 40009660: 80 a0 60 00 cmp %g1, 0 40009664: 02 80 00 05 be 40009678 <_Thread_Initialize+0x84> 40009668: ba 06 c0 1d add %i3, %i5, %i5 stack_end -= CONTEXT_FP_SIZE; 4000966c: ba 07 7f 78 add %i5, -136, %i5 the_thread->fp_context = (Context_Control_fp *) stack_end; 40009670: fa 26 61 50 st %i5, [ %i1 + 0x150 ] the_thread->Start.fp_context = (Context_Control_fp *) stack_end; 40009674: fa 26 60 d4 st %i5, [ %i1 + 0xd4 ] } #endif tls_size = _TLS_Get_allocation_size(); 40009678: 40 00 04 62 call 4000a800 <_TLS_Get_allocation_size> 4000967c: 01 00 00 00 nop /* Allocate thread-local storage (TLS) area in stack area */ if ( tls_size > 0 ) { 40009680: 80 a2 20 00 cmp %o0, 0 40009684: 22 80 00 0b be,a 400096b0 <_Thread_Initialize+0xbc> 40009688: ba 27 40 1b sub %i5, %i3, %i5 uintptr_t tls_align; stack_end -= tls_size; 4000968c: ba 27 40 08 sub %i5, %o0, %i5 tls_align = (uintptr_t) _TLS_Alignment; 40009690: 03 00 00 00 sethi %hi(0), %g1 40009694: 82 10 60 01 or %g1, 1, %g1 ! 1 <_TLS_Alignment> the_thread->Start.tls_area = (void *) ( ( (uintptr_t) stack_end + tls_align - 1 ) & ~( tls_align - 1 ) ); 40009698: 84 00 7f ff add %g1, -1, %g2 4000969c: 82 20 00 01 neg %g1 400096a0: 84 07 40 02 add %i5, %g2, %g2 400096a4: 82 08 80 01 and %g2, %g1, %g1 the_thread->Start.tls_area = (void *) 400096a8: c2 26 60 d8 st %g1, [ %i1 + 0xd8 ] } _Stack_Initialize( &the_thread->Start.Initial_stack, stack_begin, stack_end - stack_begin 400096ac: ba 27 40 1b sub %i5, %i3, %i5 old_first = head->next; 400096b0: c2 07 20 30 ld [ %i4 + 0x30 ], %g1 new_first = old_first->next; 400096b4: c4 00 40 00 ld [ %g1 ], %g2 the_stack->area = starting_address; 400096b8: f6 26 60 d0 st %i3, [ %i1 + 0xd0 ] return &the_chain->Head.Node; 400096bc: b6 07 20 30 add %i4, 0x30, %i3 the_stack->size = size; 400096c0: fa 26 60 cc st %i5, [ %i1 + 0xcc ] return &the_chain->Tail.Node; 400096c4: 86 00 60 30 add %g1, 0x30, %g3 head->next = new_first; 400096c8: c4 27 20 30 st %g2, [ %i4 + 0x30 ] return &the_chain->Tail.Node; 400096cc: 88 00 60 34 add %g1, 0x34, %g4 new_first->previous = head; 400096d0: f6 20 a0 04 st %i3, [ %g2 + 4 ] ); /* * Get thread queue heads */ the_thread->Wait.spare_heads = _Freechain_Pop( 400096d4: c2 26 60 5c st %g1, [ %i1 + 0x5c ] head->next = tail; 400096d8: c8 20 60 30 st %g4, [ %g1 + 0x30 ] tail->previous = head; 400096dc: c6 20 60 38 st %g3, [ %g1 + 0x38 ] head->previous = NULL; 400096e0: c0 20 60 34 clr [ %g1 + 0x34 ] */ the_thread->is_fp = config->is_fp; the_thread->Start.isr_level = config->isr_level; the_thread->Start.is_preemptible = config->is_preemptible; the_thread->Start.budget_algorithm = config->budget_algorithm; 400096e4: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1 the_thread->is_fp = config->is_fp; 400096e8: fa 0e a0 28 ldub [ %i2 + 0x28 ], %i5 the_thread->Start.isr_level = config->isr_level; 400096ec: c8 06 a0 24 ld [ %i2 + 0x24 ], %g4 the_thread->Start.is_preemptible = config->is_preemptible; 400096f0: c6 0e a0 29 ldub [ %i2 + 0x29 ], %g3 the_thread->Start.budget_callout = config->budget_callout; 400096f4: c4 06 a0 1c ld [ %i2 + 0x1c ], %g2 _Thread_Timer_initialize( &the_thread->Timer, cpu ); switch ( config->budget_algorithm ) { 400096f8: 80 a0 60 02 cmp %g1, 2 the_thread->Start.budget_algorithm = config->budget_algorithm; 400096fc: c2 26 60 b0 st %g1, [ %i1 + 0xb0 ] timer->header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ]; 40009700: 03 10 00 71 sethi %hi(0x4001c400), %g1 40009704: 82 10 63 f8 or %g1, 0x3f8, %g1 ! 4001c7f8 <_Per_CPU_Information+0x38> the_thread->is_fp = config->is_fp; 40009708: fa 2e 60 8a stb %i5, [ %i1 + 0x8a ] 4000970c: c2 26 60 60 st %g1, [ %i1 + 0x60 ] RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 40009710: 82 10 20 02 mov 2, %g1 the_thread->Start.isr_level = config->isr_level; 40009714: c8 26 60 b8 st %g4, [ %i1 + 0xb8 ] the_thread->Start.is_preemptible = config->is_preemptible; 40009718: c6 2e 60 ac stb %g3, [ %i1 + 0xac ] the_thread->Start.budget_callout = config->budget_callout; 4000971c: c4 26 60 b4 st %g2, [ %i1 + 0xb4 ] switch ( config->budget_algorithm ) { 40009720: 12 80 00 05 bne 40009734 <_Thread_Initialize+0x140> 40009724: c2 26 60 74 st %g1, [ %i1 + 0x74 ] case THREAD_CPU_BUDGET_ALGORITHM_NONE: 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 = 40009728: 03 10 00 5f sethi %hi(0x40017c00), %g1 4000972c: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 ! 40017dd0 <_Watchdog_Ticks_per_timeslice> 40009730: c2 26 60 8c st %g1, [ %i1 + 0x8c ] ( *scheduler->Operations.node_initialize )( 40009734: 94 10 00 19 mov %i1, %o2 &scheduler_node->Thread.Scheduler_node.Chain ); #else scheduler_node = _Thread_Scheduler_get_home_node( the_thread ); _Scheduler_Node_initialize( config->scheduler, 40009738: d0 06 80 00 ld [ %i2 ], %o0 return the_thread->Scheduler.nodes; 4000973c: fa 06 60 38 ld [ %i1 + 0x38 ], %i5 40009740: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 40009744: d6 06 a0 10 ld [ %i2 + 0x10 ], %o3 40009748: d8 06 a0 14 ld [ %i2 + 0x14 ], %o4 4000974c: 9f c0 40 00 call %g1 40009750: 92 10 00 1d mov %i5, %o1 config->priority ); scheduler_index = 1; #endif _Priority_Node_initialize( &the_thread->Real_priority, config->priority ); 40009754: c4 1e a0 10 ldd [ %i2 + 0x10 ], %g2 node->priority = priority; 40009758: c4 3e 60 30 std %g2, [ %i1 + 0x30 ] _RBTree_Initialize_one( &aggregation->Contributors, &node->Node.RBTree ); 4000975c: 82 06 60 20 add %i1, 0x20, %g1 node->priority = priority; 40009760: c4 3f 60 18 std %g2, [ %i5 + 0x18 ] #endif /* Initialize the CPU for the non-SMP schedulers */ _Thread_Set_CPU( the_thread, cpu ); the_thread->current_state = STATES_DORMANT; 40009764: 09 20 00 00 sethi %hi(0x80000000), %g4 RB_ROOT( the_rbtree ) = the_node; 40009768: c2 27 60 20 st %g1, [ %i5 + 0x20 ] return &the_chain->Tail.Node; 4000976c: 9e 06 60 e0 add %i1, 0xe0, %o7 40009770: f0 06 a0 20 ld [ %i2 + 0x20 ], %i0 the_object->name = name; 40009774: f0 26 60 0c st %i0, [ %i1 + 0xc ] 40009778: 9a 06 60 e4 add %i1, 0xe4, %o5 4000977c: c8 26 60 1c st %g4, [ %i1 + 0x1c ] the_thread->Wait.operations = &_Thread_queue_Operations_default; 40009780: 09 10 00 5f sethi %hi(0x40017c00), %g4 the_thread->Start.initial_priority = config->priority; 40009784: c4 3e 60 c0 std %g2, [ %i1 + 0xc0 ] the_thread->Wait.operations = &_Thread_queue_Operations_default; 40009788: 88 11 22 90 or %g4, 0x290, %g4 information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object; 4000978c: c2 16 60 0a lduh [ %i1 + 0xa ], %g1 RB_PARENT( the_node, Node ) = NULL; 40009790: c0 26 60 28 clr [ %i1 + 0x28 ] 40009794: 83 28 60 02 sll %g1, 2, %g1 RB_LEFT( the_node, Node ) = NULL; 40009798: c0 26 60 20 clr [ %i1 + 0x20 ] 4000979c: 82 00 7f fc add %g1, -4, %g1 RB_RIGHT( the_node, Node ) = NULL; 400097a0: c0 26 60 24 clr [ %i1 + 0x24 ] _User_extensions_Iterate( 400097a4: 94 10 20 00 clr %o2 RB_COLOR( the_node, Node ) = RB_BLACK; 400097a8: c0 26 60 2c clr [ %i1 + 0x2c ] 400097ac: 13 10 00 18 sethi %hi(0x40006000), %o1 400097b0: c8 26 60 58 st %g4, [ %i1 + 0x58 ] 400097b4: 92 12 62 58 or %o1, 0x258, %o1 RB_INIT( the_rbtree ); 400097b8: c0 26 61 60 clr [ %i1 + 0x160 ] 400097bc: 90 07 bf f8 add %fp, -8, %o0 head->next = tail; 400097c0: da 26 60 e0 st %o5, [ %i1 + 0xe0 ] head->previous = NULL; 400097c4: c0 26 60 e4 clr [ %i1 + 0xe4 ] tail->previous = head; 400097c8: de 26 60 e8 st %o7, [ %i1 + 0xe8 ] 400097cc: c4 07 20 04 ld [ %i4 + 4 ], %g2 400097d0: f2 20 80 01 st %i1, [ %g2 + %g1 ] User_extensions_Thread_create_context ctx = { created, true }; 400097d4: 82 10 20 01 mov 1, %g1 400097d8: f2 27 bf f8 st %i1, [ %fp + -8 ] _User_extensions_Iterate( 400097dc: 7f ff f2 f0 call 4000639c <_User_extensions_Iterate> 400097e0: 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 ) 400097e4: f0 0f bf fc ldub [ %fp + -4 ], %i0 400097e8: 80 a6 20 00 cmp %i0, 0 400097ec: 12 80 00 0f bne 40009828 <_Thread_Initialize+0x234> 400097f0: 01 00 00 00 nop --scheduler_index; _Scheduler_Node_destroy( scheduler_for_index, scheduler_node_for_index ); } #else if ( scheduler_index > 0 ) { _Scheduler_Node_destroy( config->scheduler, scheduler_node ); 400097f4: d0 06 80 00 ld [ %i2 ], %o0 ( *scheduler->Operations.node_destroy )( scheduler, node ); 400097f8: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 400097fc: 9f c0 40 00 call %g1 40009800: 92 10 00 1d mov %i5, %o1 } #endif _Freechain_Push( &information->Thread_queue_heads.Free, the_thread->Wait.spare_heads 40009804: c2 06 60 5c ld [ %i1 + 0x5c ], %g1 the_node->previous = after_node; 40009808: f6 20 60 04 st %i3, [ %g1 + 4 ] before_node = after_node->next; 4000980c: c4 07 20 30 ld [ %i4 + 0x30 ], %g2 after_node->next = the_node; 40009810: c2 27 20 30 st %g1, [ %i4 + 0x30 ] the_node->next = before_node; 40009814: c4 20 40 00 st %g2, [ %g1 ] before_node->previous = the_node; 40009818: c2 20 a0 04 st %g1, [ %g2 + 4 ] #if defined(RTEMS_SMP) || CPU_ENABLE_ROBUST_THREAD_DISPATCH == TRUE failed: #endif ( *the_thread->Start.stack_free )( the_thread->Start.Initial_stack.area ); 4000981c: c2 06 60 c8 ld [ %i1 + 0xc8 ], %g1 40009820: 9f c0 40 00 call %g1 40009824: d0 06 60 d0 ld [ %i1 + 0xd0 ], %o0 return false; } 40009828: 81 c7 e0 08 ret 4000982c: 81 e8 00 00 restore =============================================================================== 4000a9e8 <_Thread_Iterate>: void _Thread_Iterate( Thread_Visitor visitor, void *arg ) { 4000a9e8: 9d e3 bf a0 save %sp, -96, %sp int api_index; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; ++api_index ) { 4000a9ec: 35 10 00 6f sethi %hi(0x4001bc00), %i2 4000a9f0: 21 00 00 3f sethi %hi(0xfc00), %l0 4000a9f4: b4 16 a1 64 or %i2, 0x164, %i2 4000a9f8: a0 14 23 ff or %l0, 0x3ff, %l0 4000a9fc: a2 06 a0 0c add %i2, 0xc, %l1 const Objects_Information *information; Objects_Maximum maximum; Objects_Maximum index; _Assert( _Objects_Information_table[ api_index ] != NULL ); information = _Objects_Information_table[ api_index ][ 1 ]; 4000aa00: c2 06 a0 04 ld [ %i2 + 4 ], %g1 4000aa04: f8 00 60 04 ld [ %g1 + 4 ], %i4 if ( information == NULL ) { 4000aa08: 80 a7 20 00 cmp %i4, 0 4000aa0c: 22 80 00 18 be,a 4000aa6c <_Thread_Iterate+0x84> 4000aa10: b4 06 a0 04 add %i2, 4, %i2 continue; } maximum = _Objects_Get_maximum_index( information ); for ( index = 0 ; index < maximum ; ++index ) { 4000aa14: c2 17 20 02 lduh [ %i4 + 2 ], %g1 4000aa18: 80 a0 60 00 cmp %g1, 0 4000aa1c: 02 80 00 13 be 4000aa68 <_Thread_Iterate+0x80> <== NEVER TAKEN 4000aa20: f6 07 00 00 ld [ %i4 ], %i3 4000aa24: b6 0e c0 10 and %i3, %l0, %i3 4000aa28: ba 10 20 00 clr %i5 4000aa2c: b7 2e e0 02 sll %i3, 2, %i3 Thread_Control *the_thread; the_thread = (Thread_Control *) information->local_table[ index ]; 4000aa30: c2 07 20 04 ld [ %i4 + 4 ], %g1 4000aa34: d0 00 40 1d ld [ %g1 + %i5 ], %o0 if ( the_thread != NULL ) { 4000aa38: 80 a2 20 00 cmp %o0, 0 4000aa3c: 02 80 00 07 be 4000aa58 <_Thread_Iterate+0x70> 4000aa40: 92 10 00 19 mov %i1, %o1 bool done; done = (* visitor )( the_thread, arg ); 4000aa44: 9f c6 00 00 call %i0 4000aa48: 01 00 00 00 nop if ( done ) { 4000aa4c: 80 a2 20 00 cmp %o0, 0 4000aa50: 12 80 00 0c bne 4000aa80 <_Thread_Iterate+0x98> <== NEVER TAKEN 4000aa54: 01 00 00 00 nop for ( index = 0 ; index < maximum ; ++index ) { 4000aa58: ba 07 60 04 add %i5, 4, %i5 4000aa5c: 80 a6 c0 1d cmp %i3, %i5 4000aa60: 32 bf ff f5 bne,a 4000aa34 <_Thread_Iterate+0x4c> 4000aa64: c2 07 20 04 ld [ %i4 + 4 ], %g1 for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; ++api_index ) { 4000aa68: b4 06 a0 04 add %i2, 4, %i2 4000aa6c: 80 a4 40 1a cmp %l1, %i2 4000aa70: 32 bf ff e5 bne,a 4000aa04 <_Thread_Iterate+0x1c> 4000aa74: c2 06 a0 04 ld [ %i2 + 4 ], %g1 return; } } } } } 4000aa78: 81 c7 e0 08 ret 4000aa7c: 81 e8 00 00 restore 4000aa80: 81 c7 e0 08 ret <== NOT EXECUTED 4000aa84: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40005d54 <_Thread_Kill_zombies>: { 40005d54: 9d e3 bf a0 save %sp, -96, %sp __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40005d58: 91 d0 20 09 ta 9 return _Chain_Immutable_head( the_chain )->next; 40005d5c: 05 10 00 6b sethi %hi(0x4001ac00), %g2 40005d60: fa 00 a1 5c ld [ %g2 + 0x15c ], %i5 ! 4001ad5c <_Thread_Zombies> 40005d64: b6 10 a1 5c or %g2, 0x15c, %i3 if ( !_Chain_Is_empty(the_chain)) 40005d68: b0 06 e0 04 add %i3, 4, %i0 40005d6c: 80 a7 40 18 cmp %i5, %i0 40005d70: 02 80 00 48 be 40005e90 <_Thread_Kill_zombies+0x13c> 40005d74: 01 00 00 00 nop new_first = old_first->next; 40005d78: c6 07 40 00 ld [ %i5 ], %g3 head->next = new_first; 40005d7c: c6 20 a1 5c st %g3, [ %g2 + 0x15c ] _User_extensions_Iterate( 40005d80: 33 10 00 18 sethi %hi(0x40006000), %i1 new_first->previous = head; 40005d84: f6 20 e0 04 st %i3, [ %g3 + 4 ] while ( the_thread != NULL ) { 40005d88: 35 10 00 5e sethi %hi(0x40017800), %i2 40005d8c: b2 16 62 98 or %i1, 0x298, %i1 40005d90: b4 16 a0 c0 or %i2, 0xc0, %i2 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40005d94: 91 d0 20 0a ta 0xa 40005d98: 01 00 00 00 nop _Objects_Get_information_id( the_thread->Object.id ); 40005d9c: 40 00 0a 79 call 40008780 <_Objects_Get_information_id> 40005da0: d0 07 60 08 ld [ %i5 + 8 ], %o0 40005da4: 94 10 20 01 mov 1, %o2 40005da8: b8 10 00 08 mov %o0, %i4 40005dac: 92 10 00 19 mov %i1, %o1 40005db0: 40 00 01 7b call 4000639c <_User_extensions_Iterate> 40005db4: 90 10 00 1d mov %i5, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40005db8: 91 d0 20 09 ta 9 iter = the_thread->last_user_extensions_iterator; 40005dbc: c4 07 61 8c ld [ %i5 + 0x18c ], %g2 while ( iter != NULL ) { 40005dc0: 80 a0 a0 00 cmp %g2, 0 40005dc4: 02 80 00 0a be 40005dec <_Thread_Kill_zombies+0x98> 40005dc8: 01 00 00 00 nop next = the_node->next; 40005dcc: c8 00 80 00 ld [ %g2 ], %g4 previous = the_node->previous; 40005dd0: c6 00 a0 04 ld [ %g2 + 4 ], %g3 next->previous = previous; 40005dd4: c6 21 20 04 st %g3, [ %g4 + 4 ] previous->next = next; 40005dd8: c8 20 c0 00 st %g4, [ %g3 ] iter = iter->previous; 40005ddc: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 while ( iter != NULL ) { 40005de0: 80 a0 a0 00 cmp %g2, 0 40005de4: 32 bf ff fb bne,a 40005dd0 <_Thread_Kill_zombies+0x7c> <== NEVER TAKEN 40005de8: c8 00 80 00 ld [ %g2 ], %g4 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40005dec: 91 d0 20 0a ta 0xa 40005df0: 01 00 00 00 nop ( *scheduler->Operations.node_destroy )( scheduler, node ); 40005df4: d2 07 60 38 ld [ %i5 + 0x38 ], %o1 40005df8: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1 40005dfc: 9f c0 40 00 call %g1 40005e00: 90 10 00 1a mov %i2, %o0 the_thread->Wait.spare_heads 40005e04: c2 07 60 5c ld [ %i5 + 0x5c ], %g1 return &the_chain->Head.Node; 40005e08: 84 07 20 30 add %i4, 0x30, %g2 the_node->previous = after_node; 40005e0c: c4 20 60 04 st %g2, [ %g1 + 4 ] before_node = after_node->next; 40005e10: c4 07 20 30 ld [ %i4 + 0x30 ], %g2 after_node->next = the_node; 40005e14: c2 27 20 30 st %g1, [ %i4 + 0x30 ] the_node->next = before_node; 40005e18: c4 20 40 00 st %g2, [ %g1 ] before_node->previous = the_node; 40005e1c: c2 20 a0 04 st %g1, [ %g2 + 4 ] ( *the_thread->Start.stack_free )( the_thread->Start.Initial_stack.area ); 40005e20: c2 07 60 c8 ld [ %i5 + 0xc8 ], %g1 40005e24: 9f c0 40 00 call %g1 40005e28: d0 07 60 d0 ld [ %i5 + 0xd0 ], %o0 _Context_Destroy( the_thread, &the_thread->Registers ); 40005e2c: c4 01 a0 04 ld [ %g6 + 4 ], %g2 40005e30: 80 a0 80 1d cmp %g2, %i5 40005e34: 02 80 00 0e be 40005e6c <_Thread_Kill_zombies+0x118> 40005e38: 92 10 00 1d mov %i5, %o1 Objects_Control *the_object ) { _Assert( _Objects_Allocator_is_owner() ); _Assert( information->deallocate != NULL ); ( *information->deallocate )( information, the_object ); 40005e3c: c2 07 20 0c ld [ %i4 + 0xc ], %g1 40005e40: 9f c0 40 00 call %g1 40005e44: 90 10 00 1c mov %i4, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40005e48: 91 d0 20 09 ta 9 return _Chain_Immutable_head( the_chain )->next; 40005e4c: fa 06 c0 00 ld [ %i3 ], %i5 if ( !_Chain_Is_empty(the_chain)) 40005e50: 80 a7 40 18 cmp %i5, %i0 40005e54: 02 80 00 0f be 40005e90 <_Thread_Kill_zombies+0x13c> 40005e58: 01 00 00 00 nop new_first = old_first->next; 40005e5c: c4 07 40 00 ld [ %i5 ], %g2 head->next = new_first; 40005e60: c4 26 c0 00 st %g2, [ %i3 ] new_first->previous = head; 40005e64: 10 bf ff cc b 40005d94 <_Thread_Kill_zombies+0x40> 40005e68: f6 20 a0 04 st %i3, [ %g2 + 4 ] 40005e6c: c0 21 a0 04 clr [ %g6 + 4 ] 40005e70: c2 07 20 0c ld [ %i4 + 0xc ], %g1 40005e74: 9f c0 40 00 call %g1 40005e78: 90 10 00 1c mov %i4, %o0 40005e7c: 91 d0 20 09 ta 9 return _Chain_Immutable_head( the_chain )->next; 40005e80: fa 06 c0 00 ld [ %i3 ], %i5 if ( !_Chain_Is_empty(the_chain)) 40005e84: 80 a7 40 18 cmp %i5, %i0 40005e88: 32 bf ff f6 bne,a 40005e60 <_Thread_Kill_zombies+0x10c> 40005e8c: c4 07 40 00 ld [ %i5 ], %g2 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40005e90: 91 d0 20 0a ta 0xa 40005e94: 01 00 00 00 nop } 40005e98: 81 c7 e0 08 ret 40005e9c: 81 e8 00 00 restore =============================================================================== 4000d19c <_Thread_Priority_add>: void _Thread_Priority_add( Thread_Control *the_thread, Priority_Node *priority_node, Thread_queue_Context *queue_context ) { 4000d19c: 9d e3 bf a0 save %sp, -96, %sp return the_thread->Scheduler.nodes; 4000d1a0: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 aggregation->Action.node = node; 4000d1a4: f2 20 60 24 st %i1, [ %g1 + 0x24 ] _Priority_Actions_initialize_one( 4000d1a8: 82 00 60 08 add %g1, 8, %g1 aggregation->Action.type = type; 4000d1ac: c0 20 60 20 clr [ %g1 + 0x20 ] _Thread_Priority_do_perform_actions( 4000d1b0: 98 10 00 1a mov %i2, %o4 actions->actions = aggregation; 4000d1b4: c2 26 a0 10 st %g1, [ %i2 + 0x10 ] 4000d1b8: 96 10 20 00 clr %o3 queue = the_thread->Wait.queue; 4000d1bc: fa 06 20 54 ld [ %i0 + 0x54 ], %i5 _Thread_Priority_do_perform_actions( 4000d1c0: d4 06 20 58 ld [ %i0 + 0x58 ], %o2 4000d1c4: 92 10 00 1d mov %i5, %o1 4000d1c8: 7f ff ff 24 call 4000ce58 <_Thread_Priority_do_perform_actions> 4000d1cc: 90 10 00 18 mov %i0, %o0 if ( !_Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) { 4000d1d0: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 4000d1d4: 80 a0 60 00 cmp %g1, 0 4000d1d8: 02 80 00 10 be 4000d218 <_Thread_Priority_add+0x7c> <== ALWAYS TAKEN 4000d1dc: 01 00 00 00 nop _Thread_Priority_perform_actions( queue->owner, queue_context ); 4000d1e0: d0 07 60 04 ld [ %i5 + 4 ], %o0 <== NOT EXECUTED return queue_context->Priority.update_count; 4000d1e4: 10 80 00 03 b 4000d1f0 <_Thread_Priority_add+0x54> <== NOT EXECUTED 4000d1e8: f8 06 a0 14 ld [ %i2 + 0x14 ], %i4 <== NOT EXECUTED queue_context->Priority.update_count = update_count; 4000d1ec: f8 26 a0 14 st %i4, [ %i2 + 0x14 ] <== NOT EXECUTED _Thread_Priority_do_perform_actions( 4000d1f0: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED queue = the_thread->Wait.queue; 4000d1f4: fa 02 20 54 ld [ %o0 + 0x54 ], %i5 <== NOT EXECUTED _Thread_Priority_do_perform_actions( 4000d1f8: d4 02 20 58 ld [ %o0 + 0x58 ], %o2 <== NOT EXECUTED 4000d1fc: 96 10 20 00 clr %o3 <== NOT EXECUTED 4000d200: 7f ff ff 16 call 4000ce58 <_Thread_Priority_do_perform_actions> <== NOT EXECUTED 4000d204: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED if ( _Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) { 4000d208: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED 4000d20c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000d210: 32 bf ff f7 bne,a 4000d1ec <_Thread_Priority_add+0x50> <== NOT EXECUTED 4000d214: d0 07 60 04 ld [ %i5 + 4 ], %o0 <== NOT EXECUTED priority_node, queue_context, false, PRIORITY_ACTION_ADD ); } 4000d218: 81 c7 e0 08 ret 4000d21c: 81 e8 00 00 restore =============================================================================== 4000d220 <_Thread_Priority_remove>: void _Thread_Priority_remove( Thread_Control *the_thread, Priority_Node *priority_node, Thread_queue_Context *queue_context ) { 4000d220: 9d e3 bf a0 save %sp, -96, %sp 4000d224: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 aggregation->Action.node = node; 4000d228: f2 20 60 24 st %i1, [ %g1 + 0x24 ] aggregation->Action.type = type; 4000d22c: 84 10 20 02 mov 2, %g2 4000d230: c4 20 60 28 st %g2, [ %g1 + 0x28 ] _Priority_Actions_initialize_one( 4000d234: 82 00 60 08 add %g1, 8, %g1 actions->actions = aggregation; 4000d238: c2 26 a0 10 st %g1, [ %i2 + 0x10 ] _Thread_Priority_do_perform_actions( 4000d23c: 98 10 00 1a mov %i2, %o4 queue = the_thread->Wait.queue; 4000d240: fa 06 20 54 ld [ %i0 + 0x54 ], %i5 _Thread_Priority_do_perform_actions( 4000d244: d4 06 20 58 ld [ %i0 + 0x58 ], %o2 4000d248: 96 10 20 01 mov 1, %o3 4000d24c: 92 10 00 1d mov %i5, %o1 4000d250: 7f ff ff 02 call 4000ce58 <_Thread_Priority_do_perform_actions> 4000d254: 90 10 00 18 mov %i0, %o0 if ( !_Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) { 4000d258: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 4000d25c: 80 a0 60 00 cmp %g1, 0 4000d260: 02 80 00 10 be 4000d2a0 <_Thread_Priority_remove+0x80> <== ALWAYS TAKEN 4000d264: 01 00 00 00 nop _Thread_Priority_perform_actions( queue->owner, queue_context ); 4000d268: d0 07 60 04 ld [ %i5 + 4 ], %o0 <== NOT EXECUTED return queue_context->Priority.update_count; 4000d26c: 10 80 00 03 b 4000d278 <_Thread_Priority_remove+0x58> <== NOT EXECUTED 4000d270: f8 06 a0 14 ld [ %i2 + 0x14 ], %i4 <== NOT EXECUTED queue_context->Priority.update_count = update_count; 4000d274: f8 26 a0 14 st %i4, [ %i2 + 0x14 ] <== NOT EXECUTED _Thread_Priority_do_perform_actions( 4000d278: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED queue = the_thread->Wait.queue; 4000d27c: fa 02 20 54 ld [ %o0 + 0x54 ], %i5 <== NOT EXECUTED _Thread_Priority_do_perform_actions( 4000d280: d4 02 20 58 ld [ %o0 + 0x58 ], %o2 <== NOT EXECUTED 4000d284: 96 10 20 00 clr %o3 <== NOT EXECUTED 4000d288: 7f ff fe f4 call 4000ce58 <_Thread_Priority_do_perform_actions> <== NOT EXECUTED 4000d28c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED if ( _Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) { 4000d290: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED 4000d294: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000d298: 32 bf ff f7 bne,a 4000d274 <_Thread_Priority_remove+0x54> <== NOT EXECUTED 4000d29c: d0 07 60 04 ld [ %i5 + 4 ], %o0 <== NOT EXECUTED priority_node, queue_context, true, PRIORITY_ACTION_REMOVE ); } 4000d2a0: 81 c7 e0 08 ret 4000d2a4: 81 e8 00 00 restore =============================================================================== 40006224 <_Thread_Restart_other>: bool _Thread_Restart_other( Thread_Control *the_thread, const Thread_Entry_information *entry, ISR_lock_Context *lock_context ) { 40006224: 9d e3 bf 98 save %sp, -104, %sp Thread_Life_state previous; Per_CPU_Control *cpu_self; _Thread_State_acquire_critical( the_thread, lock_context ); if ( _States_Is_dormant( the_thread->current_state ) ) { 40006228: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 4000622c: 80 a0 60 00 cmp %g1, 0 40006230: 06 80 00 3f bl 4000632c <_Thread_Restart_other+0x108> 40006234: 96 10 20 00 clr %o3 _Thread_State_release( the_thread, lock_context ); return false; } the_thread->Start.Entry = *entry; 40006238: c2 06 40 00 ld [ %i1 ], %g1 4000623c: c2 26 20 a0 st %g1, [ %i0 + 0xa0 ] 40006240: c2 06 60 04 ld [ %i1 + 4 ], %g1 40006244: c2 26 20 a4 st %g1, [ %i0 + 0xa4 ] previous = _Thread_Change_life_locked( 40006248: 94 10 20 02 mov 2, %o2 the_thread->Start.Entry = *entry; 4000624c: c2 06 60 08 ld [ %i1 + 8 ], %g1 40006250: c2 26 20 a8 st %g1, [ %i0 + 0xa8 ] previous = _Thread_Change_life_locked( 40006254: 92 10 20 00 clr %o1 40006258: 7f ff fe 75 call 40005c2c <_Thread_Change_life_locked> 4000625c: 90 10 00 18 mov %i0, %o0 disable_level = cpu_self->thread_dispatch_disable_level; 40006260: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 cpu_self->thread_dispatch_disable_level = disable_level + 1; 40006264: 82 00 60 01 inc %g1 40006268: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] 0 ); cpu_self = _Thread_Dispatch_disable_critical( lock_context ); if ( _Thread_Is_life_change_allowed( previous ) ) { 4000626c: 80 8a 20 09 btst 9, %o0 40006270: 02 80 00 0e be 400062a8 <_Thread_Restart_other+0x84> <== ALWAYS TAKEN 40006274: ba 10 00 06 mov %g6, %i5 _Thread_Finalize_life_change( the_thread, the_thread->Start.initial_priority ); } else { _Thread_Clear_state_locked( the_thread, STATES_SUSPENDED ); 40006278: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED 4000627c: 40 00 0f 19 call 40009ee0 <_Thread_Clear_state_locked> <== NOT EXECUTED 40006280: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40006284: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40006288: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000628c: 01 00 00 00 nop <== NOT EXECUTED _Thread_State_release( the_thread, lock_context ); } _Thread_Dispatch_enable( cpu_self ); 40006290: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 40006294: 7f ff fd e6 call 40005a2c <_Thread_Dispatch_enable> 40006298: b0 10 20 01 mov 1, %i0 return true; } 4000629c: b0 0e 20 01 and %i0, 1, %i0 400062a0: 81 c7 e0 08 ret 400062a4: 81 e8 00 00 restore pending_requests = the_thread->Life.pending_life_change_requests; 400062a8: c2 06 21 74 ld [ %i0 + 0x174 ], %g1 the_thread->Life.pending_life_change_requests = pending_requests + 1; 400062ac: 84 00 60 01 add %g1, 1, %g2 if ( pending_requests == 0 ) { 400062b0: 80 a0 60 00 cmp %g1, 0 400062b4: 02 80 00 25 be 40006348 <_Thread_Restart_other+0x124> <== ALWAYS TAKEN 400062b8: c4 26 21 74 st %g2, [ %i0 + 0x174 ] register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400062bc: c2 06 80 00 ld [ %i2 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400062c0: 91 d0 20 0a ta 0xa 400062c4: 01 00 00 00 nop _Thread_Finalize_life_change( 400062c8: f4 1e 20 c0 ldd [ %i0 + 0xc0 ], %i2 _Thread_queue_Extract_with_proxy( the_thread ); 400062cc: 40 00 11 00 call 4000a6cc <_Thread_queue_Extract_with_proxy> 400062d0: 90 10 00 18 mov %i0, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400062d4: 91 d0 20 09 ta 9 return psr; 400062d8: c2 27 bf fc st %g1, [ %fp + -4 ] 400062dc: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 400062e0: 40 00 02 75 call 40006cb4 <_Watchdog_Remove> 400062e4: 92 06 20 68 add %i0, 0x68, %o1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400062e8: c2 07 bf fc ld [ %fp + -4 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400062ec: 91 d0 20 0a ta 0xa 400062f0: 01 00 00 00 nop _Thread_Raise_real_priority( the_thread, priority ); 400062f4: 92 10 00 1a mov %i2, %o1 400062f8: 94 10 00 1b mov %i3, %o2 400062fc: 7f ff fe 28 call 40005b9c <_Thread_Raise_real_priority> 40006300: 90 10 00 18 mov %i0, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40006304: 91 d0 20 09 ta 9 pending_requests = the_thread->Life.pending_life_change_requests; 40006308: c4 06 21 74 ld [ %i0 + 0x174 ], %g2 the_thread->Life.pending_life_change_requests = pending_requests - 1; 4000630c: 86 00 bf ff add %g2, -1, %g3 if ( pending_requests == 1 ) { 40006310: 80 a0 a0 01 cmp %g2, 1 40006314: 02 80 00 11 be 40006358 <_Thread_Restart_other+0x134> <== ALWAYS TAKEN 40006318: c6 26 21 74 st %g3, [ %i0 + 0x174 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000631c: 91 d0 20 0a ta 0xa 40006320: 01 00 00 00 nop } 40006324: 10 bf ff dc b 40006294 <_Thread_Restart_other+0x70> 40006328: 90 10 00 1d mov %i5, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000632c: c2 06 80 00 ld [ %i2 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40006330: 91 d0 20 0a ta 0xa 40006334: 01 00 00 00 nop return false; 40006338: b0 10 20 00 clr %i0 ! 0 } 4000633c: b0 0e 20 01 and %i0, 1, %i0 40006340: 81 c7 e0 08 ret 40006344: 81 e8 00 00 restore _Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING ); 40006348: 13 00 00 80 sethi %hi(0x20000), %o1 4000634c: 40 00 00 62 call 400064d4 <_Thread_Set_state_locked> 40006350: 90 10 00 18 mov %i0, %o0 40006354: 30 bf ff da b,a 400062bc <_Thread_Restart_other+0x98> 40006358: c2 27 bf fc st %g1, [ %fp + -4 ] _Thread_Clear_state_locked( 4000635c: 90 10 00 18 mov %i0, %o0 40006360: 13 0c 00 a0 sethi %hi(0x30028000), %o1 40006364: 40 00 0e df call 40009ee0 <_Thread_Clear_state_locked> 40006368: 92 12 63 0c or %o1, 0x30c, %o1 ! 3002830c 4000636c: 10 bf ff ec b 4000631c <_Thread_Restart_other+0xf8> 40006370: c2 07 bf fc ld [ %fp + -4 ], %g1 =============================================================================== 40006374 <_Thread_Restart_self>: void _Thread_Restart_self( Thread_Control *executing, const Thread_Entry_information *entry, ISR_lock_Context *lock_context ) { 40006374: 9d e3 bf 78 save %sp, -136, %sp _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_clear_priority_updates( &queue_context ); _Thread_State_acquire_critical( executing, lock_context ); executing->Start.Entry = *entry; 40006378: c2 06 40 00 ld [ %i1 ], %g1 4000637c: c2 26 20 a0 st %g1, [ %i0 + 0xa0 ] _Thread_Change_life_locked( 40006380: 96 10 20 09 mov 9, %o3 executing->Start.Entry = *entry; 40006384: c2 06 60 04 ld [ %i1 + 4 ], %g1 40006388: c2 26 20 a4 st %g1, [ %i0 + 0xa4 ] _Thread_Change_life_locked( 4000638c: 94 10 20 02 mov 2, %o2 executing->Start.Entry = *entry; 40006390: c2 06 60 08 ld [ %i1 + 8 ], %g1 40006394: c2 26 20 a8 st %g1, [ %i0 + 0xa8 ] _Thread_Change_life_locked( 40006398: 92 10 20 00 clr %o1 queue_context->Priority.update_count = 0; 4000639c: c0 27 bf f0 clr [ %fp + -16 ] 400063a0: 7f ff fe 23 call 40005c2c <_Thread_Change_life_locked> 400063a4: 90 10 00 18 mov %i0, %o0 disable_level = cpu_self->thread_dispatch_disable_level; 400063a8: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 cpu_self->thread_dispatch_disable_level = disable_level + 1; 400063ac: 82 00 60 01 inc %g1 return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 400063b0: ba 10 00 06 mov %g6, %i5 cpu_self->thread_dispatch_disable_level = disable_level + 1; 400063b4: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400063b8: c2 06 80 00 ld [ %i2 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400063bc: 91 d0 20 0a ta 0xa 400063c0: 01 00 00 00 nop __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400063c4: 91 d0 20 09 ta 9 _ISR_lock_ISR_disable( lock_context ); 400063c8: c2 26 80 00 st %g1, [ %i2 ] node->priority = priority; 400063cc: c4 1e 20 c0 ldd [ %i0 + 0xc0 ], %g2 400063d0: c4 3e 20 30 std %g2, [ %i0 + 0x30 ] _Thread_Priority_changed( 400063d4: 94 10 20 00 clr %o2 400063d8: 96 07 bf dc add %fp, -36, %o3 400063dc: 92 06 20 20 add %i0, 0x20, %o1 400063e0: 7f ff fd 07 call 400057fc <_Thread_Priority_changed> 400063e4: 90 10 00 18 mov %i0, %o0 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400063e8: c2 06 80 00 ld [ %i2 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400063ec: 91 d0 20 0a ta 0xa 400063f0: 01 00 00 00 nop false, &queue_context ); _Thread_Wait_release_default( executing, lock_context ); _Thread_Priority_update( &queue_context ); 400063f4: 7f ff fd 24 call 40005884 <_Thread_Priority_update> 400063f8: 90 07 bf dc add %fp, -36, %o0 _Thread_Dispatch_direct( cpu_self ); 400063fc: 7f ff fd 81 call 40005a00 <_Thread_Dispatch_direct> 40006400: 90 10 00 1d mov %i5, %o0 RTEMS_UNREACHABLE(); 40006404: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 4000a7e4 <_Thread_Start_multitasking>: #include #include void _Thread_Start_multitasking( void ) { 4000a7e4: 9d e3 bf a0 save %sp, -96, %sp heir = cpu_self->heir; 4000a7e8: c4 01 a0 24 ld [ %g6 + 0x24 ], %g2 cpu_self->dispatch_necessary = false; 4000a7ec: 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 ); 4000a7f0: 90 00 a0 f0 add %g2, 0xf0, %o0 4000a7f4: 7f ff f0 49 call 40006918 <_CPU_Context_restore> 4000a7f8: c4 21 a0 20 st %g2, [ %g6 + 0x20 ] 4000a7fc: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40008968 <_Thread_Wait_get_id>: if ( _States_Is_waiting_for_rpc_reply( the_thread->current_state ) ) { return the_thread->Wait.remote_id; } #endif queue = the_thread->Wait.queue; 40008968: c2 02 20 54 ld [ %o0 + 0x54 ], %g1 if ( queue != NULL && queue->name == _Thread_queue_Object_name ) { 4000896c: 80 a0 60 00 cmp %g1, 0 40008970: 02 80 00 08 be 40008990 <_Thread_Wait_get_id+0x28> 40008974: 90 10 20 00 clr %o0 40008978: c6 00 60 08 ld [ %g1 + 8 ], %g3 4000897c: 05 10 00 43 sethi %hi(0x40010c00), %g2 40008980: 84 10 a2 a8 or %g2, 0x2a8, %g2 ! 40010ea8 <_Thread_queue_Object_name> 40008984: 80 a0 c0 02 cmp %g3, %g2 40008988: 02 80 00 04 be 40008998 <_Thread_Wait_get_id+0x30> <== ALWAYS TAKEN 4000898c: 01 00 00 00 nop queue_object = THREAD_QUEUE_QUEUE_TO_OBJECT( queue ); return queue_object->Object.id; } return 0; } 40008990: 81 c3 e0 08 retl 40008994: 01 00 00 00 nop 40008998: 81 c3 e0 08 retl 4000899c: d0 00 7f f8 ld [ %g1 + -8 ], %o0 =============================================================================== 40006184 <_Thread_Yield>: #include #include void _Thread_Yield( Thread_Control *executing ) { 40006184: 9d e3 bf 98 save %sp, -104, %sp __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40006188: 91 d0 20 09 ta 9 ISR_lock_Context lock_context; _Thread_State_acquire( executing, &lock_context ); if ( _States_Is_ready( executing->current_state ) ) { 4000618c: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 40006190: 80 a0 a0 00 cmp %g2, 0 40006194: 12 80 00 09 bne 400061b8 <_Thread_Yield+0x34> <== NEVER TAKEN 40006198: 11 10 00 5e sethi %hi(0x40017800), %o0 ( *scheduler->Operations.yield )( 4000619c: d4 06 20 38 ld [ %i0 + 0x38 ], %o2 400061a0: 90 12 20 c0 or %o0, 0xc0, %o0 400061a4: c4 02 20 0c ld [ %o0 + 0xc ], %g2 400061a8: c2 27 bf fc st %g1, [ %fp + -4 ] 400061ac: 9f c0 80 00 call %g2 400061b0: 92 10 00 18 mov %i0, %o1 400061b4: c2 07 bf fc ld [ %fp + -4 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400061b8: 91 d0 20 0a ta 0xa 400061bc: 01 00 00 00 nop _Scheduler_Yield( executing ); } _Thread_State_release( executing, &lock_context ); } 400061c0: 81 c7 e0 08 ret 400061c4: 81 e8 00 00 restore =============================================================================== 400098f0 <_Thread_queue_Deadlock_fatal>: { 400098f0: 9d e3 bf a0 save %sp, -96, %sp _Internal_error( INTERNAL_ERROR_THREAD_QUEUE_DEADLOCK ); 400098f4: 7f ff ec 32 call 400049bc <_Internal_error> 400098f8: 90 10 20 1c mov 0x1c, %o0 400098fc: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40009900 <_Thread_queue_Enqueue>: { 40009900: 9d e3 bf 98 save %sp, -104, %sp the_thread->Wait.queue = queue; 40009904: f0 26 a0 54 st %i0, [ %i2 + 0x54 ] 40009908: 90 10 00 18 mov %i0, %o0 } 4000990c: 10 80 00 08 b 4000992c <_Thread_queue_Enqueue+0x2c> 40009910: 82 10 00 18 mov %i0, %g1 if ( owner == the_thread ) { 40009914: 22 80 00 48 be,a 40009a34 <_Thread_queue_Enqueue+0x134> 40009918: c0 26 a0 54 clr [ %i2 + 0x54 ] queue = owner->Wait.queue; 4000991c: c2 00 60 54 ld [ %g1 + 0x54 ], %g1 } while ( queue != NULL ); 40009920: 80 a0 60 00 cmp %g1, 0 40009924: 22 80 00 07 be,a 40009940 <_Thread_queue_Enqueue+0x40> 40009928: c0 26 e0 14 clr [ %i3 + 0x14 ] owner = queue->owner; 4000992c: c2 00 60 04 ld [ %g1 + 4 ], %g1 if ( owner == NULL ) { 40009930: 80 a0 60 00 cmp %g1, 0 40009934: 12 bf ff f8 bne 40009914 <_Thread_queue_Enqueue+0x14> 40009938: 80 a6 80 01 cmp %i2, %g1 queue_context->Priority.update_count = 0; 4000993c: c0 26 e0 14 clr [ %i3 + 0x14 ] ( *operations->enqueue )( queue, the_thread, queue_context ); 40009940: 94 10 00 1b mov %i3, %o2 the_thread->Wait.operations = operations; 40009944: f2 26 a0 58 st %i1, [ %i2 + 0x58 ] 40009948: 92 10 00 1a mov %i2, %o1 4000994c: c2 06 60 04 ld [ %i1 + 4 ], %g1 40009950: 9f c0 40 00 call %g1 40009954: d0 27 bf fc st %o0, [ %fp + -4 ] the_thread->Wait.flags = flags; 40009958: 84 10 24 01 mov 0x401, %g2 disable_level = cpu_self->thread_dispatch_disable_level; 4000995c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 the_thread->Wait.return_code = STATUS_SUCCESSFUL; 40009960: c0 26 a0 4c clr [ %i2 + 0x4c ] cpu_self->thread_dispatch_disable_level = disable_level + 1; 40009964: 82 00 60 01 inc %g1 40009968: c4 26 a0 50 st %g2, [ %i2 + 0x50 ] return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 4000996c: b0 10 00 06 mov %g6, %i0 cpu_self->thread_dispatch_disable_level = disable_level + 1; 40009970: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40009974: c2 06 c0 00 ld [ %i3 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009978: 91 d0 20 0a ta 0xa 4000997c: 01 00 00 00 nop ( *queue_context->enqueue_callout )( 40009980: c2 06 e0 08 ld [ %i3 + 8 ], %g1 40009984: d0 07 bf fc ld [ %fp + -4 ], %o0 40009988: 96 10 00 1b mov %i3, %o3 4000998c: 94 10 00 06 mov %g6, %o2 40009990: 9f c0 40 00 call %g1 40009994: 92 10 00 1a mov %i2, %o1 _Thread_Set_state( the_thread, queue_context->thread_state ); 40009998: d2 06 e0 04 ld [ %i3 + 4 ], %o1 4000999c: 7f ff f1 82 call 40005fa4 <_Thread_Set_state> 400099a0: 90 10 00 1a mov %i2, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400099a4: 91 d0 20 09 ta 9 bool success = ( the_thread->Wait.flags == expected_flags ); 400099a8: c4 06 a0 50 ld [ %i2 + 0x50 ], %g2 if ( success ) { 400099ac: 80 a0 a4 01 cmp %g2, 0x401 400099b0: 02 80 00 0b be 400099dc <_Thread_queue_Enqueue+0xdc> 400099b4: 86 10 24 02 mov 0x402, %g3 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400099b8: 91 d0 20 0a ta 0xa 400099bc: 01 00 00 00 nop if ( !success ) { 400099c0: 80 a0 a4 01 cmp %g2, 0x401 400099c4: 12 80 00 0c bne 400099f4 <_Thread_queue_Enqueue+0xf4> <== ALWAYS TAKEN 400099c8: 01 00 00 00 nop _Thread_Priority_update( queue_context ); 400099cc: 7f ff fe 7e call 400093c4 <_Thread_Priority_update> 400099d0: 90 10 00 1b mov %i3, %o0 _Thread_Dispatch_direct( cpu_self ); 400099d4: 7f ff ef d8 call 40005934 <_Thread_Dispatch_direct> 400099d8: 81 e8 00 00 restore the_thread->Wait.flags = desired_flags; 400099dc: c6 26 a0 50 st %g3, [ %i2 + 0x50 ] 400099e0: 91 d0 20 0a ta 0xa 400099e4: 01 00 00 00 nop if ( !success ) { 400099e8: 80 a0 a4 01 cmp %g2, 0x401 400099ec: 02 bf ff f8 be 400099cc <_Thread_queue_Enqueue+0xcc> <== ALWAYS TAKEN 400099f0: 01 00 00 00 nop __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400099f4: 91 d0 20 09 ta 9 return psr; 400099f8: c2 27 bf fc st %g1, [ %fp + -4 ] 400099fc: d0 06 a0 60 ld [ %i2 + 0x60 ], %o0 40009a00: 7f ff f2 f9 call 400065e4 <_Watchdog_Remove> 40009a04: 92 06 a0 68 add %i2, 0x68, %o1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40009a08: c2 07 bf fc ld [ %fp + -4 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009a0c: 91 d0 20 0a ta 0xa 40009a10: 01 00 00 00 nop _Thread_Clear_state( the_thread, STATES_BLOCKED ); 40009a14: 13 0c 00 57 sethi %hi(0x30015c00), %o1 40009a18: 90 10 00 1a mov %i2, %o0 40009a1c: 7f ff fe 93 call 40009468 <_Thread_Clear_state> 40009a20: 92 12 63 ff or %o1, 0x3ff, %o1 _Thread_Priority_update( queue_context ); 40009a24: 7f ff fe 68 call 400093c4 <_Thread_Priority_update> 40009a28: 90 10 00 1b mov %i3, %o0 _Thread_Dispatch_direct( cpu_self ); 40009a2c: 7f ff ef c2 call 40005934 <_Thread_Dispatch_direct> 40009a30: 81 e8 00 00 restore the_thread->Wait.operations = &_Thread_queue_Operations_default; 40009a34: 03 10 00 5f sethi %hi(0x40017c00), %g1 40009a38: 82 10 62 90 or %g1, 0x290, %g1 ! 40017e90 <_Thread_queue_Operations_default> 40009a3c: c2 26 a0 58 st %g1, [ %i2 + 0x58 ] register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40009a40: c2 06 c0 00 ld [ %i3 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009a44: 91 d0 20 0a ta 0xa 40009a48: 01 00 00 00 nop ( *queue_context->deadlock_callout )( the_thread ); 40009a4c: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1 40009a50: 9f c0 40 00 call %g1 40009a54: 90 10 00 1a mov %i2, %o0 } 40009a58: 81 c7 e0 08 ret 40009a5c: 81 e8 00 00 restore =============================================================================== 40009aa8 <_Thread_queue_Extract>: &queue_context->Lock_context.Lock_context ); } void _Thread_queue_Extract( Thread_Control *the_thread ) { 40009aa8: 9d e3 bf 78 save %sp, -136, %sp 40009aac: c0 27 bf f0 clr [ %fp + -16 ] __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40009ab0: 91 d0 20 09 ta 9 _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 40009ab4: 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; 40009ab8: d0 06 20 54 ld [ %i0 + 0x54 ], %o0 if ( queue != NULL ) { 40009abc: 80 a2 20 00 cmp %o0, 0 40009ac0: 02 80 00 1c be 40009b30 <_Thread_queue_Extract+0x88> 40009ac4: 92 10 00 18 mov %i0, %o1 ( *operations->extract )( queue, the_thread, queue_context ); 40009ac8: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 40009acc: c2 00 60 08 ld [ %g1 + 8 ], %g1 40009ad0: 9f c0 40 00 call %g1 40009ad4: 94 07 bf dc add %fp, -36, %o2 if ( success ) { 40009ad8: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 40009adc: 80 a0 64 01 cmp %g1, 0x401 the_thread->Wait.queue = NULL; 40009ae0: c0 26 20 54 clr [ %i0 + 0x54 ] the_thread->Wait.flags = desired_flags; 40009ae4: 82 10 24 04 mov 0x404, %g1 if ( success ) { 40009ae8: 02 80 00 0a be 40009b10 <_Thread_queue_Extract+0x68> <== NEVER TAKEN 40009aec: c2 26 20 50 st %g1, [ %i0 + 0x50 ] the_thread->Wait.operations = &_Thread_queue_Operations_default; 40009af0: 03 10 00 5f sethi %hi(0x40017c00), %g1 40009af4: 82 10 62 90 or %g1, 0x290, %g1 ! 40017e90 <_Thread_queue_Operations_default> 40009af8: c2 26 20 58 st %g1, [ %i0 + 0x58 ] if ( unblock ) { 40009afc: 92 07 bf dc add %fp, -36, %o1 40009b00: 7f ff ff 63 call 4000988c <_Thread_queue_Unblock_critical.part.0> 40009b04: 90 10 00 18 mov %i0, %o0 &queue_context.Lock_context.Lock_context ); } else { _Thread_Wait_release( the_thread, &queue_context ); } } 40009b08: 81 c7 e0 08 ret 40009b0c: 81 e8 00 00 restore 40009b10: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED 40009b14: 82 10 62 90 or %g1, 0x290, %g1 ! 40017e90 <_Thread_queue_Operations_default><== NOT EXECUTED 40009b18: c2 26 20 58 st %g1, [ %i0 + 0x58 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40009b1c: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009b20: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40009b24: 01 00 00 00 nop <== NOT EXECUTED } 40009b28: 81 c7 e0 08 ret <== NOT EXECUTED 40009b2c: 81 e8 00 00 restore <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40009b30: c2 07 bf dc ld [ %fp + -36 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009b34: 91 d0 20 0a ta 0xa 40009b38: 01 00 00 00 nop 40009b3c: 81 c7 e0 08 ret 40009b40: 81 e8 00 00 restore =============================================================================== 400198ec <_Thread_queue_Queue_get_name_and_id>: const Thread_queue_Queue *queue, char *buffer, size_t buffer_size, Objects_Id *id ) { 400198ec: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED const char *name; name = queue->name; 400198f0: c4 06 20 08 ld [ %i0 + 8 ], %g2 <== NOT EXECUTED { 400198f4: 86 10 00 18 mov %i0, %g3 <== NOT EXECUTED if ( name == _Thread_queue_Object_name ) { 400198f8: 03 10 02 1a sethi %hi(0x40086800), %g1 <== NOT EXECUTED 400198fc: 82 10 60 20 or %g1, 0x20, %g1 ! 40086820 <_Thread_queue_Object_name> <== NOT EXECUTED 40019900: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 40019904: 02 80 00 0a be 4001992c <_Thread_queue_Queue_get_name_and_id+0x40> <== NOT EXECUTED 40019908: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED false, buffer, buffer_size ); } else { if ( name == NULL ) { 4001990c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40019910: 02 80 00 04 be 40019920 <_Thread_queue_Queue_get_name_and_id+0x34> <== NOT EXECUTED 40019914: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED name = _Thread_queue_Object_name; } *id = 0; return strlcpy( buffer, name, buffer_size ); 40019918: 40 01 11 da call 4005e080 <== NOT EXECUTED 4001991c: 93 e8 00 02 restore %g0, %g2, %o1 <== NOT EXECUTED name = _Thread_queue_Object_name; 40019920: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED return strlcpy( buffer, name, buffer_size ); 40019924: 40 01 11 d7 call 4005e080 <== NOT EXECUTED 40019928: 93 e8 00 02 restore %g0, %g2, %o1 <== NOT EXECUTED *id = queue_object->Object.id; 4001992c: c2 00 ff f8 ld [ %g3 + -8 ], %g1 <== NOT EXECUTED 40019930: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED return _Objects_Name_to_string( 40019934: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 40019938: c2 00 ff fc ld [ %g3 + -4 ], %g1 <== NOT EXECUTED 4001993c: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED 40019940: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 40019944: 92 10 20 00 clr %o1 <== NOT EXECUTED 40019948: 7f ff f6 93 call 40017394 <_Objects_Name_to_string> <== NOT EXECUTED 4001994c: 90 07 bf fc add %fp, -4, %o0 <== NOT EXECUTED } } 40019950: 81 c7 e0 08 ret <== NOT EXECUTED 40019954: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED =============================================================================== 40009b44 <_Thread_queue_Surrender>: Thread_queue_Heads *heads, Thread_Control *previous_owner, Thread_queue_Context *queue_context, const Thread_queue_Operations *operations ) { 40009b44: 9d e3 bf 98 save %sp, -104, %sp queue_context->Priority.update_count = 0; 40009b48: 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 )( 40009b4c: 96 10 00 1b mov %i3, %o3 40009b50: c2 07 20 0c ld [ %i4 + 0xc ], %g1 40009b54: 94 10 00 1a mov %i2, %o2 40009b58: 92 10 00 19 mov %i1, %o1 40009b5c: 9f c0 40 00 call %g1 40009b60: 90 10 00 18 mov %i0, %o0 40009b64: 84 10 24 04 mov 0x404, %g2 queue, heads, previous_owner, queue_context ); queue->owner = new_owner; 40009b68: d0 26 20 04 st %o0, [ %i0 + 4 ] new_owner = ( *operations->surrender )( 40009b6c: ba 10 00 08 mov %o0, %i5 disable_level = cpu_self->thread_dispatch_disable_level; 40009b70: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 bool success = ( the_thread->Wait.flags == expected_flags ); 40009b74: f8 02 20 50 ld [ %o0 + 0x50 ], %i4 the_thread->Wait.queue = NULL; 40009b78: c0 22 20 54 clr [ %o0 + 0x54 ] cpu_self->thread_dispatch_disable_level = disable_level + 1; 40009b7c: 82 00 60 01 inc %g1 40009b80: c4 22 20 50 st %g2, [ %o0 + 0x50 ] the_thread->Wait.operations = &_Thread_queue_Operations_default; 40009b84: 05 10 00 5f sethi %hi(0x40017c00), %g2 40009b88: 84 10 a2 90 or %g2, 0x290, %g2 ! 40017e90 <_Thread_queue_Operations_default> 40009b8c: c4 22 20 58 st %g2, [ %o0 + 0x58 ] return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context ); 40009b90: b0 10 00 06 mov %g6, %i0 cpu_self->thread_dispatch_disable_level = disable_level + 1; 40009b94: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40009b98: c2 06 c0 00 ld [ %i3 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009b9c: 91 d0 20 0a ta 0xa 40009ba0: 01 00 00 00 nop _Thread_queue_Queue_release( queue, &queue_context->Lock_context.Lock_context ); _Thread_Priority_update( queue_context ); 40009ba4: 7f ff fe 08 call 400093c4 <_Thread_Priority_update> 40009ba8: 90 10 00 1b mov %i3, %o0 if ( unblock ) { 40009bac: 80 a7 24 01 cmp %i4, 0x401 40009bb0: 12 80 00 04 bne 40009bc0 <_Thread_queue_Surrender+0x7c> <== ALWAYS TAKEN 40009bb4: 01 00 00 00 nop _Thread_Remove_timer_and_unblock( new_owner, queue ); } _Thread_Dispatch_enable( cpu_self ); 40009bb8: 7f ff ef 6a call 40005960 <_Thread_Dispatch_enable> <== NOT EXECUTED 40009bbc: 81 e8 00 00 restore <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40009bc0: 91 d0 20 09 ta 9 return psr; 40009bc4: c2 27 bf fc st %g1, [ %fp + -4 ] 40009bc8: d0 07 60 60 ld [ %i5 + 0x60 ], %o0 40009bcc: 7f ff f2 86 call 400065e4 <_Watchdog_Remove> 40009bd0: 92 07 60 68 add %i5, 0x68, %o1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40009bd4: c2 07 bf fc ld [ %fp + -4 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40009bd8: 91 d0 20 0a ta 0xa 40009bdc: 01 00 00 00 nop _Thread_Clear_state( the_thread, STATES_BLOCKED ); 40009be0: 13 0c 00 57 sethi %hi(0x30015c00), %o1 40009be4: 90 10 00 1d mov %i5, %o0 40009be8: 7f ff fe 20 call 40009468 <_Thread_Clear_state> 40009bec: 92 12 63 ff or %o1, 0x3ff, %o1 40009bf0: 7f ff ef 5c call 40005960 <_Thread_Dispatch_enable> 40009bf4: 81 e8 00 00 restore =============================================================================== 40004ce0 <_Timecounter_Bintime>: { 40004ce0: 9d e3 bf a0 save %sp, -96, %sp 40004ce4: 33 10 00 6b sethi %hi(0x4001ac00), %i1 40004ce8: b2 16 60 94 or %i1, 0x94, %i1 ! 4001ac94 th = timehands; 40004cec: fa 06 40 00 ld [ %i1 ], %i5 40004cf0: f4 07 60 70 ld [ %i5 + 0x70 ], %i2 *bt = th->th_bintime; 40004cf4: c4 1f 60 30 ldd [ %i5 + 0x30 ], %g2 40004cf8: c4 3e 00 00 std %g2, [ %i0 ] 40004cfc: c4 1f 60 38 ldd [ %i5 + 0x38 ], %g2 tc = th->th_counter; 40004d00: f6 07 40 00 ld [ %i5 ], %i3 *bt = th->th_bintime; 40004d04: c4 3e 20 08 std %g2, [ %i0 + 8 ] return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40004d08: 90 10 00 1b mov %i3, %o0 40004d0c: c2 06 c0 00 ld [ %i3 ], %g1 bintime_addx(bt, th->th_scale * tc_delta(th)); 40004d10: f8 07 60 10 ld [ %i5 + 0x10 ], %i4 return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40004d14: 9f c0 40 00 call %g1 40004d18: e0 07 60 14 ld [ %i5 + 0x14 ], %l0 _bt->frac += _x; 40004d1c: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 40004d20: c8 07 60 18 ld [ %i5 + 0x18 ], %g4 40004d24: c2 06 e0 04 ld [ %i3 + 4 ], %g1 40004d28: 90 22 00 04 sub %o0, %g4, %o0 40004d2c: 90 0a 00 01 and %o0, %g1, %o0 bintime_addx(bt, th->th_scale * tc_delta(th)); 40004d30: b8 5f 00 08 smul %i4, %o0, %i4 40004d34: 92 52 00 10 umul %o0, %l0, %o1 40004d38: 91 40 00 00 rd %y, %o0 40004d3c: 9a 82 40 03 addcc %o1, %g3, %o5 40004d40: 90 07 00 08 add %i4, %o0, %o0 40004d44: 98 c2 00 02 addxcc %o0, %g2, %o4 if (_u > _bt->frac) 40004d48: 1a 80 00 06 bcc 40004d60 <_Timecounter_Bintime+0x80> 40004d4c: d8 3e 20 08 std %o4, [ %i0 + 8 ] _bt->sec++; 40004d50: c4 1e 00 00 ldd [ %i0 ], %g2 40004d54: 9a 80 e0 01 addcc %g3, 1, %o5 40004d58: 98 40 a0 00 addx %g2, 0, %o4 40004d5c: d8 3e 00 00 std %o4, [ %i0 ] } while (gen == 0 || gen != th->th_generation); 40004d60: 80 a6 a0 00 cmp %i2, 0 40004d64: 02 bf ff e2 be 40004cec <_Timecounter_Bintime+0xc> <== NEVER TAKEN 40004d68: 01 00 00 00 nop 40004d6c: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 40004d70: 80 a0 40 1a cmp %g1, %i2 40004d74: 12 bf ff de bne 40004cec <_Timecounter_Bintime+0xc> 40004d78: 01 00 00 00 nop } 40004d7c: 81 c7 e0 08 ret 40004d80: 81 e8 00 00 restore =============================================================================== 400075d8 <_Timecounter_Binuptime>: { 400075d8: 9d e3 bf a0 save %sp, -96, %sp 400075dc: 33 10 00 4e sethi %hi(0x40013800), %i1 400075e0: b2 16 62 1c or %i1, 0x21c, %i1 ! 40013a1c th = timehands; 400075e4: fa 06 40 00 ld [ %i1 ], %i5 val = *obj; 400075e8: f4 07 60 70 ld [ %i5 + 0x70 ], %i2 *bt = th->th_offset; 400075ec: c4 1f 60 20 ldd [ %i5 + 0x20 ], %g2 400075f0: c4 3e 00 00 std %g2, [ %i0 ] 400075f4: c4 1f 60 28 ldd [ %i5 + 0x28 ], %g2 tc = th->th_counter; 400075f8: f6 07 40 00 ld [ %i5 ], %i3 *bt = th->th_offset; 400075fc: c4 3e 20 08 std %g2, [ %i0 + 8 ] return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40007600: 90 10 00 1b mov %i3, %o0 40007604: c2 06 c0 00 ld [ %i3 ], %g1 bintime_addx(bt, th->th_scale * tc_delta(th)); 40007608: f8 07 60 10 ld [ %i5 + 0x10 ], %i4 return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 4000760c: 9f c0 40 00 call %g1 40007610: e0 07 60 14 ld [ %i5 + 0x14 ], %l0 _bt->frac += _x; 40007614: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 40007618: c8 07 60 18 ld [ %i5 + 0x18 ], %g4 4000761c: c2 06 e0 04 ld [ %i3 + 4 ], %g1 40007620: 90 22 00 04 sub %o0, %g4, %o0 40007624: 90 0a 00 01 and %o0, %g1, %o0 bintime_addx(bt, th->th_scale * tc_delta(th)); 40007628: b8 5f 00 08 smul %i4, %o0, %i4 4000762c: 92 52 00 10 umul %o0, %l0, %o1 40007630: 91 40 00 00 rd %y, %o0 40007634: 9a 82 40 03 addcc %o1, %g3, %o5 40007638: 90 07 00 08 add %i4, %o0, %o0 4000763c: 98 c2 00 02 addxcc %o0, %g2, %o4 if (_u > _bt->frac) 40007640: 1a 80 00 06 bcc 40007658 <_Timecounter_Binuptime+0x80> 40007644: d8 3e 20 08 std %o4, [ %i0 + 8 ] _bt->sec++; 40007648: c4 1e 00 00 ldd [ %i0 ], %g2 4000764c: 9a 80 e0 01 addcc %g3, 1, %o5 40007650: 98 40 a0 00 addx %g2, 0, %o4 40007654: d8 3e 00 00 std %o4, [ %i0 ] } while (gen == 0 || gen != th->th_generation); 40007658: 80 a6 a0 00 cmp %i2, 0 4000765c: 02 bf ff e2 be 400075e4 <_Timecounter_Binuptime+0xc> <== NEVER TAKEN 40007660: 01 00 00 00 nop 40007664: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 40007668: 80 a0 40 1a cmp %g1, %i2 4000766c: 12 bf ff de bne 400075e4 <_Timecounter_Binuptime+0xc> 40007670: 01 00 00 00 nop } 40007674: 81 c7 e0 08 ret 40007678: 81 e8 00 00 restore =============================================================================== 40004e0c <_Timecounter_Getbintime>: { 40004e0c: 07 10 00 6b sethi %hi(0x4001ac00), %g3 40004e10: 86 10 e0 94 or %g3, 0x94, %g3 ! 4001ac94 th = timehands; 40004e14: c2 00 c0 00 ld [ %g3 ], %g1 40004e18: c4 00 60 70 ld [ %g1 + 0x70 ], %g2 *bt = th->th_bintime; 40004e1c: d8 18 60 30 ldd [ %g1 + 0x30 ], %o4 40004e20: d8 3a 00 00 std %o4, [ %o0 ] 40004e24: d8 18 60 38 ldd [ %g1 + 0x38 ], %o4 40004e28: d8 3a 20 08 std %o4, [ %o0 + 8 ] } while (gen == 0 || gen != th->th_generation); 40004e2c: 80 a0 a0 00 cmp %g2, 0 40004e30: 02 bf ff f9 be 40004e14 <_Timecounter_Getbintime+0x8> <== NEVER TAKEN 40004e34: 01 00 00 00 nop 40004e38: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 40004e3c: 80 a0 40 02 cmp %g1, %g2 40004e40: 12 bf ff f5 bne 40004e14 <_Timecounter_Getbintime+0x8> 40004e44: 01 00 00 00 nop } 40004e48: 81 c3 e0 08 retl 40004e4c: 01 00 00 00 nop =============================================================================== 4000316c <_Timecounter_Getbinuptime>: { 4000316c: 07 10 00 36 sethi %hi(0x4000d800), %g3 40003170: 86 10 e1 cc or %g3, 0x1cc, %g3 ! 4000d9cc th = timehands; 40003174: c2 00 c0 00 ld [ %g3 ], %g1 40003178: c4 00 60 70 ld [ %g1 + 0x70 ], %g2 *bt = th->th_offset; 4000317c: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4 40003180: d8 3a 00 00 std %o4, [ %o0 ] 40003184: d8 18 60 28 ldd [ %g1 + 0x28 ], %o4 40003188: d8 3a 20 08 std %o4, [ %o0 + 8 ] } while (gen == 0 || gen != th->th_generation); 4000318c: 80 a0 a0 00 cmp %g2, 0 40003190: 02 bf ff f9 be 40003174 <_Timecounter_Getbinuptime+0x8> <== NEVER TAKEN 40003194: 01 00 00 00 nop 40003198: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 4000319c: 80 a0 40 02 cmp %g1, %g2 400031a0: 12 bf ff f5 bne 40003174 <_Timecounter_Getbinuptime+0x8> <== NEVER TAKEN 400031a4: 01 00 00 00 nop } 400031a8: 81 c3 e0 08 retl 400031ac: 01 00 00 00 nop =============================================================================== 400032e0 <_Timecounter_Getmicrotime>: { 400032e0: 07 10 00 36 sethi %hi(0x4000d800), %g3 400032e4: 86 10 e1 cc or %g3, 0x1cc, %g3 ! 4000d9cc th = timehands; 400032e8: c2 00 c0 00 ld [ %g3 ], %g1 400032ec: c4 00 60 70 ld [ %g1 + 0x70 ], %g2 *tvp = th->th_microtime; 400032f0: d8 18 60 40 ldd [ %g1 + 0x40 ], %o4 400032f4: d8 3a 00 00 std %o4, [ %o0 ] 400032f8: d8 18 60 48 ldd [ %g1 + 0x48 ], %o4 400032fc: d8 3a 20 08 std %o4, [ %o0 + 8 ] } while (gen == 0 || gen != th->th_generation); 40003300: 80 a0 a0 00 cmp %g2, 0 40003304: 02 bf ff f9 be 400032e8 <_Timecounter_Getmicrotime+0x8> <== NEVER TAKEN 40003308: 01 00 00 00 nop 4000330c: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 40003310: 80 a0 40 02 cmp %g1, %g2 40003314: 12 bf ff f5 bne 400032e8 <_Timecounter_Getmicrotime+0x8> <== NEVER TAKEN 40003318: 01 00 00 00 nop } 4000331c: 81 c3 e0 08 retl 40003320: 01 00 00 00 nop =============================================================================== 40003204 <_Timecounter_Getmicrouptime>: { 40003204: 15 10 00 36 sethi %hi(0x4000d800), %o2 _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40003208: 17 00 03 d0 sethi %hi(0xf4000), %o3 4000320c: 94 12 a1 cc or %o2, 0x1cc, %o2 40003210: 96 12 e2 40 or %o3, 0x240, %o3 th = timehands; 40003214: c2 02 80 00 ld [ %o2 ], %g1 40003218: c8 00 60 70 ld [ %g1 + 0x70 ], %g4 4000321c: c4 00 60 28 ld [ %g1 + 0x28 ], %g2 _tv->tv_sec = _bt->sec; 40003220: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4 _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40003224: 86 50 80 0b umul %g2, %o3, %g3 40003228: 85 40 00 00 rd %y, %g2 _tv->tv_sec = _bt->sec; 4000322c: d8 3a 00 00 std %o4, [ %o0 ] _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40003230: c4 22 20 08 st %g2, [ %o0 + 8 ] } while (gen == 0 || gen != th->th_generation); 40003234: 80 a1 20 00 cmp %g4, 0 40003238: 02 bf ff f7 be 40003214 <_Timecounter_Getmicrouptime+0x10> <== NEVER TAKEN 4000323c: 01 00 00 00 nop 40003240: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 40003244: 80 a0 40 04 cmp %g1, %g4 40003248: 12 bf ff f3 bne 40003214 <_Timecounter_Getmicrouptime+0x10> <== NEVER TAKEN 4000324c: 01 00 00 00 nop } 40003250: 81 c3 e0 08 retl 40003254: 01 00 00 00 nop =============================================================================== 40004e50 <_Timecounter_Getnanotime>: { 40004e50: 07 10 00 6b sethi %hi(0x4001ac00), %g3 40004e54: 86 10 e0 94 or %g3, 0x94, %g3 ! 4001ac94 th = timehands; 40004e58: c2 00 c0 00 ld [ %g3 ], %g1 40004e5c: c4 00 60 70 ld [ %g1 + 0x70 ], %g2 *tsp = th->th_nanotime; 40004e60: d8 18 60 50 ldd [ %g1 + 0x50 ], %o4 40004e64: d8 3a 00 00 std %o4, [ %o0 ] 40004e68: d8 18 60 58 ldd [ %g1 + 0x58 ], %o4 40004e6c: d8 3a 20 08 std %o4, [ %o0 + 8 ] } while (gen == 0 || gen != th->th_generation); 40004e70: 80 a0 a0 00 cmp %g2, 0 40004e74: 02 bf ff f9 be 40004e58 <_Timecounter_Getnanotime+0x8> <== NEVER TAKEN 40004e78: 01 00 00 00 nop 40004e7c: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 40004e80: 80 a0 40 02 cmp %g1, %g2 40004e84: 12 bf ff f5 bne 40004e58 <_Timecounter_Getnanotime+0x8> <== NEVER TAKEN 40004e88: 01 00 00 00 nop } 40004e8c: 81 c3 e0 08 retl 40004e90: 01 00 00 00 nop =============================================================================== 40004db8 <_Timecounter_Getnanouptime>: { 40004db8: 15 10 00 6b sethi %hi(0x4001ac00), %o2 _ts->tv_nsec = ((uint64_t)1000000000 * 40004dbc: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 40004dc0: 94 12 a0 94 or %o2, 0x94, %o2 40004dc4: 96 12 e2 00 or %o3, 0x200, %o3 th = timehands; 40004dc8: c2 02 80 00 ld [ %o2 ], %g1 40004dcc: c8 00 60 70 ld [ %g1 + 0x70 ], %g4 (uint32_t)(_bt->frac >> 32)) >> 32; 40004dd0: c4 00 60 28 ld [ %g1 + 0x28 ], %g2 _ts->tv_sec = _bt->sec; 40004dd4: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4 _ts->tv_nsec = ((uint64_t)1000000000 * 40004dd8: 86 50 80 0b umul %g2, %o3, %g3 40004ddc: 85 40 00 00 rd %y, %g2 _ts->tv_sec = _bt->sec; 40004de0: d8 3a 00 00 std %o4, [ %o0 ] _ts->tv_nsec = ((uint64_t)1000000000 * 40004de4: c4 22 20 08 st %g2, [ %o0 + 8 ] } while (gen == 0 || gen != th->th_generation); 40004de8: 80 a1 20 00 cmp %g4, 0 40004dec: 02 bf ff f7 be 40004dc8 <_Timecounter_Getnanouptime+0x10> <== NEVER TAKEN 40004df0: 01 00 00 00 nop 40004df4: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 40004df8: 80 a0 40 04 cmp %g1, %g4 40004dfc: 12 bf ff f3 bne 40004dc8 <_Timecounter_Getnanouptime+0x10> <== NEVER TAKEN 40004e00: 01 00 00 00 nop } 40004e04: 81 c3 e0 08 retl 40004e08: 01 00 00 00 nop =============================================================================== 40004e94 <_Timecounter_Install>: { 40004e94: 9d e3 bf 98 save %sp, -104, %sp if (tc->tc_quality < timecounter->tc_quality) 40004e98: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40004e9c: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 4001ac90 <_Timecounter> 40004ea0: c6 00 a0 14 ld [ %g2 + 0x14 ], %g3 40004ea4: c8 06 20 14 ld [ %i0 + 0x14 ], %g4 40004ea8: 80 a1 00 03 cmp %g4, %g3 40004eac: 06 80 00 11 bl 40004ef0 <_Timecounter_Install+0x5c> <== NEVER TAKEN 40004eb0: 01 00 00 00 nop if (tc->tc_quality == timecounter->tc_quality && 40004eb4: 32 80 00 0a bne,a 40004edc <_Timecounter_Install+0x48> 40004eb8: f0 20 60 90 st %i0, [ %g1 + 0x90 ] 40004ebc: c8 00 a0 08 ld [ %g2 + 8 ], %g4 40004ec0: c6 06 20 08 ld [ %i0 + 8 ], %g3 40004ec4: 80 a1 00 03 cmp %g4, %g3 40004ec8: 18 80 00 0a bgu 40004ef0 <_Timecounter_Install+0x5c> <== NEVER TAKEN 40004ecc: 01 00 00 00 nop 40004ed0: 22 80 00 0a be,a 40004ef8 <_Timecounter_Install+0x64> <== ALWAYS TAKEN 40004ed4: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 timecounter = tc; 40004ed8: f0 20 60 90 st %i0, [ %g1 + 0x90 ] <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40004edc: 91 d0 20 09 ta 9 _Timecounter_Acquire(&lock_context); 40004ee0: c2 27 bf fc st %g1, [ %fp + -4 ] _Timecounter_Windup(new_boottimebin, &lock_context); 40004ee4: 90 10 20 00 clr %o0 40004ee8: 7f ff fe bc call 400049d8 <_Timecounter_Windup> 40004eec: 92 07 bf fc add %fp, -4, %o1 } 40004ef0: 81 c7 e0 08 ret 40004ef4: 81 e8 00 00 restore if (tc->tc_quality == timecounter->tc_quality && 40004ef8: c4 06 20 0c ld [ %i0 + 0xc ], %g2 40004efc: 80 a0 c0 02 cmp %g3, %g2 40004f00: 28 bf ff f7 bleu,a 40004edc <_Timecounter_Install+0x48> 40004f04: f0 20 60 90 st %i0, [ %g1 + 0x90 ] 40004f08: 30 bf ff fa b,a 40004ef0 <_Timecounter_Install+0x5c> =============================================================================== 40004c50 <_Timecounter_Sbinuptime>: { 40004c50: 9d e3 bf a0 save %sp, -96, %sp 40004c54: 31 10 00 6b sethi %hi(0x4001ac00), %i0 40004c58: b0 16 20 94 or %i0, 0x94, %i0 ! 4001ac94 th = timehands; 40004c5c: fa 06 00 00 ld [ %i0 ], %i5 val = *obj; 40004c60: f6 07 60 70 ld [ %i5 + 0x70 ], %i3 tc = th->th_counter; 40004c64: f8 07 40 00 ld [ %i5 ], %i4 return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40004c68: c2 07 00 00 ld [ %i4 ], %g1 40004c6c: e0 07 60 24 ld [ %i5 + 0x24 ], %l0 40004c70: f2 07 60 28 ld [ %i5 + 0x28 ], %i1 sbt += (th->th_scale * tc_delta(th)) >> 32; 40004c74: f4 07 60 10 ld [ %i5 + 0x10 ], %i2 40004c78: e2 07 60 14 ld [ %i5 + 0x14 ], %l1 return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40004c7c: 9f c0 40 00 call %g1 40004c80: 90 10 00 1c mov %i4, %o0 40004c84: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 tc->tc_counter_mask); 40004c88: c4 07 20 04 ld [ %i4 + 4 ], %g2 } while (gen == 0 || gen != th->th_generation); 40004c8c: 80 a6 e0 00 cmp %i3, 0 40004c90: 02 bf ff f3 be 40004c5c <_Timecounter_Sbinuptime+0xc> <== NEVER TAKEN 40004c94: 01 00 00 00 nop 40004c98: c6 07 60 70 ld [ %i5 + 0x70 ], %g3 40004c9c: 80 a0 c0 1b cmp %g3, %i3 40004ca0: 12 bf ff ef bne 40004c5c <_Timecounter_Sbinuptime+0xc> 40004ca4: 90 22 00 01 sub %o0, %g1, %o0 return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40004ca8: 84 0a 00 02 and %o0, %g2, %g2 sbt += (th->th_scale * tc_delta(th)) >> 32; 40004cac: b4 5e 80 02 smul %i2, %g2, %i2 40004cb0: 86 50 80 11 umul %g2, %l1, %g3 40004cb4: 85 40 00 00 rd %y, %g2 return (((sbintime_t)_bt.sec << 32) + (_bt.frac >> 32)); 40004cb8: 9a 10 20 00 clr %o5 40004cbc: ba 06 80 02 add %i2, %g2, %i5 40004cc0: b2 83 40 19 addcc %o5, %i1, %i1 40004cc4: b8 10 20 00 clr %i4 40004cc8: 84 10 20 00 clr %g2 40004ccc: b0 44 00 02 addx %l0, %g2, %i0 } 40004cd0: b2 87 40 19 addcc %i5, %i1, %i1 40004cd4: b0 47 00 18 addx %i4, %i0, %i0 40004cd8: 81 c7 e0 08 ret 40004cdc: 81 e8 00 00 restore =============================================================================== 40006c5c <_Timecounter_Tick_simple>: } void _Timecounter_Tick_simple(uint32_t delta, uint32_t offset, ISR_lock_Context *lock_context) { 40006c5c: 9d e3 bf a0 save %sp, -96, %sp struct bintime bt; struct timehands *th; uint32_t ogen; th = timehands; 40006c60: 03 10 00 55 sethi %hi(0x40015400), %g1 40006c64: c2 00 60 fc ld [ %g1 + 0xfc ], %g1 ! 400154fc ogen = th->th_generation; 40006c68: f8 18 60 28 ldd [ %g1 + 0x28 ], %i4 th->th_offset_count = offset; bintime_addx(&th->th_offset, th->th_scale * delta); 40006c6c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 40006c70: c6 00 60 10 ld [ %g1 + 0x10 ], %g3 40006c74: 86 58 c0 18 smul %g3, %i0, %g3 th->th_offset_count = offset; 40006c78: f2 20 60 18 st %i1, [ %g1 + 0x18 ] bintime_addx(&th->th_offset, th->th_scale * delta); 40006c7c: b2 50 80 18 umul %g2, %i0, %i1 40006c80: b1 40 00 00 rd %y, %i0 40006c84: 92 86 40 1d addcc %i1, %i5, %o1 40006c88: b0 00 c0 18 add %g3, %i0, %i0 40006c8c: 90 c6 00 1c addxcc %i0, %i4, %o0 _bt->frac += _x; 40006c90: d0 38 60 28 std %o0, [ %g1 + 0x28 ] if (_u > _bt->frac) 40006c94: 0a 80 00 28 bcs 40006d34 <_Timecounter_Tick_simple+0xd8> <== NEVER TAKEN 40006c98: c8 00 60 70 ld [ %g1 + 0x70 ], %g4 bt = th->th_offset; 40006c9c: d4 18 60 20 ldd [ %g1 + 0x20 ], %o2 _bt->frac += _bt2->frac; 40006ca0: c4 18 60 68 ldd [ %g1 + 0x68 ], %g2 40006ca4: 9a 80 c0 09 addcc %g3, %o1, %o5 40006ca8: 98 c0 80 08 addxcc %g2, %o0, %o4 _bt->sec++; 40006cac: 0a 80 00 27 bcs 40006d48 <_Timecounter_Tick_simple+0xec> 40006cb0: ba 82 e0 01 addcc %o3, 1, %i5 40006cb4: b8 10 00 0a mov %o2, %i4 40006cb8: ba 10 00 0b mov %o3, %i5 _bt->sec += _bt2->sec; 40006cbc: c4 18 60 60 ldd [ %g1 + 0x60 ], %g2 40006cc0: b2 87 40 03 addcc %i5, %g3, %i1 bintime_add(&bt, &th->th_boottime); /* Update the UTC timestamps used by the get*() functions. */ th->th_bintime = bt; 40006cc4: d8 38 60 38 std %o4, [ %g1 + 0x38 ] 40006cc8: b0 47 00 02 addx %i4, %g2, %i0 _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40006ccc: 39 00 03 d0 sethi %hi(0xf4000), %i4 _ts->tv_nsec = ((uint64_t)1000000000 * 40006cd0: 05 0e e6 b2 sethi %hi(0x3b9ac800), %g2 _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40006cd4: b8 17 22 40 or %i4, 0x240, %i4 _ts->tv_nsec = ((uint64_t)1000000000 * 40006cd8: 84 10 a2 00 or %g2, 0x200, %g2 _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40006cdc: ba 53 00 1c umul %o4, %i4, %i5 40006ce0: b9 40 00 00 rd %y, %i4 _ts->tv_nsec = ((uint64_t)1000000000 * 40006ce4: 86 53 00 02 umul %o4, %g2, %g3 40006ce8: 85 40 00 00 rd %y, %g2 40006cec: f0 38 60 30 std %i0, [ %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) ogen = 1; th->th_generation = ogen; 40006cf0: 88 81 20 01 inccc %g4 _tv->tv_sec = _bt->sec; 40006cf4: f0 38 60 40 std %i0, [ %g1 + 0x40 ] _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40006cf8: f8 20 60 48 st %i4, [ %g1 + 0x48 ] _ts->tv_sec = _bt->sec; 40006cfc: f0 38 60 50 std %i0, [ %g1 + 0x50 ] 40006d00: 12 80 00 03 bne 40006d0c <_Timecounter_Tick_simple+0xb0> <== ALWAYS TAKEN 40006d04: c4 20 60 58 st %g2, [ %g1 + 0x58 ] 40006d08: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED /* Go live with the new struct timehands. */ time_second = th->th_microtime.tv_sec; 40006d0c: 05 10 00 55 sethi %hi(0x40015400), %g2 40006d10: f0 38 a0 f0 std %i0, [ %g2 + 0xf0 ] ! 400154f0 <_Timecounter_Time_second> th->th_generation = ogen; 40006d14: c8 20 60 70 st %g4, [ %g1 + 0x70 ] time_uptime = th->th_offset.sec; 40006d18: 03 10 00 55 sethi %hi(0x40015400), %g1 40006d1c: d6 20 60 ec st %o3, [ %g1 + 0xec ] ! 400154ec <_Timecounter_Time_uptime> register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40006d20: c2 06 80 00 ld [ %i2 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40006d24: 91 d0 20 0a ta 0xa 40006d28: 01 00 00 00 nop _Timecounter_Release(lock_context); _Watchdog_Tick(_Per_CPU_Get_snapshot()); 40006d2c: 40 00 0a 86 call 40009744 <_Watchdog_Tick> 40006d30: 91 e8 00 06 restore %g0, %g6, %o0 _bt->sec++; 40006d34: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2 <== NOT EXECUTED 40006d38: 96 80 e0 01 addcc %g3, 1, %o3 <== NOT EXECUTED 40006d3c: 94 40 a0 00 addx %g2, 0, %o2 <== NOT EXECUTED 40006d40: 10 bf ff d8 b 40006ca0 <_Timecounter_Tick_simple+0x44> <== NOT EXECUTED 40006d44: d4 38 60 20 std %o2, [ %g1 + 0x20 ] <== NOT EXECUTED _bt->sec++; 40006d48: 10 bf ff dd b 40006cbc <_Timecounter_Tick_simple+0x60> 40006d4c: b8 42 a0 00 addx %o2, 0, %i4 =============================================================================== 40005ab0 <_Timespec_Add_to>: uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) { 40005ab0: 9d e3 bf a0 save %sp, -96, %sp uint32_t seconds = add->tv_sec; 40005ab4: d8 1e 40 00 ldd [ %i1 ], %o4 /* Add the basics */ time->tv_sec += add->tv_sec; time->tv_nsec += add->tv_nsec; 40005ab8: c2 06 60 08 ld [ %i1 + 8 ], %g1 time->tv_sec += add->tv_sec; 40005abc: f8 1e 00 00 ldd [ %i0 ], %i4 time->tv_nsec += add->tv_nsec; 40005ac0: c4 06 20 08 ld [ %i0 + 8 ], %g2 time->tv_sec += add->tv_sec; 40005ac4: b6 83 40 1d addcc %o5, %i5, %i3 time->tv_nsec += add->tv_nsec; 40005ac8: 84 00 80 01 add %g2, %g1, %g2 time->tv_sec += add->tv_sec; 40005acc: b4 43 00 1c addx %o4, %i4, %i2 time->tv_nsec += add->tv_nsec; 40005ad0: c4 26 20 08 st %g2, [ %i0 + 8 ] /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 40005ad4: 3b 0e e6 b2 sethi %hi(0x3b9ac800), %i5 time->tv_sec += add->tv_sec; 40005ad8: f4 3e 00 00 std %i2, [ %i0 ] while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 40005adc: ba 17 61 ff or %i5, 0x1ff, %i5 40005ae0: 82 10 00 02 mov %g2, %g1 40005ae4: 80 a0 80 1d cmp %g2, %i5 40005ae8: 08 80 00 11 bleu 40005b2c <_Timespec_Add_to+0x7c> 40005aec: b2 10 00 0d mov %o5, %i1 time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 40005af0: 39 31 19 4d sethi %hi(0xc4653400), %i4 while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 40005af4: 84 10 00 1a mov %i2, %g2 40005af8: 86 10 00 1b mov %i3, %g3 time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 40005afc: b8 17 22 00 or %i4, 0x200, %i4 time->tv_sec++; 40005b00: 86 80 e0 01 inccc %g3 time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 40005b04: 82 00 40 1c add %g1, %i4, %g1 time->tv_sec++; 40005b08: 84 40 a0 00 addx %g2, 0, %g2 40005b0c: 88 06 40 03 add %i1, %g3, %g4 while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 40005b10: 80 a0 40 1d cmp %g1, %i5 40005b14: 18 bf ff fb bgu 40005b00 <_Timespec_Add_to+0x50> <== NEVER TAKEN 40005b18: 88 21 00 1b sub %g4, %i3, %g4 40005b1c: c2 26 20 08 st %g1, [ %i0 + 8 ] 40005b20: c4 3e 00 00 std %g2, [ %i0 ] seconds++; } return seconds; } 40005b24: 81 c7 e0 08 ret 40005b28: 91 e8 00 04 restore %g0, %g4, %o0 uint32_t seconds = add->tv_sec; 40005b2c: 88 10 00 0d mov %o5, %g4 } 40005b30: 81 c7 e0 08 ret 40005b34: 91 e8 00 04 restore %g0, %g4, %o0 =============================================================================== 40010758 <_Timespec_Less_than>: bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec < rhs->tv_sec ) 40010758: c4 02 00 00 ld [ %o0 ], %g2 4001075c: c2 02 40 00 ld [ %o1 ], %g1 40010760: c8 02 20 04 ld [ %o0 + 4 ], %g4 40010764: 80 a0 40 02 cmp %g1, %g2 40010768: 14 80 00 13 bg 400107b4 <_Timespec_Less_than+0x5c> <== NEVER TAKEN 4001076c: c6 02 60 04 ld [ %o1 + 4 ], %g3 40010770: 02 80 00 0f be 400107ac <_Timespec_Less_than+0x54> <== ALWAYS TAKEN 40010774: 80 a0 c0 04 cmp %g3, %g4 return true; if ( lhs->tv_sec > rhs->tv_sec ) 40010778: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 4001077c: 34 80 00 0a bg,a 400107a4 <_Timespec_Less_than+0x4c> <== NEVER TAKEN 40010780: 90 10 20 00 clr %o0 <== NOT EXECUTED 40010784: 02 80 00 0f be 400107c0 <_Timespec_Less_than+0x68> <== ALWAYS TAKEN 40010788: 80 a1 00 03 cmp %g4, %g3 return false; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) 4001078c: c4 02 20 08 ld [ %o0 + 8 ], %g2 <== NOT EXECUTED 40010790: c2 02 60 08 ld [ %o1 + 8 ], %g1 40010794: 80 a0 80 01 cmp %g2, %g1 40010798: 06 80 00 03 bl 400107a4 <_Timespec_Less_than+0x4c> 4001079c: 90 10 20 01 mov 1, %o0 return false; 400107a0: 90 10 20 00 clr %o0 return true; return false; } 400107a4: 81 c3 e0 08 retl 400107a8: 90 0a 20 01 and %o0, 1, %o0 if ( lhs->tv_sec < rhs->tv_sec ) 400107ac: 08 bf ff f4 bleu 4001077c <_Timespec_Less_than+0x24> 400107b0: 80 a0 80 01 cmp %g2, %g1 return true; 400107b4: 90 10 20 01 mov 1, %o0 } 400107b8: 81 c3 e0 08 retl 400107bc: 90 0a 20 01 and %o0, 1, %o0 if ( lhs->tv_sec > rhs->tv_sec ) 400107c0: 28 bf ff f4 bleu,a 40010790 <_Timespec_Less_than+0x38> 400107c4: c4 02 20 08 ld [ %o0 + 8 ], %g2 return false; 400107c8: 10 bf ff f7 b 400107a4 <_Timespec_Less_than+0x4c> 400107cc: 90 10 20 00 clr %o0 =============================================================================== 400061c8 <_User_extensions_Handler_initialization>: size_t n; size_t i; initial_table = _User_extensions_Initial_extensions; initial_switch_controls = _User_extensions_Initial_switch_controls; n = _User_extensions_Initial_count; 400061c8: 03 10 00 5e sethi %hi(0x40017800), %g1 400061cc: c4 00 61 18 ld [ %g1 + 0x118 ], %g2 ! 40017918 <_User_extensions_Initial_count> for ( i = 0 ; i < n ; ++i ) { 400061d0: 80 a0 a0 00 cmp %g2, 0 400061d4: 02 80 00 1f be 40006250 <_User_extensions_Handler_initialization+0x88> <== NEVER TAKEN 400061d8: 15 10 00 6b sethi %hi(0x4001ac00), %o2 400061dc: 94 12 a1 50 or %o2, 0x150, %o2 ! 4001ad50 <_User_extensions_Switches_list> 400061e0: c8 02 a0 08 ld [ %o2 + 8 ], %g4 400061e4: 9b 28 a0 01 sll %g2, 1, %o5 400061e8: 03 10 00 71 sethi %hi(0x4001c400), %g1 400061ec: 9a 03 40 02 add %o5, %g2, %o5 400061f0: 82 10 62 b8 or %g1, 0x2b8, %g1 400061f4: 05 10 00 5e sethi %hi(0x40017800), %g2 400061f8: 9b 2b 60 02 sll %o5, 2, %o5 400061fc: 84 10 a1 2c or %g2, 0x12c, %g2 40006200: 98 10 20 00 clr %o4 40006204: 9a 03 40 01 add %o5, %g1, %o5 the_node->next = tail; 40006208: 96 02 a0 04 add %o2, 4, %o3 User_extensions_thread_switch_extension callout; callout = initial_table[ i ].thread_switch; 4000620c: c6 00 80 00 ld [ %g2 ], %g3 if ( callout != NULL ) { 40006210: 80 a0 e0 00 cmp %g3, 0 40006214: 22 80 00 09 be,a 40006238 <_User_extensions_Handler_initialization+0x70> 40006218: 82 00 60 0c add %g1, 0xc, %g1 User_extensions_Switch_control *c; c = &initial_switch_controls[ i ]; c->thread_switch = callout; 4000621c: c6 20 60 08 st %g3, [ %g1 + 8 ] } 40006220: 98 10 20 01 mov 1, %o4 the_node->next = tail; 40006224: d6 20 40 00 st %o3, [ %g1 ] old_last->next = the_node; 40006228: c2 21 00 00 st %g1, [ %g4 ] the_node->previous = old_last; 4000622c: c8 20 60 04 st %g4, [ %g1 + 4 ] } 40006230: 88 10 00 01 mov %g1, %g4 for ( i = 0 ; i < n ; ++i ) { 40006234: 82 00 60 0c add %g1, 0xc, %g1 40006238: 80 a0 40 0d cmp %g1, %o5 4000623c: 12 bf ff f4 bne 4000620c <_User_extensions_Handler_initialization+0x44> 40006240: 84 00 a0 24 add %g2, 0x24, %g2 40006244: 80 8b 20 ff btst 0xff, %o4 40006248: 32 80 00 02 bne,a 40006250 <_User_extensions_Handler_initialization+0x88> 4000624c: c8 22 a0 08 st %g4, [ %o2 + 8 ] _Chain_Initialize_node( &c->Node ); _Chain_Append_unprotected( &_User_extensions_Switches_list, &c->Node ); } } } 40006250: 81 c3 e0 08 retl 40006254: 01 00 00 00 nop =============================================================================== 4000639c <_User_extensions_Iterate>: void _User_extensions_Iterate( void *arg, User_extensions_Visitor visitor, Chain_Iterator_direction direction ) { 4000639c: 9d e3 bf 88 save %sp, -120, %sp ISR_lock_Context lock_context; executing = _Thread_Get_executing(); initial_begin = _User_extensions_Initial_extensions; initial_end = initial_begin + _User_extensions_Initial_count; 400063a0: 03 10 00 5e sethi %hi(0x40017800), %g1 400063a4: c2 00 61 18 ld [ %g1 + 0x118 ], %g1 ! 40017918 <_User_extensions_Initial_count> 400063a8: bb 28 60 03 sll %g1, 3, %i5 400063ac: 21 10 00 5e sethi %hi(0x40017800), %l0 400063b0: ba 07 40 01 add %i5, %g1, %i5 400063b4: a0 14 21 1c or %l0, 0x11c, %l0 400063b8: bb 2f 60 02 sll %i5, 2, %i5 ISR_Level level; _ISR_Local_disable( level ); #endif executing = _Thread_Executing; 400063bc: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4 if ( direction == CHAIN_ITERATOR_FORWARD ) { 400063c0: 80 a6 a0 00 cmp %i2, 0 400063c4: 12 80 00 51 bne 40006508 <_User_extensions_Iterate+0x16c> 400063c8: ba 04 00 1d add %l0, %i5, %i5 initial_current = initial_begin; while ( initial_current != initial_end ) { 400063cc: 80 a7 40 10 cmp %i5, %l0 400063d0: 02 80 00 0a be 400063f8 <_User_extensions_Iterate+0x5c> <== NEVER TAKEN 400063d4: b6 10 00 10 mov %l0, %i3 (*visitor)( executing, arg, initial_current ); 400063d8: 94 10 00 1b mov %i3, %o2 400063dc: 92 10 00 18 mov %i0, %o1 400063e0: 9f c6 40 00 call %i1 400063e4: 90 10 00 1c mov %i4, %o0 ++initial_current; 400063e8: b6 06 e0 24 add %i3, 0x24, %i3 while ( initial_current != initial_end ) { 400063ec: 80 a7 40 1b cmp %i5, %i3 400063f0: 12 bf ff fb bne 400063dc <_User_extensions_Iterate+0x40> 400063f4: 94 10 00 1b mov %i3, %o2 } end = _Chain_Immutable_tail( &_User_extensions_List.Active ); 400063f8: 37 10 00 6b sethi %hi(0x4001ac00), %i3 400063fc: b6 16 e1 6c or %i3, 0x16c, %i3 ! 4001ad6c <_User_extensions_List+0x4> 40006400: 86 06 ff fc add %i3, -4, %g3 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40006404: 91 d0 20 09 ta 9 old_last = tail->previous; 40006408: de 00 e0 14 ld [ %g3 + 0x14 ], %o7 tail->previous = the_node; 4000640c: 88 07 bf ec add %fp, -20, %g4 the_node->next = tail; 40006410: 9a 00 e0 10 add %g3, 0x10, %o5 tail->previous = the_node; 40006414: c8 20 e0 14 st %g4, [ %g3 + 0x14 ] the_iterator->direction = direction; if ( direction == CHAIN_ITERATOR_FORWARD ) { the_iterator->position = _Chain_Head( the_chain ); } else { the_iterator->position = _Chain_Tail( the_chain ); 40006418: 84 00 e0 04 add %g3, 4, %g2 the_node->next = tail; 4000641c: da 27 bf ec st %o5, [ %fp + -20 ] if ( direction == CHAIN_ITERATOR_FORWARD ) { 40006420: 80 a6 a0 00 cmp %i2, 0 old_last->next = the_node; 40006424: c8 23 c0 00 st %g4, [ %o7 ] the_node->previous = old_last; 40006428: de 27 bf f0 st %o7, [ %fp + -16 ] if ( direction == CHAIN_ITERATOR_FORWARD ) { 4000642c: 12 80 00 03 bne 40006438 <_User_extensions_Iterate+0x9c> 40006430: f4 27 bf f4 st %i2, [ %fp + -12 ] the_iterator->position = _Chain_Head( the_chain ); 40006434: 84 10 00 03 mov %g3, %g2 &_User_extensions_List.Iterators, &iter.Iterator, direction ); if ( executing != NULL ) { 40006438: 80 a7 20 00 cmp %i4, 0 4000643c: 02 80 00 05 be 40006450 <_User_extensions_Iterate+0xb4> 40006440: c4 27 bf f8 st %g2, [ %fp + -8 ] iter.previous = executing->last_user_extensions_iterator; 40006444: c6 07 21 8c ld [ %i4 + 0x18c ], %g3 40006448: c6 27 bf fc st %g3, [ %fp + -4 ] executing->last_user_extensions_iterator = &iter; 4000644c: c8 27 21 8c st %g4, [ %i4 + 0x18c ] 40006450: 10 80 00 0f b 4000648c <_User_extensions_Iterate+0xf0> 40006454: 86 10 00 1a mov %i2, %g3 } while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) { 40006458: 80 a6 c0 0a cmp %i3, %o2 4000645c: 02 80 00 14 be 400064ac <_User_extensions_Iterate+0x110> 40006460: 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; 40006464: d4 27 bf f8 st %o2, [ %fp + -8 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40006468: 91 d0 20 0a ta 0xa 4000646c: 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 ); 40006470: 94 02 a0 14 add %o2, 0x14, %o2 40006474: 92 10 00 18 mov %i0, %o1 40006478: 9f c6 40 00 call %i1 4000647c: 90 10 00 1c mov %i4, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40006480: 91 d0 20 09 ta 9 if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) { 40006484: c6 07 bf f4 ld [ %fp + -12 ], %g3 return _Chain_Next( the_iterator->position ); 40006488: c4 07 bf f8 ld [ %fp + -8 ], %g2 if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) { 4000648c: 80 a0 e0 00 cmp %g3, 0 40006490: 22 bf ff f2 be,a 40006458 <_User_extensions_Iterate+0xbc> 40006494: d4 00 80 00 ld [ %g2 ], %o2 return the_node->previous; 40006498: d4 00 a0 04 ld [ %g2 + 4 ], %o2 while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) { 4000649c: 80 a6 c0 0a cmp %i3, %o2 400064a0: 32 bf ff f2 bne,a 40006468 <_User_extensions_Iterate+0xcc> 400064a4: d4 27 bf f8 st %o2, [ %fp + -8 ] _User_extensions_Acquire( &lock_context ); } if ( executing != NULL ) { 400064a8: 80 a7 20 00 cmp %i4, 0 400064ac: 02 80 00 03 be 400064b8 <_User_extensions_Iterate+0x11c> 400064b0: c4 07 bf fc ld [ %fp + -4 ], %g2 executing->last_user_extensions_iterator = iter.previous; 400064b4: c4 27 21 8c st %g2, [ %i4 + 0x18c ] next = the_node->next; 400064b8: c6 07 bf ec ld [ %fp + -20 ], %g3 previous = the_node->previous; 400064bc: c4 07 bf f0 ld [ %fp + -16 ], %g2 next->previous = previous; 400064c0: c4 20 e0 04 st %g2, [ %g3 + 4 ] previous->next = next; 400064c4: c6 20 80 00 st %g3, [ %g2 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400064c8: 91 d0 20 0a ta 0xa 400064cc: 01 00 00 00 nop _Chain_Iterator_destroy( &iter.Iterator ); _User_extensions_Release( &lock_context ); if ( direction == CHAIN_ITERATOR_BACKWARD ) { 400064d0: 80 a6 a0 01 cmp %i2, 1 400064d4: 02 80 00 09 be 400064f8 <_User_extensions_Iterate+0x15c> 400064d8: 80 a7 40 10 cmp %i5, %l0 while ( initial_current != initial_begin ) { --initial_current; (*visitor)( executing, arg, initial_current ); } } } 400064dc: 81 c7 e0 08 ret 400064e0: 81 e8 00 00 restore (*visitor)( executing, arg, initial_current ); 400064e4: 92 10 00 18 mov %i0, %o1 400064e8: 94 10 00 1d mov %i5, %o2 400064ec: 9f c6 40 00 call %i1 400064f0: 90 10 00 1c mov %i4, %o0 while ( initial_current != initial_begin ) { 400064f4: 80 a7 40 10 cmp %i5, %l0 400064f8: 12 bf ff fb bne 400064e4 <_User_extensions_Iterate+0x148> 400064fc: ba 07 7f dc add %i5, -36, %i5 } 40006500: 81 c7 e0 08 ret 40006504: 81 e8 00 00 restore end = _Chain_Immutable_head( &_User_extensions_List.Active ); 40006508: 07 10 00 6b sethi %hi(0x4001ac00), %g3 4000650c: 86 10 e1 68 or %g3, 0x168, %g3 ! 4001ad68 <_User_extensions_List> 40006510: 10 bf ff bd b 40006404 <_User_extensions_Iterate+0x68> 40006514: b6 10 00 03 mov %g3, %i3 =============================================================================== 400143bc <_User_extensions_Remove_set>: __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400143bc: 91 d0 20 09 ta 9 return the_node->next; 400143c0: 09 10 00 63 sethi %hi(0x40018c00), %g4 400143c4: 88 11 20 84 or %g4, 0x84, %g4 ! 40018c84 <_User_extensions_List> 400143c8: c4 01 20 0c ld [ %g4 + 0xc ], %g2 400143cc: da 02 20 04 ld [ %o0 + 4 ], %o5 while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) { 400143d0: 88 01 20 10 add %g4, 0x10, %g4 400143d4: 80 a0 80 04 cmp %g2, %g4 400143d8: 12 80 00 08 bne 400143f8 <_User_extensions_Remove_set+0x3c> <== NEVER TAKEN 400143dc: d8 02 00 00 ld [ %o0 ], %o4 next->previous = previous; 400143e0: 10 80 00 14 b 40014430 <_User_extensions_Remove_set+0x74> 400143e4: da 23 20 04 st %o5, [ %o4 + 4 ] return the_node->next; 400143e8: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) { 400143ec: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED 400143f0: 22 80 00 10 be,a 40014430 <_User_extensions_Remove_set+0x74> <== NOT EXECUTED 400143f4: da 23 20 04 st %o5, [ %o4 + 4 ] <== NOT EXECUTED if ( iter->position == the_node_to_extract ) { 400143f8: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 <== NOT EXECUTED 400143fc: 80 a2 00 03 cmp %o0, %g3 <== NOT EXECUTED 40014400: 32 bf ff fb bne,a 400143ec <_User_extensions_Remove_set+0x30> <== NOT EXECUTED 40014404: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED if ( iter->direction == CHAIN_ITERATOR_FORWARD ) { 40014408: c6 00 a0 08 ld [ %g2 + 8 ], %g3 <== NOT EXECUTED 4001440c: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40014410: 32 bf ff f6 bne,a 400143e8 <_User_extensions_Remove_set+0x2c> <== NOT EXECUTED 40014414: d8 20 a0 0c st %o4, [ %g2 + 0xc ] <== NOT EXECUTED iter->position = _Chain_Previous( the_node_to_extract ); 40014418: da 20 a0 0c st %o5, [ %g2 + 0xc ] <== NOT EXECUTED return the_node->next; 4001441c: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) { 40014420: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED 40014424: 32 bf ff f6 bne,a 400143fc <_User_extensions_Remove_set+0x40> <== NOT EXECUTED 40014428: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 <== NOT EXECUTED next->previous = previous; 4001442c: da 23 20 04 st %o5, [ %o4 + 4 ] <== NOT EXECUTED previous->next = next; 40014430: d8 23 40 00 st %o4, [ %o5 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40014434: 91 d0 20 0a ta 0xa 40014438: 01 00 00 00 nop /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) { 4001443c: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 40014440: 80 a0 60 00 cmp %g1, 0 40014444: 02 80 00 09 be 40014468 <_User_extensions_Remove_set+0xac> 40014448: 01 00 00 00 nop __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 4001444c: 91 d0 20 09 ta 9 next = the_node->next; 40014450: c6 02 20 08 ld [ %o0 + 8 ], %g3 previous = the_node->previous; 40014454: c4 02 20 0c ld [ %o0 + 0xc ], %g2 next->previous = previous; 40014458: c4 20 e0 04 st %g2, [ %g3 + 4 ] previous->next = next; 4001445c: c6 20 80 00 st %g3, [ %g2 ] __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40014460: 91 d0 20 0a ta 0xa 40014464: 01 00 00 00 nop _Per_CPU_Acquire_all( &lock_context ); _Chain_Extract_unprotected( &the_extension->Switch.Node ); _Per_CPU_Release_all( &lock_context ); } } 40014468: 81 c3 e0 08 retl 4001446c: 01 00 00 00 nop =============================================================================== 40006258 <_User_extensions_Thread_create_visitor>: void _User_extensions_Thread_create_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 40006258: 9d e3 bf a0 save %sp, -96, %sp User_extensions_thread_create_extension callout = callouts->thread_create; 4000625c: c4 06 80 00 ld [ %i2 ], %g2 if ( callout != NULL ) { 40006260: 80 a0 a0 00 cmp %g2, 0 40006264: 02 80 00 0b be 40006290 <_User_extensions_Thread_create_visitor+0x38> 40006268: 01 00 00 00 nop User_extensions_Thread_create_context *ctx = arg; ctx->ok = ctx->ok && (*callout)( executing, ctx->created ); 4000626c: c2 0e 60 04 ldub [ %i1 + 4 ], %g1 40006270: 80 88 60 ff btst 0xff, %g1 40006274: 22 80 00 07 be,a 40006290 <_User_extensions_Thread_create_visitor+0x38> <== NEVER TAKEN 40006278: c2 2e 60 04 stb %g1, [ %i1 + 4 ] 4000627c: d2 06 40 00 ld [ %i1 ], %o1 40006280: 9f c0 80 00 call %g2 40006284: 90 10 00 18 mov %i0, %o0 40006288: 82 10 00 08 mov %o0, %g1 4000628c: c2 2e 60 04 stb %g1, [ %i1 + 4 ] } } 40006290: 81 c7 e0 08 ret 40006294: 81 e8 00 00 restore =============================================================================== 40006658 <_Watchdog_Do_tickle>: #ifdef RTEMS_SMP ISR_lock_Control *lock, #endif ISR_lock_Context *lock_context ) { 40006658: 9d e3 bf a0 save %sp, -96, %sp RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 4000665c: ba 10 20 02 mov 2, %i5 do { if ( first->expire <= now ) { 40006660: c2 06 60 18 ld [ %i1 + 0x18 ], %g1 40006664: 80 a0 40 1a cmp %g1, %i2 40006668: 18 80 00 25 bgu 400066fc <_Watchdog_Do_tickle+0xa4> 4000666c: 01 00 00 00 nop 40006670: 22 80 00 20 be,a 400066f0 <_Watchdog_Do_tickle+0x98> 40006674: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 return RB_RIGHT( the_node, Node ); 40006678: c2 06 60 04 ld [ %i1 + 4 ], %g1 if ( node != NULL ) { 4000667c: 80 a0 60 00 cmp %g1, 0 40006680: 22 80 00 1a be,a 400066e8 <_Watchdog_Do_tickle+0x90> 40006684: c2 06 60 08 ld [ %i1 + 8 ], %g1 return RB_LEFT( the_node, Node ); 40006688: 84 10 00 01 mov %g1, %g2 4000668c: c2 00 40 00 ld [ %g1 ], %g1 while ( ( left = _RBTree_Left( node ) ) != NULL ) { 40006690: 80 a0 60 00 cmp %g1, 0 40006694: 32 bf ff fe bne,a 4000668c <_Watchdog_Do_tickle+0x34> <== NEVER TAKEN 40006698: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED header->first = node; 4000669c: 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 ); 400066a0: 92 10 00 19 mov %i1, %o1 400066a4: 40 00 08 60 call 40008824 <_RBTree_Extract> 400066a8: 90 10 00 18 mov %i0, %o0 _Watchdog_Set_state( first, WATCHDOG_INACTIVE ); routine = first->routine; 400066ac: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 400066b0: fa 26 60 0c st %i5, [ %i1 + 0xc ] register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400066b4: c2 07 00 00 ld [ %i4 ], %g1 __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400066b8: 91 d0 20 0a ta 0xa 400066bc: 01 00 00 00 nop _ISR_lock_Release_and_ISR_enable( lock, lock_context ); ( *routine )( first ); 400066c0: 9f c0 80 00 call %g2 400066c4: 90 10 00 19 mov %i1, %o0 __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400066c8: 91 d0 20 09 ta 9 _ISR_lock_ISR_disable_and_acquire( lock, lock_context ); 400066cc: c2 27 00 00 st %g1, [ %i4 ] return (Watchdog_Control *) header->first; 400066d0: f2 06 20 04 ld [ %i0 + 4 ], %i1 } else { break; } first = _Watchdog_Header_first( header ); } while ( first != NULL ); 400066d4: 80 a6 60 00 cmp %i1, 0 400066d8: 32 bf ff e3 bne,a 40006664 <_Watchdog_Do_tickle+0xc> 400066dc: c2 06 60 18 ld [ %i1 + 0x18 ], %g1 } 400066e0: 81 c7 e0 08 ret 400066e4: 81 e8 00 00 restore header->first = _RBTree_Parent( &the_watchdog->Node.RBTree ); 400066e8: 10 bf ff ee b 400066a0 <_Watchdog_Do_tickle+0x48> 400066ec: c2 26 20 04 st %g1, [ %i0 + 4 ] if ( first->expire <= now ) { 400066f0: 80 a0 40 1b cmp %g1, %i3 400066f4: 28 bf ff e2 bleu,a 4000667c <_Watchdog_Do_tickle+0x24> 400066f8: c2 06 60 04 ld [ %i1 + 4 ], %g1 } 400066fc: 81 c7 e0 08 ret 40006700: 81 e8 00 00 restore =============================================================================== 40006518 <_Watchdog_Insert>: _Assert( _Watchdog_Get_state( the_watchdog ) == WATCHDOG_INACTIVE ); link = _RBTree_Root_reference( &header->Watchdogs ); parent = NULL; old_first = header->first; 40006518: da 02 20 04 ld [ %o0 + 4 ], %o5 new_first = &the_watchdog->Node.RBTree; the_watchdog->expire = expire; 4000651c: d4 3a 60 18 std %o2, [ %o1 + 0x18 ] while ( *link != NULL ) { 40006520: c2 02 00 00 ld [ %o0 ], %g1 40006524: 80 a0 60 00 cmp %g1, 0 40006528: 02 80 00 24 be 400065b8 <_Watchdog_Insert+0xa0> 4000652c: 88 10 00 09 mov %o1, %g4 Watchdog_Control *parent_watchdog; parent = *link; parent_watchdog = (Watchdog_Control *) parent; if ( expire < parent_watchdog->expire ) { 40006530: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 40006534: 80 a0 80 0a cmp %g2, %o2 40006538: 18 80 00 12 bgu 40006580 <_Watchdog_Insert+0x68> 4000653c: 86 10 00 01 mov %g1, %g3 40006540: 32 80 00 07 bne,a 4000655c <_Watchdog_Insert+0x44> 40006544: c4 00 60 04 ld [ %g1 + 4 ], %g2 40006548: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 4000654c: 80 a0 80 0b cmp %g2, %o3 40006550: 18 80 00 0c bgu 40006580 <_Watchdog_Insert+0x68> 40006554: 86 10 00 01 mov %g1, %g3 while ( *link != NULL ) { 40006558: c4 00 60 04 ld [ %g1 + 4 ], %g2 */ RTEMS_INLINE_ROUTINE RBTree_Node **_RBTree_Right_reference( RBTree_Node *the_node ) { return &RB_RIGHT( the_node, Node ); 4000655c: 86 00 60 04 add %g1, 4, %g3 40006560: 80 a0 a0 00 cmp %g2, 0 40006564: 02 80 00 0b be 40006590 <_Watchdog_Insert+0x78> 40006568: 88 10 00 0d mov %o5, %g4 4000656c: 82 10 00 02 mov %g2, %g1 if ( expire < parent_watchdog->expire ) { 40006570: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 40006574: 80 a0 80 0a cmp %g2, %o2 40006578: 08 bf ff f2 bleu 40006540 <_Watchdog_Insert+0x28> <== ALWAYS TAKEN 4000657c: 86 10 00 01 mov %g1, %g3 while ( *link != NULL ) { 40006580: c4 00 c0 00 ld [ %g3 ], %g2 40006584: 80 a0 a0 00 cmp %g2, 0 40006588: 32 bf ff fa bne,a 40006570 <_Watchdog_Insert+0x58> 4000658c: 82 10 00 02 mov %g2, %g1 link = _RBTree_Right_reference( parent ); new_first = old_first; } } header->first = new_first; 40006590: c8 22 20 04 st %g4, [ %o0 + 4 ] RB_SET( child, parent, Node ); 40006594: c2 22 60 08 st %g1, [ %o1 + 8 ] 40006598: 82 10 20 01 mov 1, %g1 4000659c: c0 22 60 04 clr [ %o1 + 4 ] 400065a0: c0 22 40 00 clr [ %o1 ] 400065a4: c2 22 60 0c st %g1, [ %o1 + 0xc ] *link = child; 400065a8: d2 20 c0 00 st %o1, [ %g3 ] _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 ); 400065ac: 82 13 c0 00 mov %o7, %g1 400065b0: 40 00 0a 05 call 40008dc4 <_RBTree_Insert_color> 400065b4: 9e 10 40 00 mov %g1, %o7 header->first = new_first; 400065b8: c8 22 20 04 st %g4, [ %o0 + 4 ] link = _RBTree_Root_reference( &header->Watchdogs ); 400065bc: 86 10 00 08 mov %o0, %g3 RB_SET( child, parent, Node ); 400065c0: c2 22 60 08 st %g1, [ %o1 + 8 ] 400065c4: 82 10 20 01 mov 1, %g1 400065c8: c0 22 60 04 clr [ %o1 + 4 ] 400065cc: c0 22 40 00 clr [ %o1 ] 400065d0: c2 22 60 0c st %g1, [ %o1 + 0xc ] *link = child; 400065d4: d2 20 c0 00 st %o1, [ %g3 ] _RBTree_Insert_color( &header->Watchdogs, &the_watchdog->Node.RBTree ); 400065d8: 82 13 c0 00 mov %o7, %g1 400065dc: 40 00 09 fa call 40008dc4 <_RBTree_Insert_color> 400065e0: 9e 10 40 00 mov %g1, %o7 =============================================================================== 400065e4 <_Watchdog_Remove>: void _Watchdog_Remove( Watchdog_Header *header, Watchdog_Control *the_watchdog ) { 400065e4: 9d e3 bf a0 save %sp, -96, %sp if ( _Watchdog_Is_scheduled( the_watchdog ) ) { 400065e8: c2 06 60 0c ld [ %i1 + 0xc ], %g1 400065ec: 80 a0 60 01 cmp %g1, 1 400065f0: 28 80 00 04 bleu,a 40006600 <_Watchdog_Remove+0x1c> 400065f4: c2 06 20 04 ld [ %i0 + 4 ], %g1 } _RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree ); _Watchdog_Set_state( the_watchdog, WATCHDOG_INACTIVE ); } } 400065f8: 81 c7 e0 08 ret 400065fc: 81 e8 00 00 restore if ( header->first == &the_watchdog->Node.RBTree ) { 40006600: 80 a0 40 19 cmp %g1, %i1 40006604: 22 80 00 09 be,a 40006628 <_Watchdog_Remove+0x44> 40006608: c2 06 60 04 ld [ %i1 + 4 ], %g1 _RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree ); 4000660c: 92 10 00 19 mov %i1, %o1 40006610: 40 00 08 85 call 40008824 <_RBTree_Extract> 40006614: 90 10 00 18 mov %i0, %o0 RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 40006618: 82 10 20 02 mov 2, %g1 4000661c: c2 26 60 0c st %g1, [ %i1 + 0xc ] } 40006620: 81 c7 e0 08 ret 40006624: 81 e8 00 00 restore if ( node != NULL ) { 40006628: 80 a0 60 00 cmp %g1, 0 4000662c: 22 80 00 09 be,a 40006650 <_Watchdog_Remove+0x6c> 40006630: c2 06 60 08 ld [ %i1 + 8 ], %g1 return RB_LEFT( the_node, Node ); 40006634: 84 10 00 01 mov %g1, %g2 40006638: c2 00 40 00 ld [ %g1 ], %g1 while ( ( left = _RBTree_Left( node ) ) != NULL ) { 4000663c: 80 a0 60 00 cmp %g1, 0 40006640: 32 bf ff fe bne,a 40006638 <_Watchdog_Remove+0x54> <== NEVER TAKEN 40006644: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED header->first = node; 40006648: 10 bf ff f1 b 4000660c <_Watchdog_Remove+0x28> 4000664c: c4 26 20 04 st %g2, [ %i0 + 4 ] header->first = _RBTree_Parent( &the_watchdog->Node.RBTree ); 40006650: 10 bf ff ef b 4000660c <_Watchdog_Remove+0x28> 40006654: c2 26 20 04 st %g1, [ %i0 + 4 ] =============================================================================== 4000bb08 <_Workspace_Handler_initialization>: void _Workspace_Handler_initialization( const Memory_Information *mem, Heap_Initialization_or_extend_handler extend ) { 4000bb08: 9d e3 bf a0 save %sp, -96, %sp uintptr_t page_size; uintptr_t overhead; size_t i; page_size = CPU_HEAP_ALIGNMENT; remaining = rtems_configuration_get_work_space_size(); 4000bb0c: 03 10 00 5f sethi %hi(0x40017c00), %g1 4000bb10: c2 08 63 2c ldub [ %g1 + 0x32c ], %g1 ! 40017f2c <_Stack_Allocator_avoids_workspace> 4000bb14: 80 a0 60 00 cmp %g1, 0 4000bb18: 02 80 00 43 be 4000bc24 <_Workspace_Handler_initialization+0x11c> <== ALWAYS TAKEN 4000bb1c: 90 10 20 00 clr %o0 init_or_extend = _Heap_Initialize; unified = rtems_configuration_get_unified_work_area(); overhead = _Heap_Area_overhead( page_size ); for ( i = 0; i < _Memory_Get_count( mem ); ++i ) { 4000bb20: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED remaining = rtems_configuration_get_work_space_size(); 4000bb24: 05 10 00 5d sethi %hi(0x40017400), %g2 4000bb28: e0 00 a3 cc ld [ %g2 + 0x3cc ], %l0 ! 400177cc <_Workspace_Size> unified = rtems_configuration_get_unified_work_area(); 4000bb2c: 07 10 00 5f sethi %hi(0x40017c00), %g3 for ( i = 0; i < _Memory_Get_count( mem ); ++i ) { 4000bb30: 80 a0 60 00 cmp %g1, 0 4000bb34: 02 80 00 32 be 4000bbfc <_Workspace_Handler_initialization+0xf4> <== NEVER TAKEN 4000bb38: a0 02 00 10 add %o0, %l0, %l0 init_or_extend = _Heap_Initialize; 4000bb3c: 05 10 00 20 sethi %hi(0x40008000), %g2 } else { size = 0; } } space_available = ( *init_or_extend )( 4000bb40: 23 10 00 73 sethi %hi(0x4001cc00), %l1 if ( unified ) { 4000bb44: e4 08 e3 2d ldub [ %g3 + 0x32d ], %l2 for ( i = 0; i < _Memory_Get_count( mem ); ++i ) { 4000bb48: b4 10 20 00 clr %i2 4000bb4c: b6 10 20 00 clr %i3 init_or_extend = _Heap_Initialize; 4000bb50: 84 10 a2 70 or %g2, 0x270, %g2 space_available = ( *init_or_extend )( 4000bb54: 10 80 00 08 b 4000bb74 <_Workspace_Handler_initialization+0x6c> 4000bb58: a2 14 60 e8 or %l1, 0xe8, %l1 ); _Memory_Consume( area, size ); if ( space_available < remaining ) { remaining -= space_available; 4000bb5c: a0 24 00 08 sub %l0, %o0, %l0 <== NOT EXECUTED } else { remaining = 0; } init_or_extend = extend; 4000bb60: 84 10 00 19 mov %i1, %g2 <== NOT EXECUTED for ( i = 0; i < _Memory_Get_count( mem ); ++i ) { 4000bb64: b6 06 e0 01 inc %i3 <== NOT EXECUTED 4000bb68: 80 a6 c0 01 cmp %i3, %g1 4000bb6c: 1a 80 00 24 bcc 4000bbfc <_Workspace_Handler_initialization+0xf4> <== ALWAYS TAKEN 4000bb70: b4 06 a0 0c add %i2, 0xc, %i2 return &information->areas[ index ]; 4000bb74: fa 06 20 04 ld [ %i0 + 4 ], %i5 4000bb78: ba 07 40 1a add %i5, %i2, %i5 return (uintptr_t) area->end - (uintptr_t) area->free; 4000bb7c: d2 07 60 04 ld [ %i5 + 4 ], %o1 4000bb80: f8 07 60 08 ld [ %i5 + 8 ], %i4 4000bb84: b8 27 00 09 sub %i4, %o1, %i4 if ( free_size > overhead ) { 4000bb88: 80 a7 20 16 cmp %i4, 0x16 4000bb8c: 28 bf ff f7 bleu,a 4000bb68 <_Workspace_Handler_initialization+0x60> 4000bb90: b6 06 e0 01 inc %i3 if ( unified ) { 4000bb94: 80 a4 a0 00 cmp %l2, 0 4000bb98: 12 80 00 0a bne 4000bbc0 <_Workspace_Handler_initialization+0xb8> 4000bb9c: 96 10 20 08 mov 8, %o3 if ( remaining > 0 ) { 4000bba0: 80 a4 20 00 cmp %l0, 0 4000bba4: 02 80 00 1b be 4000bc10 <_Workspace_Handler_initialization+0x108> <== NEVER TAKEN 4000bba8: 94 10 20 00 clr %o2 size = remaining < free_size - overhead ? 4000bbac: 82 07 3f ea add %i4, -22, %g1 remaining + overhead : free_size; 4000bbb0: 80 a0 40 10 cmp %g1, %l0 4000bbb4: 38 80 00 03 bgu,a 4000bbc0 <_Workspace_Handler_initialization+0xb8> <== ALWAYS TAKEN 4000bbb8: b8 04 20 16 add %l0, 0x16, %i4 space_available = ( *init_or_extend )( 4000bbbc: 96 10 20 08 mov 8, %o3 <== NOT EXECUTED 4000bbc0: 94 10 00 1c mov %i4, %o2 4000bbc4: 9f c0 80 00 call %g2 4000bbc8: 90 10 00 11 mov %l1, %o0 area->free = (char *) area->free + consume; 4000bbcc: c2 07 60 04 ld [ %i5 + 4 ], %g1 4000bbd0: 82 00 40 1c add %g1, %i4, %g1 4000bbd4: c2 27 60 04 st %g1, [ %i5 + 4 ] if ( space_available < remaining ) { 4000bbd8: 80 a2 00 10 cmp %o0, %l0 4000bbdc: 0a bf ff e0 bcs 4000bb5c <_Workspace_Handler_initialization+0x54> <== NEVER TAKEN 4000bbe0: c2 06 00 00 ld [ %i0 ], %g1 for ( i = 0; i < _Memory_Get_count( mem ); ++i ) { 4000bbe4: b6 06 e0 01 inc %i3 init_or_extend = extend; 4000bbe8: 84 10 00 19 mov %i1, %g2 remaining = 0; 4000bbec: a0 10 20 00 clr %l0 for ( i = 0; i < _Memory_Get_count( mem ); ++i ) { 4000bbf0: 80 a6 c0 01 cmp %i3, %g1 4000bbf4: 0a bf ff e0 bcs 4000bb74 <_Workspace_Handler_initialization+0x6c> <== NEVER TAKEN 4000bbf8: b4 06 a0 0c add %i2, 0xc, %i2 } } if ( remaining > 0 ) { 4000bbfc: 80 a4 20 00 cmp %l0, 0 4000bc00: 12 80 00 0d bne 4000bc34 <_Workspace_Handler_initialization+0x12c> 4000bc04: 01 00 00 00 nop _Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } _Heap_Protection_set_delayed_free_fraction( &_Workspace_Area, 1 ); } 4000bc08: 81 c7 e0 08 ret 4000bc0c: 81 e8 00 00 restore space_available = ( *init_or_extend )( 4000bc10: 9f c0 80 00 call %g2 <== NOT EXECUTED 4000bc14: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED if ( space_available < remaining ) { 4000bc18: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED init_or_extend = extend; 4000bc1c: 10 bf ff d2 b 4000bb64 <_Workspace_Handler_initialization+0x5c> <== NOT EXECUTED 4000bc20: 84 10 00 19 mov %i1, %g2 <== NOT EXECUTED remaining = rtems_configuration_get_work_space_size(); 4000bc24: 40 00 00 ce call 4000bf5c 4000bc28: 01 00 00 00 nop 4000bc2c: 10 bf ff be b 4000bb24 <_Workspace_Handler_initialization+0x1c> 4000bc30: c2 06 00 00 ld [ %i0 ], %g1 _Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); 4000bc34: 7f ff e3 62 call 400049bc <_Internal_error> 4000bc38: 90 10 20 02 mov 2, %o0 4000bc3c: 01 00 00 00 nop <== NOT EXECUTED