RTEMS-6
Annotated Report
score
Sun Feb 28 22:19:02 2021
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 <memcpy>
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 <memcpy>
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 <memcpy>
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 <rtems_version+0xc>
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 <hex2ascii_data>
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 <memcpy>
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 <memcpy>
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 <strlen>
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 <rtems/score/memory.h>
#include <string.h>
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 <memset>
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 <string.h> /* 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 <memcpy>
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 <memset>
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 <memcpy>
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 <memcpy>
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 <strnlen>
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 <rtems/score/rbtreeimpl.h>
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 <rtems/score/rbtreeimpl.h>
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 <rtems/score/schedulercbsimpl.h>
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 <rtems/score/schedulercbs.h>
#include <rtems/score/wkspace.h>
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 <rtems/score/thread.h>
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 <PROM_START>
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 <RAM_END+0x9de51b00>
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 <RAM_SIZE+0x2fc2830c>
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 <rtems/score/threadimpl.h>
#include <rtems/score/status.h>
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 <RAM_SIZE+0x2fc15fff>
}
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 <strlcpy>
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 <memset>
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 <PROM_START>
}
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 <RAM_SIZE+0x2fc2830c>
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 <rtems/score/threadimpl.h>
#include <rtems/score/assert.h>
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 <rtems/score/threadimpl.h>
#include <rtems/score/schedulerimpl.h>
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 <strlcpy> <== 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 <strlcpy> <== 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 <timehands>
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 <timehands>
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 <timehands>
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 <timehands>
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 <timehands>
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 <timehands>
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 <timehands>
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 <timehands>
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 <rtems_configuration_get_stack_space_size>
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