RTEMS-5
Annotated Report
score
Sat Apr 11 20:02:17 2020
40009454 <_CORE_message_queue_Broadcast>:
const void *buffer,
size_t size,
uint32_t *count,
Thread_queue_Context *queue_context
)
{
40009454: 9d e3 bf a0 save %sp, -96, %sp
Thread_Control *the_thread;
uint32_t number_broadcasted;
if ( size > the_message_queue->maximum_message_size ) {
40009458: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
4000945c: 80 a0 40 1a cmp %g1, %i2
40009460: 0a 80 00 29 bcs 40009504 <_CORE_message_queue_Broadcast+0xb0>
40009464: 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 ) {
40009468: e0 06 20 14 ld [ %i0 + 0x14 ], %l0
4000946c: 80 a4 20 00 cmp %l0, 0
40009470: 32 80 00 1f bne,a 400094ec <_CORE_message_queue_Broadcast+0x98>
40009474: a0 10 20 00 clr %l0
/*
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
the_thread = _Thread_queue_First_locked(
40009478: d0 06 00 00 ld [ %i0 ], %o0
const Thread_queue_Operations *operations
)
{
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
if ( heads != NULL ) {
4000947c: 80 a2 20 00 cmp %o0, 0
40009480: 02 80 00 1b be 400094ec <_CORE_message_queue_Broadcast+0x98>
40009484: c2 06 20 0c ld [ %i0 + 0xc ], %g1
return ( *operations->first )( heads );
40009488: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000948c: 9f c0 40 00 call %g1
40009490: 01 00 00 00 nop
memcpy(destination, source, size);
40009494: 92 10 00 19 mov %i1, %o1
40009498: ba 10 00 08 mov %o0, %i5
&the_message_queue->Wait_queue,
the_message_queue->operations
);
if ( the_thread == NULL ) {
4000949c: 80 a2 20 00 cmp %o0, 0
400094a0: 02 80 00 13 be 400094ec <_CORE_message_queue_Broadcast+0x98>
<== NEVER TAKEN
400094a4: 94 10 00 1a mov %i2, %o2
return NULL;
}
*(size_t *) the_thread->Wait.return_argument = size;
400094a8: c2 02 20 40 ld [ %o0 + 0x40 ], %g1
400094ac: f4 20 40 00 st %i2, [ %g1 ]
0,
queue_context
)
)
) {
number_broadcasted += 1;
400094b0: a0 04 20 01 inc %l0
the_thread->Wait.count = (uint32_t) submit_type;
400094b4: c0 22 20 3c clr [ %o0 + 0x3c ]
memcpy(destination, source, size);
400094b8: 40 00 24 5f call 40012634 <memcpy>
400094bc: d0 02 20 44 ld [ %o0 + 0x44 ], %o0
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
_Thread_queue_Extract_critical(
400094c0: d2 06 20 0c ld [ %i0 + 0xc ], %o1
400094c4: 96 10 00 1c mov %i4, %o3
400094c8: 94 10 00 1d mov %i5, %o2
400094cc: 40 00 0b 9d call 4000c340 <_Thread_queue_Extract_critical>
400094d0: 90 10 00 18 mov %i0, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400094d4: 91 d0 20 09 ta 9
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
400094d8: c2 27 00 00 st %g1, [ %i4 ]
if ( the_message_queue->number_of_pending_messages != 0 ) {
400094dc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
400094e0: 80 a0 60 00 cmp %g1, 0
400094e4: 22 bf ff e6 be,a 4000947c <_CORE_message_queue_Broadcast+0x28>
<== ALWAYS TAKEN
400094e8: d0 06 00 00 ld [ %i0 ], %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400094ec: c2 07 00 00 ld [ %i4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400094f0: 91 d0 20 0a ta 0xa
400094f4: 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;
400094f8: e0 26 c0 00 st %l0, [ %i3 ]
return STATUS_SUCCESSFUL;
}
400094fc: 81 c7 e0 08 ret
40009500: 91 e8 20 00 restore %g0, 0, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40009504: c2 07 00 00 ld [ %i4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009508: 91 d0 20 0a ta 0xa
4000950c: 01 00 00 00 nop
return STATUS_MESSAGE_INVALID_SIZE;
40009510: 31 00 00 1e sethi %hi(0x7800), %i0
40009514: b0 16 22 08 or %i0, 0x208, %i0 ! 7a08 <_ISR_Stack_size+0x6a08>
40009518: 81 c7 e0 08 ret
4000951c: 81 e8 00 00 restore
4000fc58 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Thread_queue_Context *queue_context
)
{
4000fc58: 9d e3 bf a0 save %sp, -96, %sp
return _Chain_Immutable_head( the_chain )->next;
4000fc5c: e0 06 20 1c ld [ %i0 + 0x1c ], %l0
return &the_chain->Tail.Node;
4000fc60: 82 06 20 20 add %i0, 0x20, %g1
if ( !_Chain_Is_empty(the_chain))
4000fc64: 80 a4 00 01 cmp %l0, %g1
4000fc68: 02 80 00 32 be 4000fd30 <_CORE_message_queue_Seize+0xd8>
4000fc6c: 86 06 20 1c add %i0, 0x1c, %g3
new_first = old_first->next;
4000fc70: c4 04 00 00 ld [ %l0 ], %g2
head->next = new_first;
4000fc74: c4 26 20 1c st %g2, [ %i0 + 0x1c ]
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
4000fc78: 92 04 20 10 add %l0, 0x10, %o1
CORE_message_queue_Buffer_control *the_message;
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
4000fc7c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
new_first->previous = head;
4000fc80: c6 20 a0 04 st %g3, [ %g2 + 4 ]
4000fc84: 82 00 7f ff add %g1, -1, %g1
*size_p = the_message->Contents.size;
4000fc88: c4 04 20 0c ld [ %l0 + 0xc ], %g2
the_message_queue->number_of_pending_messages -= 1;
4000fc8c: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
4000fc90: 90 10 00 1a mov %i2, %o0
*size_p = the_message->Contents.size;
4000fc94: c4 26 c0 00 st %g2, [ %i3 ]
executing->Wait.count =
4000fc98: c2 04 20 08 ld [ %l0 + 8 ], %g1
4000fc9c: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
4000fca0: 40 00 22 ea call 40018848 <memcpy>
4000fca4: d4 06 c0 00 ld [ %i3 ], %o2
* is not, then we can go ahead and free the buffer.
*
* NOTE: If we note that the queue was not full before this receive,
* then we can avoid this dequeue.
*/
the_thread = _Thread_queue_First_locked(
4000fca8: d0 06 00 00 ld [ %i0 ], %o0
if ( heads != NULL ) {
4000fcac: 80 a2 20 00 cmp %o0, 0
4000fcb0: 02 80 00 15 be 4000fd04 <_CORE_message_queue_Seize+0xac>
4000fcb4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
return ( *operations->first )( heads );
4000fcb8: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000fcbc: 9f c0 40 00 call %g1
4000fcc0: 01 00 00 00 nop
&the_message_queue->Wait_queue,
the_message_queue->operations
);
if ( the_thread == NULL ) {
4000fcc4: b8 92 20 00 orcc %o0, 0, %i4
4000fcc8: 02 80 00 0f be 4000fd04 <_CORE_message_queue_Seize+0xac>
<== NEVER TAKEN
4000fccc: 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(
4000fcd0: d8 07 20 3c ld [ %i4 + 0x3c ], %o4
4000fcd4: d6 07 20 48 ld [ %i4 + 0x48 ], %o3
4000fcd8: d4 07 20 44 ld [ %i4 + 0x44 ], %o2
4000fcdc: 40 00 1a fd call 400168d0 <_CORE_message_queue_Insert_message>
4000fce0: 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(
4000fce4: d2 06 20 0c ld [ %i0 + 0xc ], %o1
4000fce8: 90 10 00 18 mov %i0, %o0
4000fcec: 96 10 00 1d mov %i5, %o3
4000fcf0: 94 10 00 1c mov %i4, %o2
4000fcf4: 40 00 0b 8a call 40012b1c <_Thread_queue_Extract_critical>
4000fcf8: b0 10 20 00 clr %i0
&the_message_queue->Wait_queue.Queue,
the_message_queue->operations,
the_thread,
queue_context
);
return STATUS_SUCCESSFUL;
4000fcfc: 81 c7 e0 08 ret
4000fd00: 81 e8 00 00 restore
old_last = tail->previous;
4000fd04: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
return &the_chain->Tail.Node;
4000fd08: 84 06 20 34 add %i0, 0x34, %g2
the_node->next = tail;
4000fd0c: c4 24 00 00 st %g2, [ %l0 ]
tail->previous = the_node;
4000fd10: e0 26 20 38 st %l0, [ %i0 + 0x38 ]
old_last->next = the_node;
4000fd14: e0 20 40 00 st %l0, [ %g1 ]
the_node->previous = old_last;
4000fd18: c2 24 20 04 st %g1, [ %l0 + 4 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000fd1c: c2 07 40 00 ld [ %i5 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000fd20: 91 d0 20 0a ta 0xa
4000fd24: 01 00 00 00 nop
return STATUS_SUCCESSFUL;
4000fd28: 81 c7 e0 08 ret
4000fd2c: 91 e8 20 00 restore %g0, 0, %o0
}
#endif
}
if ( !wait ) {
4000fd30: 80 a7 20 00 cmp %i4, 0
4000fd34: 32 80 00 07 bne,a 4000fd50 <_CORE_message_queue_Seize+0xf8>
4000fd38: f4 26 60 44 st %i2, [ %i1 + 0x44 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000fd3c: c2 07 40 00 ld [ %i5 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000fd40: 91 d0 20 0a ta 0xa
4000fd44: 01 00 00 00 nop
_CORE_message_queue_Release( the_message_queue, queue_context );
return STATUS_UNSATISFIED;
4000fd48: 81 c7 e0 08 ret
4000fd4c: 91 e8 2b 0d restore %g0, 0xb0d, %o0
queue_context->thread_state = thread_state;
4000fd50: 82 10 20 10 mov 0x10, %g1
}
executing->Wait.return_argument_second.mutable_object = buffer;
executing->Wait.return_argument = size_p;
4000fd54: f6 26 60 40 st %i3, [ %i1 + 0x40 ]
_Thread_queue_Context_set_thread_state(
queue_context,
STATES_WAITING_FOR_MESSAGE
);
_Thread_queue_Enqueue(
4000fd58: 90 10 00 18 mov %i0, %o0
4000fd5c: c2 27 60 04 st %g1, [ %i5 + 4 ]
4000fd60: 96 10 00 1d mov %i5, %o3
4000fd64: d2 06 20 0c ld [ %i0 + 0xc ], %o1
4000fd68: 40 00 0a f7 call 40012944 <_Thread_queue_Enqueue>
4000fd6c: 94 10 00 19 mov %i1, %o2
return (Status_Control) the_thread->Wait.return_code;
4000fd70: f0 06 60 4c ld [ %i1 + 0x4c ], %i0
the_message_queue->operations,
executing,
queue_context
);
return _Thread_Wait_get_status( executing );
}
4000fd74: 81 c7 e0 08 ret
4000fd78: 81 e8 00 00 restore
4000fd7c <_CORE_message_queue_Submit>:
size_t size,
CORE_message_queue_Submit_types submit_type,
bool wait,
Thread_queue_Context *queue_context
)
{
4000fd7c: 9d e3 bf a0 save %sp, -96, %sp
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
4000fd80: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
4000fd84: 80 a0 40 1b cmp %g1, %i3
4000fd88: 0a 80 00 1e bcs 4000fe00 <_CORE_message_queue_Submit+0x84>
4000fd8c: 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 ) {
4000fd90: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000fd94: 80 a0 60 00 cmp %g1, 0
4000fd98: 32 80 00 23 bne,a 4000fe24 <_CORE_message_queue_Submit+0xa8>
4000fd9c: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
/*
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
the_thread = _Thread_queue_First_locked(
4000fda0: d0 06 00 00 ld [ %i0 ], %o0
if ( heads != NULL ) {
4000fda4: 80 a2 20 00 cmp %o0, 0
4000fda8: 02 80 00 1e be 4000fe20 <_CORE_message_queue_Submit+0xa4>
4000fdac: c2 06 20 0c ld [ %i0 + 0xc ], %g1
return ( *operations->first )( heads );
4000fdb0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000fdb4: 9f c0 40 00 call %g1
4000fdb8: 01 00 00 00 nop
&the_message_queue->Wait_queue,
the_message_queue->operations
);
if ( the_thread == NULL ) {
4000fdbc: a0 92 20 00 orcc %o0, 0, %l0
4000fdc0: 02 80 00 18 be 4000fe20 <_CORE_message_queue_Submit+0xa4>
<== NEVER TAKEN
4000fdc4: 92 10 00 1a mov %i2, %o1
return NULL;
}
*(size_t *) the_thread->Wait.return_argument = size;
4000fdc8: c2 04 20 40 ld [ %l0 + 0x40 ], %g1
4000fdcc: f6 20 40 00 st %i3, [ %g1 ]
the_thread->Wait.count = (uint32_t) submit_type;
4000fdd0: f8 24 20 3c st %i4, [ %l0 + 0x3c ]
memcpy(destination, source, size);
4000fdd4: 94 10 00 1b mov %i3, %o2
4000fdd8: 40 00 22 9c call 40018848 <memcpy>
4000fddc: d0 04 20 44 ld [ %l0 + 0x44 ], %o0
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
_Thread_queue_Extract_critical(
4000fde0: d2 06 20 0c ld [ %i0 + 0xc ], %o1
4000fde4: d6 07 a0 5c ld [ %fp + 0x5c ], %o3
4000fde8: 90 10 00 18 mov %i0, %o0
4000fdec: 94 10 00 10 mov %l0, %o2
4000fdf0: 40 00 0b 4b call 40012b1c <_Thread_queue_Extract_critical>
4000fdf4: b0 10 20 00 clr %i0
4000fdf8: 81 c7 e0 08 ret
4000fdfc: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000fe00: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
4000fe04: c2 00 40 00 ld [ %g1 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000fe08: 91 d0 20 0a ta 0xa
4000fe0c: 01 00 00 00 nop
_CORE_message_queue_Release( the_message_queue, queue_context );
return STATUS_MESSAGE_INVALID_SIZE;
4000fe10: 31 00 00 1e sethi %hi(0x7800), %i0
4000fe14: b0 16 22 08 or %i0, 0x208, %i0 ! 7a08 <_ISR_Stack_size+0x6a08>
4000fe18: 81 c7 e0 08 ret
4000fe1c: 81 e8 00 00 restore
return _Chain_Immutable_head( the_chain )->next;
4000fe20: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
return &the_chain->Tail.Node;
4000fe24: 82 06 20 34 add %i0, 0x34, %g1
if ( !_Chain_Is_empty(the_chain))
4000fe28: 80 a2 40 01 cmp %o1, %g1
4000fe2c: 02 80 00 14 be 4000fe7c <_CORE_message_queue_Submit+0x100>
4000fe30: 84 06 20 30 add %i0, 0x30, %g2
new_first = old_first->next;
4000fe34: c2 02 40 00 ld [ %o1 ], %g1
head->next = new_first;
4000fe38: c2 26 20 30 st %g1, [ %i0 + 0x30 ]
* 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(
4000fe3c: 98 10 00 1c mov %i4, %o4
new_first->previous = head;
4000fe40: c4 20 60 04 st %g2, [ %g1 + 4 ]
4000fe44: 96 10 00 1b mov %i3, %o3
4000fe48: 94 10 00 1a mov %i2, %o2
4000fe4c: 40 00 1a a1 call 400168d0 <_CORE_message_queue_Insert_message>
4000fe50: 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 (
4000fe54: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000fe58: 80 a0 60 01 cmp %g1, 1
4000fe5c: 22 80 00 1c be,a 4000fecc <_CORE_message_queue_Submit+0x150>
4000fe60: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000fe64: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
4000fe68: c2 00 40 00 ld [ %g1 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000fe6c: 91 d0 20 0a ta 0xa
4000fe70: 01 00 00 00 nop
}
#else
_CORE_message_queue_Release( the_message_queue, queue_context );
#endif
return STATUS_SUCCESSFUL;
4000fe74: 81 c7 e0 08 ret
4000fe78: 91 e8 20 00 restore %g0, 0, %o0
/*
* 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 ) {
4000fe7c: 80 a7 60 00 cmp %i5, 0
4000fe80: 02 80 00 0d be 4000feb4 <_CORE_message_queue_Submit+0x138>
4000fe84: 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() ) {
4000fe88: 40 00 13 57 call 40014be4 <_ISR_Is_in_progress>
4000fe8c: 01 00 00 00 nop
4000fe90: 80 a2 20 00 cmp %o0, 0
4000fe94: 22 80 00 16 be,a 4000feec <_CORE_message_queue_Submit+0x170>
4000fe98: f4 26 60 44 st %i2, [ %i1 + 0x44 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000fe9c: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
4000fea0: c2 00 40 00 ld [ %g1 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000fea4: 91 d0 20 0a ta 0xa
4000fea8: 01 00 00 00 nop
_CORE_message_queue_Release( the_message_queue, queue_context );
return STATUS_MESSAGE_QUEUE_WAIT_IN_ISR;
4000feac: 81 c7 e0 08 ret
4000feb0: 91 e8 2b 0d restore %g0, 0xb0d, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000feb4: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
4000feb8: c2 00 40 00 ld [ %g1 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000febc: 91 d0 20 0a ta 0xa
4000fec0: 01 00 00 00 nop
return STATUS_TOO_MANY;
4000fec4: 81 c7 e0 08 ret
4000fec8: 91 e8 2b 05 restore %g0, 0xb05, %o0
&& the_message_queue->notify_handler != NULL
4000fecc: 80 a0 60 00 cmp %g1, 0
4000fed0: 02 bf ff e5 be 4000fe64 <_CORE_message_queue_Submit+0xe8>
4000fed4: d2 07 a0 5c ld [ %fp + 0x5c ], %o1
( *the_message_queue->notify_handler )(
4000fed8: 90 10 00 18 mov %i0, %o0
4000fedc: 9f c0 40 00 call %g1
4000fee0: b0 10 20 00 clr %i0
4000fee4: 81 c7 e0 08 ret
4000fee8: 81 e8 00 00 restore
queue_context->thread_state = thread_state;
4000feec: 82 10 20 10 mov 0x10, %g1
* 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;
executing->Wait.option = (uint32_t) size;
4000fef0: f6 26 60 48 st %i3, [ %i1 + 0x48 ]
_Thread_queue_Context_set_thread_state(
queue_context,
STATES_WAITING_FOR_MESSAGE
);
_Thread_queue_Enqueue(
4000fef4: 90 10 00 18 mov %i0, %o0
4000fef8: d6 07 a0 5c ld [ %fp + 0x5c ], %o3
executing->Wait.count = submit_type;
4000fefc: f8 26 60 3c st %i4, [ %i1 + 0x3c ]
_Thread_queue_Enqueue(
4000ff00: 94 10 00 19 mov %i1, %o2
4000ff04: c2 22 e0 04 st %g1, [ %o3 + 4 ]
4000ff08: 40 00 0a 8f call 40012944 <_Thread_queue_Enqueue>
4000ff0c: d2 06 20 0c ld [ %i0 + 0xc ], %o1
4000ff10: f0 06 60 4c ld [ %i1 + 0x4c ], %i0
executing,
queue_context
);
return _Thread_Wait_get_status( executing );
#endif
}
4000ff14: 81 c7 e0 08 ret
4000ff18: 81 e8 00 00 restore
40005570 <_Freechain_Get>:
Freechain_Control *freechain,
Freechain_Allocator allocator,
size_t number_nodes_to_extend,
size_t node_size
)
{
40005570: 9d e3 bf a0 save %sp, -96, %sp
40005574: ba 10 00 18 mov %i0, %i5
return _Chain_Immutable_head( the_chain )->next;
40005578: f0 06 00 00 ld [ %i0 ], %i0
return &the_chain->Tail.Node;
4000557c: b8 07 60 04 add %i5, 4, %i4
void *starting_address;
starting_address = ( *allocator )( number_nodes_to_extend * node_size );
40005580: 80 a6 00 1c cmp %i0, %i4
40005584: 12 80 00 04 bne 40005594 <_Freechain_Get+0x24>
<== ALWAYS TAKEN
40005588: 80 a6 a0 00 cmp %i2, 0
4000558c: 12 80 00 0a bne 400055b4 <_Freechain_Get+0x44>
<== NOT EXECUTED
40005590: 01 00 00 00 nop
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
40005594: 80 a7 00 18 cmp %i4, %i0
40005598: 02 80 00 12 be 400055e0 <_Freechain_Get+0x70>
<== NEVER TAKEN
4000559c: 01 00 00 00 nop
new_first = old_first->next;
400055a0: c2 06 00 00 ld [ %i0 ], %g1
head->next = new_first;
400055a4: c2 27 40 00 st %g1, [ %i5 ]
new_first->previous = head;
400055a8: fa 20 60 04 st %i5, [ %g1 + 4 ]
400055ac: 81 c7 e0 08 ret
400055b0: 81 e8 00 00 restore
number_nodes_to_extend *= ( starting_address != NULL );
_Chain_Initialize(
400055b4: 9f c6 40 00 call %i1
<== NOT EXECUTED
400055b8: 90 5e 80 1b smul %i2, %i3, %o0
<== NOT EXECUTED
&freechain->Free,
400055bc: 80 a0 00 08 cmp %g0, %o0
<== NOT EXECUTED
_Chain_Initialize(
400055c0: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
&freechain->Free,
400055c4: 94 40 20 00 addx %g0, 0, %o2
<== NOT EXECUTED
starting_address,
number_nodes_to_extend,
400055c8: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
400055cc: 94 5a 80 1a smul %o2, %i2, %o2
<== NOT EXECUTED
400055d0: 40 00 08 0f call 4000760c <_Chain_Initialize>
<== NOT EXECUTED
400055d4: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
400055d8: 10 bf ff ef b 40005594 <_Freechain_Get+0x24>
<== NOT EXECUTED
400055dc: f0 07 40 00 ld [ %i5 ], %i0
<== NOT EXECUTED
return starting_address;
}
void *_Freechain_Get(
Freechain_Control *freechain,
Freechain_Allocator allocator,
400055e0: 81 c7 e0 08 ret
<== NOT EXECUTED
400055e4: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
40006cdc <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
40006cdc: 9d e3 bf a0 save %sp, -96, %sp
40006ce0: 88 06 60 04 add %i1, 4, %g4
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
40006ce4: 80 a6 7f fc cmp %i1, -4
40006ce8: 1a 80 00 8a bcc 40006f10 <_Heap_Allocate_aligned_with_boundary+0x234>
40006cec: da 06 20 10 ld [ %i0 + 0x10 ], %o5
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
40006cf0: 80 a6 e0 00 cmp %i3, 0
40006cf4: 12 80 00 81 bne 40006ef8 <_Heap_Allocate_aligned_with_boundary+0x21c>
40006cf8: 80 a6 40 1b cmp %i1, %i3
return _Heap_Free_list_head(heap)->next;
40006cfc: d2 06 20 08 ld [ %i0 + 8 ], %o1
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
40006d00: 80 a6 00 09 cmp %i0, %o1
40006d04: 02 80 00 78 be 40006ee4 <_Heap_Allocate_aligned_with_boundary+0x208>
40006d08: ba 10 20 00 clr %i5
uintptr_t alloc_begin = alloc_end - alloc_size;
40006d0c: 9e 10 20 04 mov 4, %o7
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
40006d10: 96 03 60 07 add %o5, 7, %o3
uintptr_t alloc_begin = alloc_end - alloc_size;
40006d14: 9e 23 c0 19 sub %o7, %i1, %o7
uintptr_t const free_size = alloc_block_begin - block_begin;
40006d18: 10 80 00 09 b 40006d3c <_Heap_Allocate_aligned_with_boundary+0x60>
40006d1c: 94 10 3f f8 mov -8, %o2
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
40006d20: 80 a7 20 00 cmp %i4, 0
40006d24: 32 80 00 5b bne,a 40006e90 <_Heap_Allocate_aligned_with_boundary+0x1b4>
<== ALWAYS TAKEN
40006d28: 96 10 00 19 mov %i1, %o3
break;
}
block = block->next;
40006d2c: d2 02 60 08 ld [ %o1 + 8 ], %o1
while ( block != free_list_tail ) {
40006d30: 80 a6 00 09 cmp %i0, %o1
40006d34: 22 80 00 6d be,a 40006ee8 <_Heap_Allocate_aligned_with_boundary+0x20c>
40006d38: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
if ( block->size_and_flag > block_size_floor ) {
40006d3c: c2 02 60 04 ld [ %o1 + 4 ], %g1
40006d40: 80 a0 40 04 cmp %g1, %g4
40006d44: 08 bf ff fa bleu 40006d2c <_Heap_Allocate_aligned_with_boundary+0x50>
40006d48: ba 07 60 01 inc %i5
if ( alignment == 0 ) {
40006d4c: 80 a6 a0 00 cmp %i2, 0
40006d50: 02 bf ff f4 be 40006d20 <_Heap_Allocate_aligned_with_boundary+0x44>
40006d54: b8 02 60 08 add %o1, 8, %i4
alloc_begin = _Heap_Check_block(
40006d58: d8 06 20 14 ld [ %i0 + 0x14 ], %o4
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40006d5c: 82 08 7f fe and %g1, -2, %g1
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
40006d60: 86 22 c0 0c sub %o3, %o4, %g3
uintptr_t const block_end = block_begin + block_size;
40006d64: 82 00 40 09 add %g1, %o1, %g1
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
40006d68: 86 00 c0 01 add %g3, %g1, %g3
uintptr_t alloc_begin = alloc_end - alloc_size;
40006d6c: 82 03 c0 01 add %o7, %g1, %g1
return value - (value % alignment);
40006d70: 81 80 20 00 wr %g0, %y
40006d74: 01 00 00 00 nop
40006d78: 01 00 00 00 nop
40006d7c: 01 00 00 00 nop
40006d80: 84 70 40 1a udiv %g1, %i2, %g2
40006d84: 84 58 80 1a smul %g2, %i2, %g2
if ( alloc_begin > alloc_begin_ceiling ) {
40006d88: 80 a0 c0 02 cmp %g3, %g2
40006d8c: 1a 80 00 08 bcc 40006dac <_Heap_Allocate_aligned_with_boundary+0xd0>
40006d90: 80 a6 e0 00 cmp %i3, 0
40006d94: 81 80 20 00 wr %g0, %y
40006d98: 01 00 00 00 nop
40006d9c: 01 00 00 00 nop
40006da0: 01 00 00 00 nop
40006da4: 84 70 c0 1a udiv %g3, %i2, %g2
40006da8: 84 58 80 1a smul %g2, %i2, %g2
if ( boundary != 0 ) {
40006dac: 02 80 00 26 be 40006e44 <_Heap_Allocate_aligned_with_boundary+0x168>
40006db0: 80 a7 00 02 cmp %i4, %g2
alloc_end = alloc_begin + alloc_size;
40006db4: 86 06 40 02 add %i1, %g2, %g3
40006db8: 81 80 20 00 wr %g0, %y
40006dbc: 01 00 00 00 nop
40006dc0: 01 00 00 00 nop
40006dc4: 01 00 00 00 nop
40006dc8: 82 70 c0 1b udiv %g3, %i3, %g1
40006dcc: 82 58 40 1b smul %g1, %i3, %g1
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
40006dd0: 80 a0 40 03 cmp %g1, %g3
40006dd4: 1a 80 00 1b bcc 40006e40 <_Heap_Allocate_aligned_with_boundary+0x164>
40006dd8: 90 06 40 1c add %i1, %i4, %o0
40006ddc: 80 a0 80 01 cmp %g2, %g1
40006de0: 2a 80 00 06 bcs,a 40006df8 <_Heap_Allocate_aligned_with_boundary+0x11c>
40006de4: 80 a2 00 01 cmp %o0, %g1
if ( alloc_begin >= alloc_begin_floor ) {
40006de8: 10 80 00 17 b 40006e44 <_Heap_Allocate_aligned_with_boundary+0x168>
40006dec: 80 a7 00 02 cmp %i4, %g2
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
40006df0: 1a 80 00 14 bcc 40006e40 <_Heap_Allocate_aligned_with_boundary+0x164>
40006df4: 80 a2 00 01 cmp %o0, %g1
if ( boundary_line < boundary_floor ) {
40006df8: 18 bf ff cd bgu 40006d2c <_Heap_Allocate_aligned_with_boundary+0x50>
40006dfc: 82 20 40 19 sub %g1, %i1, %g1
40006e00: 81 80 20 00 wr %g0, %y
40006e04: 01 00 00 00 nop
40006e08: 01 00 00 00 nop
40006e0c: 01 00 00 00 nop
40006e10: 84 70 40 1a udiv %g1, %i2, %g2
40006e14: 84 58 80 1a smul %g2, %i2, %g2
alloc_end = alloc_begin + alloc_size;
40006e18: 86 06 40 02 add %i1, %g2, %g3
40006e1c: 81 80 20 00 wr %g0, %y
40006e20: 01 00 00 00 nop
40006e24: 01 00 00 00 nop
40006e28: 01 00 00 00 nop
40006e2c: 82 70 c0 1b udiv %g3, %i3, %g1
40006e30: 82 58 40 1b smul %g1, %i3, %g1
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
40006e34: 80 a0 80 01 cmp %g2, %g1
40006e38: 0a bf ff ee bcs 40006df0 <_Heap_Allocate_aligned_with_boundary+0x114>
40006e3c: 80 a0 40 03 cmp %g1, %g3
if ( alloc_begin >= alloc_begin_floor ) {
40006e40: 80 a7 00 02 cmp %i4, %g2
40006e44: 18 bf ff ba bgu 40006d2c <_Heap_Allocate_aligned_with_boundary+0x50>
40006e48: 82 22 80 09 sub %o2, %o1, %g1
40006e4c: 81 80 20 00 wr %g0, %y
40006e50: 01 00 00 00 nop
40006e54: 01 00 00 00 nop
40006e58: 01 00 00 00 nop
40006e5c: 86 70 80 0d udiv %g2, %o5, %g3
40006e60: 86 58 c0 0d smul %g3, %o5, %g3
uintptr_t const free_size = alloc_block_begin - block_begin;
40006e64: 82 00 40 03 add %g1, %g3, %g1
if ( free_size >= min_block_size || free_size == 0 ) {
40006e68: 80 a0 40 0c cmp %g1, %o4
40006e6c: 1a 80 00 04 bcc 40006e7c <_Heap_Allocate_aligned_with_boundary+0x1a0>
40006e70: 80 a0 60 00 cmp %g1, 0
40006e74: 32 bf ff af bne,a 40006d30 <_Heap_Allocate_aligned_with_boundary+0x54>
40006e78: d2 02 60 08 ld [ %o1 + 8 ], %o1
40006e7c: b8 10 00 02 mov %g2, %i4
if ( alloc_begin != 0 ) {
40006e80: 80 a7 20 00 cmp %i4, 0
40006e84: 22 bf ff ab be,a 40006d30 <_Heap_Allocate_aligned_with_boundary+0x54>
<== NEVER TAKEN
40006e88: d2 02 60 08 ld [ %o1 + 8 ], %o1
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 );
40006e8c: 96 10 00 19 mov %i1, %o3
40006e90: 94 10 00 1c mov %i4, %o2
40006e94: 7f ff ff 42 call 40006b9c <_Heap_Block_allocate>
40006e98: 90 10 00 18 mov %i0, %o0
alignment,
boundary
);
/* Statistics */
++stats->allocs;
40006e9c: c4 06 20 58 ld [ %i0 + 0x58 ], %g2
stats->searches += search_count;
40006ea0: c2 06 20 54 ld [ %i0 + 0x54 ], %g1
++stats->allocs;
40006ea4: 84 00 a0 01 inc %g2
stats->searches += search_count;
40006ea8: 82 00 40 1d add %g1, %i5, %g1
++stats->allocs;
40006eac: c4 26 20 58 st %g2, [ %i0 + 0x58 ]
stats->searches += search_count;
40006eb0: c2 26 20 54 st %g1, [ %i0 + 0x54 ]
stats->lifetime_allocated += _Heap_Block_size( block );
40006eb4: c4 1e 20 28 ldd [ %i0 + 0x28 ], %g2
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40006eb8: c2 02 20 04 ld [ %o0 + 4 ], %g1
40006ebc: 82 08 7f fe and %g1, -2, %g1
40006ec0: b6 80 c0 01 addcc %g3, %g1, %i3
40006ec4: b4 40 a0 00 addx %g2, 0, %i2
40006ec8: f4 3e 20 28 std %i2, [ %i0 + 0x28 ]
/* Statistics */
++stats->failed_allocs;
}
/* Statistics */
if ( stats->max_search < search_count ) {
40006ecc: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
40006ed0: 80 a0 40 1d cmp %g1, %i5
40006ed4: 2a 80 00 02 bcs,a 40006edc <_Heap_Allocate_aligned_with_boundary+0x200>
40006ed8: fa 26 20 50 st %i5, [ %i0 + 0x50 ]
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
40006edc: 81 c7 e0 08 ret
40006ee0: 91 e8 00 1c restore %g0, %i4, %o0
++stats->failed_allocs;
40006ee4: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
40006ee8: 82 00 60 01 inc %g1
40006eec: b8 10 20 00 clr %i4
40006ef0: 10 bf ff f7 b 40006ecc <_Heap_Allocate_aligned_with_boundary+0x1f0>
40006ef4: c2 26 20 5c st %g1, [ %i0 + 0x5c ]
if ( boundary < alloc_size ) {
40006ef8: 18 80 00 06 bgu 40006f10 <_Heap_Allocate_aligned_with_boundary+0x234>
40006efc: 80 a6 a0 00 cmp %i2, 0
if ( alignment == 0 ) {
40006f00: 22 bf ff 7f be,a 40006cfc <_Heap_Allocate_aligned_with_boundary+0x20>
40006f04: b4 10 00 0d mov %o5, %i2
return _Heap_Free_list_head(heap)->next;
40006f08: 10 bf ff 7e b 40006d00 <_Heap_Allocate_aligned_with_boundary+0x24>
40006f0c: d2 06 20 08 ld [ %i0 + 8 ], %o1
return NULL;
40006f10: b8 10 20 00 clr %i4
}
40006f14: 81 c7 e0 08 ret
40006f18: 91 e8 00 1c restore %g0, %i4, %o0
40006b9c <_Heap_Block_allocate>:
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
40006b9c: 9d e3 bf a0 save %sp, -96, %sp
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40006ba0: c2 06 60 04 ld [ %i1 + 4 ], %g1
40006ba4: 82 08 7f fe and %g1, -2, %g1
return (Heap_Block *) ((uintptr_t) block + offset);
40006ba8: 94 06 40 01 add %i1, %g1, %o2
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40006bac: c6 02 a0 04 ld [ %o2 + 4 ], %g3
40006bb0: ba 10 00 18 mov %i0, %i5
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_prev_used( next_block ) ) {
40006bb4: 80 88 e0 01 btst 1, %g3
40006bb8: b0 06 bf f8 add %i2, -8, %i0
return &heap->free_list;
40006bbc: 96 10 00 1d mov %i5, %o3
40006bc0: 12 80 00 0f bne 40006bfc <_Heap_Block_allocate+0x60>
<== NEVER TAKEN
40006bc4: 98 26 00 19 sub %i0, %i1, %o4
free_list_anchor = _Heap_Free_list_head( heap );
} else {
free_list_anchor = block->prev;
_Heap_Free_list_remove( block );
40006bc8: c6 06 60 08 ld [ %i1 + 8 ], %g3
free_list_anchor = block->prev;
40006bcc: d6 06 60 0c ld [ %i1 + 0xc ], %o3
prev->next = next;
40006bd0: c6 22 e0 08 st %g3, [ %o3 + 8 ]
next->prev = prev;
40006bd4: d6 20 e0 0c st %o3, [ %g3 + 0xc ]
/* Statistics */
--stats->free_blocks;
40006bd8: f8 07 60 44 ld [ %i5 + 0x44 ], %i4
++stats->used_blocks;
40006bdc: c8 07 60 4c ld [ %i5 + 0x4c ], %g4
stats->free_size -= block_size;
40006be0: c6 07 60 3c ld [ %i5 + 0x3c ], %g3
--stats->free_blocks;
40006be4: b8 07 3f ff add %i4, -1, %i4
++stats->used_blocks;
40006be8: 88 01 20 01 inc %g4
stats->free_size -= block_size;
40006bec: 82 20 c0 01 sub %g3, %g1, %g1
--stats->free_blocks;
40006bf0: f8 27 60 44 st %i4, [ %i5 + 0x44 ]
++stats->used_blocks;
40006bf4: c8 27 60 4c st %g4, [ %i5 + 0x4c ]
stats->free_size -= block_size;
40006bf8: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
}
if ( alloc_area_offset < heap->page_size ) {
40006bfc: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40006c00: 80 a0 40 0c cmp %g1, %o4
40006c04: 28 80 00 0e bleu,a 40006c3c <_Heap_Block_allocate+0xa0>
40006c08: c4 07 60 3c ld [ %i5 + 0x3c ], %g2
_Heap_Block_split( heap, block, next_block, free_list_anchor, alloc_size );
40006c0c: 98 03 00 1b add %o4, %i3, %o4
40006c10: 92 10 00 19 mov %i1, %o1
40006c14: 90 10 00 1d mov %i5, %o0
40006c18: 7f ff ff 08 call 40006838 <_Heap_Block_split>
40006c1c: b0 10 00 19 mov %i1, %i0
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
40006c20: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
40006c24: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
40006c28: 80 a0 80 01 cmp %g2, %g1
40006c2c: 38 80 00 02 bgu,a 40006c34 <_Heap_Block_allocate+0x98>
40006c30: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
40006c34: 81 c7 e0 08 ret
40006c38: 81 e8 00 00 restore
return value - (value % alignment);
40006c3c: 81 80 20 00 wr %g0, %y
40006c40: 01 00 00 00 nop
40006c44: 01 00 00 00 nop
40006c48: 01 00 00 00 nop
40006c4c: 86 76 80 01 udiv %i2, %g1, %g3
40006c50: 82 58 c0 01 smul %g3, %g1, %g1
40006c54: b4 26 80 01 sub %i2, %g1, %i2
- HEAP_BLOCK_HEADER_SIZE);
40006c58: b0 26 00 1a sub %i0, %i2, %i0
uintptr_t block_size_adjusted = (uintptr_t) new_block - (uintptr_t) block;
40006c5c: 82 26 00 19 sub %i0, %i1, %g1
stats->free_size += block_size_adjusted;
40006c60: 84 00 80 01 add %g2, %g1, %g2
40006c64: c4 27 60 3c st %g2, [ %i5 + 0x3c ]
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40006c68: c4 06 60 04 ld [ %i1 + 4 ], %g2
if ( _Heap_Is_prev_used( block ) ) {
40006c6c: 80 88 a0 01 btst 1, %g2
40006c70: 12 80 00 11 bne 40006cb4 <_Heap_Block_allocate+0x118>
40006c74: 86 22 80 18 sub %o2, %i0, %g3
return (Heap_Block *) ((uintptr_t) block - block->prev_size);
40006c78: c4 06 40 00 ld [ %i1 ], %g2
40006c7c: b2 26 40 02 sub %i1, %g2, %i1
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40006c80: c4 06 60 04 ld [ %i1 + 4 ], %g2
40006c84: 84 08 bf fe and %g2, -2, %g2
block_size_adjusted += prev_block_size;
40006c88: 82 00 40 02 add %g1, %g2, %g1
block->size_and_flag = block_size_adjusted | HEAP_PREV_BLOCK_USED;
40006c8c: 84 10 60 01 or %g1, 1, %g2
40006c90: c4 26 60 04 st %g2, [ %i1 + 4 ]
_Heap_Block_split( heap, new_block, next_block, free_list_anchor, alloc_size );
40006c94: 98 10 00 1b mov %i3, %o4
new_block->prev_size = block_size_adjusted;
40006c98: c2 26 00 00 st %g1, [ %i0 ]
_Heap_Block_split( heap, new_block, next_block, free_list_anchor, alloc_size );
40006c9c: 92 10 00 18 mov %i0, %o1
new_block->size_and_flag = new_block_size;
40006ca0: c6 26 20 04 st %g3, [ %i0 + 4 ]
_Heap_Block_split( heap, new_block, next_block, free_list_anchor, alloc_size );
40006ca4: 7f ff fe e5 call 40006838 <_Heap_Block_split>
40006ca8: 90 10 00 1d mov %i5, %o0
if ( stats->min_free_size > stats->free_size ) {
40006cac: 10 bf ff de b 40006c24 <_Heap_Block_allocate+0x88>
40006cb0: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
Heap_Block *next = block_before->next;
40006cb4: c8 02 e0 08 ld [ %o3 + 8 ], %g4
new_block->next = next;
40006cb8: c8 26 60 08 st %g4, [ %i1 + 8 ]
new_block->prev = block_before;
40006cbc: d6 26 60 0c st %o3, [ %i1 + 0xc ]
block_before->next = new_block;
40006cc0: f2 22 e0 08 st %i1, [ %o3 + 8 ]
++stats->free_blocks;
40006cc4: 96 10 00 19 mov %i1, %o3
40006cc8: c4 07 60 44 ld [ %i5 + 0x44 ], %g2
next->prev = new_block;
40006ccc: f2 21 20 0c st %i1, [ %g4 + 0xc ]
40006cd0: 84 00 a0 01 inc %g2
40006cd4: 10 bf ff ee b 40006c8c <_Heap_Block_allocate+0xf0>
40006cd8: c4 27 60 44 st %g2, [ %i5 + 0x44 ]
40006f74 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused RTEMS_UNUSED
)
{
40006f74: 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;
40006f78: c0 27 bf f8 clr [ %fp + -8 ]
{
40006f7c: ba 10 00 18 mov %i0, %i5
Heap_Block *extend_last_block = NULL;
40006f80: c0 27 bf fc clr [ %fp + -4 ]
40006f84: b6 86 40 1a addcc %i1, %i2, %i3
Heap_Block *const first_block = heap->first_block;
40006f88: 0a 80 00 83 bcs 40007194 <_Heap_Extend+0x220>
40006f8c: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
uintptr_t const page_size = heap->page_size;
40006f90: f8 06 20 10 ld [ %i0 + 0x10 ], %i4
if ( extend_area_end < extend_area_begin ) {
return 0;
}
extend_area_ok = _Heap_Get_first_and_last_block(
40006f94: d6 06 20 14 ld [ %i0 + 0x14 ], %o3
40006f98: 9a 07 bf fc add %fp, -4, %o5
uintptr_t const free_size = stats->free_size;
40006f9c: f0 06 20 3c ld [ %i0 + 0x3c ], %i0
extend_area_ok = _Heap_Get_first_and_last_block(
40006fa0: 98 07 bf f8 add %fp, -8, %o4
40006fa4: 94 10 00 1c mov %i4, %o2
40006fa8: 92 10 00 1a mov %i2, %o1
40006fac: 7f ff fe 6f call 40006968 <_Heap_Get_first_and_last_block>
40006fb0: 90 10 00 19 mov %i1, %o0
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
40006fb4: 80 a2 20 00 cmp %o0, 0
40006fb8: 02 80 00 77 be 40007194 <_Heap_Extend+0x220>
40006fbc: 82 10 00 10 mov %l0, %g1
Heap_Block *link_above_block = NULL;
40006fc0: a4 10 20 00 clr %l2
Heap_Block *link_below_block = NULL;
40006fc4: 9e 10 20 00 clr %o7
Heap_Block *merge_above_block = NULL;
40006fc8: b4 10 20 00 clr %i2
Heap_Block *merge_below_block = NULL;
40006fcc: a2 10 20 00 clr %l1
return 0;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
40006fd0: 80 a0 40 10 cmp %g1, %l0
40006fd4: 02 80 00 7f be 400071d0 <_Heap_Extend+0x25c>
40006fd8: 88 10 00 01 mov %g1, %g4
uintptr_t const sub_area_end = start_block->prev_size;
40006fdc: c6 00 40 00 ld [ %g1 ], %g3
return value - (value % alignment);
40006fe0: 81 80 20 00 wr %g0, %y
40006fe4: 01 00 00 00 nop
40006fe8: 01 00 00 00 nop
40006fec: 01 00 00 00 nop
40006ff0: 84 70 c0 1c udiv %g3, %i4, %g2
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
40006ff4: 80 a6 40 03 cmp %i1, %g3
40006ff8: 84 58 80 1c smul %g2, %i4, %g2
40006ffc: 1a 80 00 05 bcc 40007010 <_Heap_Extend+0x9c>
40007000: 84 00 bf f8 add %g2, -8, %g2
40007004: 80 a1 00 1b cmp %g4, %i3
40007008: 0a 80 00 63 bcs 40007194 <_Heap_Extend+0x220>
4000700c: 01 00 00 00 nop
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return 0;
}
if ( extend_area_end == sub_area_begin ) {
40007010: 80 a1 00 1b cmp %g4, %i3
40007014: 02 80 00 6d be 400071c8 <_Heap_Extend+0x254>
40007018: 80 a6 c0 03 cmp %i3, %g3
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
4000701c: 0a 80 00 60 bcs 4000719c <_Heap_Extend+0x228>
40007020: 80 a6 40 03 cmp %i1, %g3
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
40007024: 80 a6 40 03 cmp %i1, %g3
40007028: 22 80 00 60 be,a 400071a8 <_Heap_Extend+0x234>
4000702c: f6 20 40 00 st %i3, [ %g1 ]
start_block->prev_size = extend_area_end;
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
40007030: 38 80 00 02 bgu,a 40007038 <_Heap_Extend+0xc4>
40007034: a4 10 00 02 mov %g2, %l2
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40007038: c2 00 a0 04 ld [ %g2 + 4 ], %g1
4000703c: 82 08 7f fe and %g1, -2, %g1
return (Heap_Block *) ((uintptr_t) block + offset);
40007040: 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 );
40007044: 80 a4 00 01 cmp %l0, %g1
40007048: 12 bf ff e3 bne 40006fd4 <_Heap_Extend+0x60>
4000704c: 80 a0 40 10 cmp %g1, %l0
if ( extend_area_begin < heap->area_begin ) {
40007050: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
40007054: 80 a0 40 19 cmp %g1, %i1
40007058: 38 80 00 06 bgu,a 40007070 <_Heap_Extend+0xfc>
4000705c: f2 27 60 18 st %i1, [ %i5 + 0x18 ]
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
40007060: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40007064: 80 a0 40 1b cmp %g1, %i3
40007068: 2a 80 00 02 bcs,a 40007070 <_Heap_Extend+0xfc>
4000706c: f6 27 60 1c st %i3, [ %i5 + 0x1c ]
heap->area_end = extend_area_end;
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
40007070: c2 07 bf f8 ld [ %fp + -8 ], %g1
40007074: c4 07 bf fc ld [ %fp + -4 ], %g2
extend_first_block_size =
40007078: 86 20 80 01 sub %g2, %g1, %g3
extend_first_block->prev_size = extend_area_end;
4000707c: f6 20 40 00 st %i3, [ %g1 ]
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
40007080: 88 10 e0 01 or %g3, 1, %g4
extend_first_block->size_and_flag =
40007084: 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;
40007088: c6 20 80 00 st %g3, [ %g2 ]
extend_last_block->size_and_flag = 0;
4000708c: 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 ) {
40007090: c6 07 60 20 ld [ %i5 + 0x20 ], %g3
40007094: 80 a0 c0 01 cmp %g3, %g1
40007098: 28 80 00 50 bleu,a 400071d8 <_Heap_Extend+0x264>
4000709c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
heap->first_block = extend_first_block;
400070a0: 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 ) {
400070a4: 80 a4 60 00 cmp %l1, 0
400070a8: 02 80 00 51 be 400071ec <_Heap_Extend+0x278>
400070ac: b2 06 60 08 add %i1, 8, %i1
uintptr_t const page_size = heap->page_size;
400070b0: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
uintptr_t remainder = value % alignment;
400070b4: 81 80 20 00 wr %g0, %y
400070b8: 01 00 00 00 nop
400070bc: 01 00 00 00 nop
400070c0: 01 00 00 00 nop
400070c4: 82 76 40 02 udiv %i1, %g2, %g1
400070c8: 82 58 40 02 smul %g1, %g2, %g1
if ( remainder != 0 ) {
400070cc: 82 a6 40 01 subcc %i1, %g1, %g1
400070d0: 22 80 00 05 be,a 400070e4 <_Heap_Extend+0x170>
400070d4: c2 04 40 00 ld [ %l1 ], %g1
return value - remainder + alignment;
400070d8: b2 00 80 19 add %g2, %i1, %i1
400070dc: b2 26 40 01 sub %i1, %g1, %i1
new_first_block->prev_size = first_block->prev_size;
400070e0: c2 04 40 00 ld [ %l1 ], %g1
400070e4: c2 26 7f f8 st %g1, [ %i1 + -8 ]
uintptr_t const new_first_block_begin =
400070e8: 92 06 7f f8 add %i1, -8, %o1
uintptr_t const new_first_block_size =
400070ec: 82 24 40 09 sub %l1, %o1, %g1
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
400070f0: 82 10 60 01 or %g1, 1, %g1
400070f4: c2 22 60 04 st %g1, [ %o1 + 4 ]
_Heap_Free_block( heap, new_first_block );
400070f8: 7f ff ff 89 call 40006f1c <_Heap_Free_block>
400070fc: 90 10 00 1d mov %i5, %o0
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
40007100: 80 a6 a0 00 cmp %i2, 0
40007104: 02 80 00 40 be 40007204 <_Heap_Extend+0x290>
40007108: b6 06 ff f8 add %i3, -8, %i3
return value - (value % alignment);
4000710c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
(last_block->size_and_flag - last_block_new_size)
40007110: c6 06 a0 04 ld [ %i2 + 4 ], %g3
uintptr_t const last_block_new_size = _Heap_Align_down(
40007114: b6 26 c0 1a sub %i3, %i2, %i3
40007118: 81 80 20 00 wr %g0, %y
4000711c: 01 00 00 00 nop
40007120: 01 00 00 00 nop
40007124: 01 00 00 00 nop
40007128: 82 76 c0 02 udiv %i3, %g2, %g1
4000712c: 84 58 40 02 smul %g1, %g2, %g2
new_last_block->size_and_flag =
40007130: 88 06 80 02 add %i2, %g2, %g4
(last_block->size_and_flag - last_block_new_size)
40007134: 82 20 c0 02 sub %g3, %g2, %g1
| HEAP_PREV_BLOCK_USED;
40007138: 82 10 60 01 or %g1, 1, %g1
new_last_block->size_and_flag =
4000713c: c2 21 20 04 st %g1, [ %g4 + 4 ]
_Heap_Free_block( heap, last_block );
40007140: 92 10 00 1a mov %i2, %o1
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
40007144: c2 06 a0 04 ld [ %i2 + 4 ], %g1
40007148: 82 08 60 01 and %g1, 1, %g1
block->size_and_flag = size | flag;
4000714c: 82 10 40 02 or %g1, %g2, %g1
40007150: c2 26 a0 04 st %g1, [ %i2 + 4 ]
40007154: 7f ff ff 72 call 40006f1c <_Heap_Free_block>
40007158: 90 10 00 1d mov %i5, %o0
if ( merge_below_block == NULL && merge_above_block == NULL ) {
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
4000715c: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
40007160: c6 00 a0 04 ld [ %g2 + 4 ], %g3
_Heap_Block_set_size(
40007164: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
40007168: 82 20 40 02 sub %g1, %g2, %g1
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000716c: 86 08 e0 01 and %g3, 1, %g3
block->size_and_flag = size | flag;
40007170: 82 10 40 03 or %g1, %g3, %g1
40007174: c2 20 a0 04 st %g1, [ %g2 + 4 ]
extended_size = stats->free_size - free_size;
/* Statistics */
stats->size += extended_size;
40007178: c4 07 60 38 ld [ %i5 + 0x38 ], %g2
extended_size = stats->free_size - free_size;
4000717c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
40007180: b0 20 40 18 sub %g1, %i0, %i0
stats->size += extended_size;
40007184: 82 00 80 18 add %g2, %i0, %g1
40007188: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
return extended_size;
}
4000718c: 81 c7 e0 08 ret
40007190: 81 e8 00 00 restore
return 0;
40007194: 81 c7 e0 08 ret
40007198: 91 e8 20 00 restore %g0, 0, %o0
if ( sub_area_end == extend_area_begin ) {
4000719c: 12 bf ff a5 bne 40007030 <_Heap_Extend+0xbc>
<== ALWAYS TAKEN
400071a0: 9e 10 00 01 mov %g1, %o7
start_block->prev_size = extend_area_end;
400071a4: f6 20 40 00 st %i3, [ %g1 ]
<== NOT EXECUTED
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
400071a8: c2 00 a0 04 ld [ %g2 + 4 ], %g1
400071ac: 82 08 7f fe and %g1, -2, %g1
return (Heap_Block *) ((uintptr_t) block + offset);
400071b0: 82 00 40 02 add %g1, %g2, %g1
} while ( start_block != first_block );
400071b4: 80 a4 00 01 cmp %l0, %g1
400071b8: 12 bf ff 86 bne 40006fd0 <_Heap_Extend+0x5c>
<== NEVER TAKEN
400071bc: b4 10 00 02 mov %g2, %i2
if ( extend_area_begin < heap->area_begin ) {
400071c0: 10 bf ff a5 b 40007054 <_Heap_Extend+0xe0>
400071c4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
400071c8: 10 bf ff 97 b 40007024 <_Heap_Extend+0xb0>
400071cc: a2 10 00 01 mov %g1, %l1
400071d0: 10 bf ff 83 b 40006fdc <_Heap_Extend+0x68>
400071d4: c8 07 60 18 ld [ %i5 + 0x18 ], %g4
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
400071d8: 80 a0 40 02 cmp %g1, %g2
400071dc: 2a bf ff b2 bcs,a 400070a4 <_Heap_Extend+0x130>
400071e0: c4 27 60 24 st %g2, [ %i5 + 0x24 ]
if ( merge_below_block != NULL ) {
400071e4: 10 bf ff b1 b 400070a8 <_Heap_Extend+0x134>
400071e8: 80 a4 60 00 cmp %l1, 0
} else if ( link_below_block != NULL ) {
400071ec: 80 a3 e0 00 cmp %o7, 0
400071f0: 02 bf ff c4 be 40007100 <_Heap_Extend+0x18c>
400071f4: 9e 23 c0 02 sub %o7, %g2, %o7
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
400071f8: 9e 13 e0 01 or %o7, 1, %o7
last_block->size_and_flag =
400071fc: 10 bf ff c1 b 40007100 <_Heap_Extend+0x18c>
40007200: de 20 a0 04 st %o7, [ %g2 + 4 ]
} else if ( link_above_block != NULL ) {
40007204: 80 a4 a0 00 cmp %l2, 0
40007208: 02 80 00 0b be 40007234 <_Heap_Extend+0x2c0>
4000720c: c2 07 bf f8 ld [ %fp + -8 ], %g1
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
40007210: c4 04 a0 04 ld [ %l2 + 4 ], %g2
40007214: 84 08 a0 01 and %g2, 1, %g2
_Heap_Block_set_size( link, first_block_begin - link_begin );
40007218: 82 20 40 12 sub %g1, %l2, %g1
block->size_and_flag = size | flag;
4000721c: 82 10 40 02 or %g1, %g2, %g1
40007220: c2 24 a0 04 st %g1, [ %l2 + 4 ]
_Heap_Link_above(
40007224: c4 07 bf fc ld [ %fp + -4 ], %g2
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
40007228: c2 00 a0 04 ld [ %g2 + 4 ], %g1
4000722c: 82 10 60 01 or %g1, 1, %g1
40007230: c2 20 a0 04 st %g1, [ %g2 + 4 ]
if ( merge_below_block == NULL && merge_above_block == NULL ) {
40007234: 80 a4 60 00 cmp %l1, 0
40007238: 12 bf ff c9 bne 4000715c <_Heap_Extend+0x1e8>
4000723c: d2 07 bf f8 ld [ %fp + -8 ], %o1
_Heap_Free_block( heap, extend_first_block );
40007240: 7f ff ff 37 call 40006f1c <_Heap_Free_block>
40007244: 90 10 00 1d mov %i5, %o0
_Heap_Set_last_block_size( heap );
40007248: 10 bf ff c6 b 40007160 <_Heap_Extend+0x1ec>
4000724c: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
40007250 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
40007250: 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 ) {
40007254: 80 a6 60 00 cmp %i1, 0
40007258: 02 80 00 41 be 4000735c <_Heap_Free+0x10c>
4000725c: 84 10 20 01 mov 1, %g2
return value - (value % alignment);
40007260: c8 06 20 10 ld [ %i0 + 0x10 ], %g4
return (uintptr_t) block >= (uintptr_t) heap->first_block
40007264: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
return value - (value % alignment);
40007268: 81 80 20 00 wr %g0, %y
4000726c: 01 00 00 00 nop
40007270: 01 00 00 00 nop
40007274: 01 00 00 00 nop
40007278: 82 76 40 04 udiv %i1, %g4, %g1
4000727c: 82 58 40 04 smul %g1, %g4, %g1
- HEAP_BLOCK_HEADER_SIZE);
40007280: 82 00 7f f8 add %g1, -8, %g1
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40007284: 80 a0 40 03 cmp %g1, %g3
40007288: 0a 80 00 35 bcs 4000735c <_Heap_Free+0x10c>
4000728c: 84 10 20 00 clr %g2
40007290: f6 06 20 24 ld [ %i0 + 0x24 ], %i3
40007294: 80 a0 40 1b cmp %g1, %i3
40007298: 38 80 00 32 bgu,a 40007360 <_Heap_Free+0x110>
4000729c: b0 08 a0 ff and %g2, 0xff, %i0
return false;
}
_Heap_Protection_block_check( heap, block );
block_size = _Heap_Block_size( block );
400072a0: fa 00 60 04 ld [ %g1 + 4 ], %i5
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
400072a4: b8 0f 7f fe and %i5, -2, %i4
return (Heap_Block *) ((uintptr_t) block + offset);
400072a8: 88 00 40 1c add %g1, %i4, %g4
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
400072ac: 80 a0 c0 04 cmp %g3, %g4
400072b0: 38 80 00 2c bgu,a 40007360 <_Heap_Free+0x110>
<== NEVER TAKEN
400072b4: b0 08 a0 ff and %g2, 0xff, %i0
<== NOT EXECUTED
400072b8: 80 a6 c0 04 cmp %i3, %g4
400072bc: 2a 80 00 29 bcs,a 40007360 <_Heap_Free+0x110>
400072c0: b0 08 a0 ff and %g2, 0xff, %i0
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
400072c4: f4 01 20 04 ld [ %g4 + 4 ], %i2
400072c8: 80 8e a0 01 btst 1, %i2
400072cc: 02 80 00 24 be 4000735c <_Heap_Free+0x10c>
<== NEVER TAKEN
400072d0: b4 0e bf fe and %i2, -2, %i2
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
400072d4: 80 a6 c0 04 cmp %i3, %g4
400072d8: 02 80 00 24 be 40007368 <_Heap_Free+0x118>
400072dc: ba 0f 60 01 and %i5, 1, %i5
400072e0: 84 01 00 1a add %g4, %i2, %g2
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
400072e4: c4 00 a0 04 ld [ %g2 + 4 ], %g2
400072e8: 80 88 a0 01 btst 1, %g2
400072ec: 12 80 00 20 bne 4000736c <_Heap_Free+0x11c>
400072f0: 80 a7 60 00 cmp %i5, 0
if ( !_Heap_Is_prev_used( block ) ) {
400072f4: 02 80 00 20 be 40007374 <_Heap_Free+0x124>
400072f8: 9e 10 20 01 mov 1, %o7
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;
_Heap_Free_list_replace( next_block, block );
400072fc: c6 01 20 08 ld [ %g4 + 8 ], %g3
40007300: c4 01 20 0c ld [ %g4 + 0xc ], %g2
new_block->prev = prev;
40007304: c4 20 60 0c st %g2, [ %g1 + 0xc ]
uintptr_t const size = block_size + next_block_size;
40007308: b4 07 00 1a add %i4, %i2, %i2
new_block->next = next;
4000730c: c6 20 60 08 st %g3, [ %g1 + 8 ]
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
40007310: 88 16 a0 01 or %i2, 1, %g4
next->prev = new_block;
40007314: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
prev->next = new_block;
40007318: c2 20 a0 08 st %g1, [ %g2 + 8 ]
4000731c: c8 20 60 04 st %g4, [ %g1 + 4 ]
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
40007320: f4 20 40 1a st %i2, [ %g1 + %i2 ]
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
stats->lifetime_freed += block_size;
return( true );
40007324: 84 10 20 01 mov 1, %g2
stats->lifetime_freed += block_size;
40007328: f4 1e 20 30 ldd [ %i0 + 0x30 ], %i2
--stats->used_blocks;
4000732c: c8 06 20 4c ld [ %i0 + 0x4c ], %g4
++stats->frees;
40007330: c6 06 20 60 ld [ %i0 + 0x60 ], %g3
stats->free_size += block_size;
40007334: c2 06 20 3c ld [ %i0 + 0x3c ], %g1
stats->lifetime_freed += block_size;
40007338: 9a 86 c0 1c addcc %i3, %i4, %o5
--stats->used_blocks;
4000733c: 88 01 3f ff add %g4, -1, %g4
++stats->frees;
40007340: 86 00 e0 01 inc %g3
stats->free_size += block_size;
40007344: 82 00 40 1c add %g1, %i4, %g1
stats->lifetime_freed += block_size;
40007348: 98 46 a0 00 addx %i2, 0, %o4
--stats->used_blocks;
4000734c: c8 26 20 4c st %g4, [ %i0 + 0x4c ]
++stats->frees;
40007350: c6 26 20 60 st %g3, [ %i0 + 0x60 ]
stats->free_size += block_size;
40007354: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
stats->lifetime_freed += block_size;
40007358: d8 3e 20 30 std %o4, [ %i0 + 0x30 ]
4000735c: b0 08 a0 ff and %g2, 0xff, %i0
}
40007360: 81 c7 e0 08 ret
40007364: 81 e8 00 00 restore
if ( !_Heap_Is_prev_used( block ) ) {
40007368: 80 a7 60 00 cmp %i5, 0
4000736c: 12 80 00 1c bne 400073dc <_Heap_Free+0x18c>
40007370: 9e 10 20 00 clr %o7
uintptr_t const prev_size = block->prev_size;
40007374: f2 00 40 00 ld [ %g1 ], %i1
40007378: ba 20 40 19 sub %g1, %i1, %i5
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000737c: 80 a7 40 03 cmp %i5, %g3
40007380: 0a bf ff f7 bcs 4000735c <_Heap_Free+0x10c>
<== NEVER TAKEN
40007384: 84 10 20 00 clr %g2
40007388: 80 a7 40 1b cmp %i5, %i3
4000738c: 38 bf ff f5 bgu,a 40007360 <_Heap_Free+0x110>
<== NEVER TAKEN
40007390: b0 08 a0 ff and %g2, 0xff, %i0
<== NOT EXECUTED
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40007394: c6 07 60 04 ld [ %i5 + 4 ], %g3
if ( !_Heap_Is_prev_used ( prev_block) ) {
40007398: 80 88 e0 01 btst 1, %g3
4000739c: 02 bf ff f0 be 4000735c <_Heap_Free+0x10c>
<== NEVER TAKEN
400073a0: 80 a3 e0 00 cmp %o7, 0
if ( next_is_free ) { /* coalesce both */
400073a4: 02 80 00 22 be 4000742c <_Heap_Free+0x1dc>
400073a8: b2 06 40 1c add %i1, %i4, %i1
_Heap_Free_list_remove( next_block );
400073ac: c4 01 20 08 ld [ %g4 + 8 ], %g2
400073b0: c6 01 20 0c ld [ %g4 + 0xc ], %g3
prev->next = next;
400073b4: c4 20 e0 08 st %g2, [ %g3 + 8 ]
uintptr_t const size = block_size + prev_size + next_block_size;
400073b8: b4 06 80 19 add %i2, %i1, %i2
stats->free_blocks -= 1;
400073bc: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
next->prev = prev;
400073c0: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
400073c4: 82 00 7f ff add %g1, -1, %g1
400073c8: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
400073cc: 82 16 a0 01 or %i2, 1, %g1
400073d0: c2 27 60 04 st %g1, [ %i5 + 4 ]
400073d4: 10 bf ff d4 b 40007324 <_Heap_Free+0xd4>
400073d8: f4 27 40 1a st %i2, [ %i5 + %i2 ]
Heap_Block *next = block_before->next;
400073dc: c6 06 20 08 ld [ %i0 + 8 ], %g3
new_block->next = next;
400073e0: c6 20 60 08 st %g3, [ %g1 + 8 ]
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
400073e4: 84 17 20 01 or %i4, 1, %g2
new_block->prev = block_before;
400073e8: f0 20 60 0c st %i0, [ %g1 + 0xc ]
block_before->next = new_block;
400073ec: c2 26 20 08 st %g1, [ %i0 + 8 ]
next->prev = new_block;
400073f0: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
400073f4: c4 20 60 04 st %g2, [ %g1 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
400073f8: c4 01 20 04 ld [ %g4 + 4 ], %g2
400073fc: 84 08 bf fe and %g2, -2, %g2
40007400: c4 21 20 04 st %g2, [ %g4 + 4 ]
++stats->free_blocks;
40007404: c4 06 20 44 ld [ %i0 + 0x44 ], %g2
next_block->prev_size = block_size;
40007408: f8 20 40 1c st %i4, [ %g1 + %i4 ]
++stats->free_blocks;
4000740c: 82 00 a0 01 add %g2, 1, %g1
40007410: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
if ( stats->max_free_blocks < stats->free_blocks ) {
40007414: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
40007418: 80 a0 40 02 cmp %g1, %g2
4000741c: 38 bf ff c2 bgu,a 40007324 <_Heap_Free+0xd4>
40007420: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
return( true );
40007424: 10 bf ff c1 b 40007328 <_Heap_Free+0xd8>
40007428: 84 10 20 01 mov 1, %g2
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000742c: 84 16 60 01 or %i1, 1, %g2
40007430: c4 27 60 04 st %g2, [ %i5 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
40007434: c4 01 20 04 ld [ %g4 + 4 ], %g2
40007438: 84 08 bf fe and %g2, -2, %g2
4000743c: c4 21 20 04 st %g2, [ %g4 + 4 ]
next_block->prev_size = size;
40007440: 10 bf ff b9 b 40007324 <_Heap_Free+0xd4>
40007444: f2 20 40 1c st %i1, [ %g1 + %i4 ]
40006968 <_Heap_Get_first_and_last_block>:
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
40006968: 84 02 20 08 add %o0, 8, %g2
<== NOT EXECUTED
uintptr_t remainder = value % alignment;
4000696c: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40006970: 01 00 00 00 nop
<== NOT EXECUTED
40006974: 01 00 00 00 nop
<== NOT EXECUTED
40006978: 01 00 00 00 nop
<== NOT EXECUTED
4000697c: 82 70 80 0a udiv %g2, %o2, %g1
<== NOT EXECUTED
40006980: 82 58 40 0a smul %g1, %o2, %g1
<== NOT EXECUTED
if ( remainder != 0 ) {
40006984: 82 a0 80 01 subcc %g2, %g1, %g1
<== NOT EXECUTED
40006988: 02 80 00 1a be 400069f0 <_Heap_Get_first_and_last_block+0x88>
<== NOT EXECUTED
4000698c: 88 02 00 09 add %o0, %o1, %g4
<== NOT EXECUTED
40006990: 86 02 bf f8 add %o2, -8, %g3
<== NOT EXECUTED
40006994: 84 00 c0 02 add %g3, %g2, %g2
<== NOT EXECUTED
40006998: 82 20 80 01 sub %g2, %g1, %g1
<== NOT EXECUTED
4000699c: 84 20 40 08 sub %g1, %o0, %g2
<== NOT EXECUTED
400069a0: 84 00 a0 08 add %g2, 8, %g2
<== NOT EXECUTED
heap_area_end < heap_area_begin
400069a4: 80 a1 00 08 cmp %g4, %o0
<== NOT EXECUTED
400069a8: 88 40 20 00 addx %g0, 0, %g4
<== NOT EXECUTED
|| heap_area_size <= overhead
400069ac: 80 a0 80 09 cmp %g2, %o1
<== NOT EXECUTED
_Heap_Align_down( heap_area_size - overhead, page_size );
400069b0: 92 22 40 02 sub %o1, %g2, %o1
<== NOT EXECUTED
|| heap_area_size <= overhead
400069b4: 86 60 3f ff subx %g0, -1, %g3
<== NOT EXECUTED
return value - (value % alignment);
400069b8: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
400069bc: 01 00 00 00 nop
<== NOT EXECUTED
400069c0: 01 00 00 00 nop
<== NOT EXECUTED
400069c4: 01 00 00 00 nop
<== NOT EXECUTED
400069c8: 84 72 40 0a udiv %o1, %o2, %g2
<== NOT EXECUTED
|| first_block_size < min_block_size
400069cc: 80 91 00 03 orcc %g4, %g3, %g0
<== NOT EXECUTED
400069d0: 12 80 00 05 bne 400069e4 <_Heap_Get_first_and_last_block+0x7c>
<== NOT EXECUTED
400069d4: 94 58 80 0a smul %g2, %o2, %o2
<== NOT EXECUTED
400069d8: 80 a2 80 0b cmp %o2, %o3
<== NOT EXECUTED
400069dc: 3a 80 00 08 bcc,a 400069fc <_Heap_Get_first_and_last_block+0x94>
<== NOT EXECUTED
400069e0: c2 23 00 00 st %g1, [ %o4 ]
<== NOT EXECUTED
return false;
400069e4: 90 10 20 00 clr %o0
<== NOT EXECUTED
}
400069e8: 81 c3 e0 08 retl
<== NOT EXECUTED
400069ec: 90 0a 20 01 and %o0, 1, %o0
<== NOT EXECUTED
400069f0: 82 10 00 08 mov %o0, %g1
<== NOT EXECUTED
400069f4: 10 bf ff ec b 400069a4 <_Heap_Get_first_and_last_block+0x3c>
<== NOT EXECUTED
400069f8: 84 10 20 08 mov 8, %g2
<== NOT EXECUTED
return (Heap_Block *) ((uintptr_t) block + offset);
400069fc: 94 02 80 01 add %o2, %g1, %o2
<== NOT EXECUTED
return true;
40006a00: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
*last_block_ptr = last_block;
40006a04: d4 23 40 00 st %o2, [ %o5 ]
<== NOT EXECUTED
}
40006a08: 81 c3 e0 08 retl
<== NOT EXECUTED
40006a0c: 90 0a 20 01 and %o0, 1, %o0
<== NOT EXECUTED
40010548 <_Heap_Get_free_information>:
)
{
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
40010548: c0 22 40 00 clr [ %o1 ]
info->largest = 0;
4001054c: c0 22 60 04 clr [ %o1 + 4 ]
info->total = 0;
40010550: c0 22 60 08 clr [ %o1 + 8 ]
return _Heap_Free_list_head(heap)->next;
40010554: c4 02 20 08 ld [ %o0 + 8 ], %g2
for(the_block = _Heap_Free_list_first(the_heap);
40010558: 80 a2 00 02 cmp %o0, %g2
4001055c: 02 80 00 12 be 400105a4 <_Heap_Get_free_information+0x5c>
<== NEVER TAKEN
40010560: 88 10 20 01 mov 1, %g4
40010564: 9a 10 20 00 clr %o5
40010568: 10 80 00 03 b 40010574 <_Heap_Get_free_information+0x2c>
4001056c: 86 10 20 00 clr %g3
40010570: da 02 60 04 ld [ %o1 + 4 ], %o5
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40010574: c2 00 a0 04 ld [ %g2 + 4 ], %g1
40010578: 82 08 7f fe and %g1, -2, %g1
uint32_t const the_size = _Heap_Block_size(the_block);
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
4001057c: c8 22 40 00 st %g4, [ %o1 ]
info->total += the_size;
40010580: 86 00 c0 01 add %g3, %g1, %g3
if ( info->largest < the_size )
40010584: 80 a0 40 0d cmp %g1, %o5
40010588: 08 80 00 03 bleu 40010594 <_Heap_Get_free_information+0x4c>
4001058c: c6 22 60 08 st %g3, [ %o1 + 8 ]
info->largest = the_size;
40010590: c2 22 60 04 st %g1, [ %o1 + 4 ]
the_block = the_block->next)
40010594: c4 00 a0 08 ld [ %g2 + 8 ], %g2
for(the_block = _Heap_Free_list_first(the_heap);
40010598: 80 a2 00 02 cmp %o0, %g2
4001059c: 12 bf ff f5 bne 40010570 <_Heap_Get_free_information+0x28>
400105a0: 88 01 20 01 inc %g4
}
}
400105a4: 81 c3 e0 08 retl
400105a8: 01 00 00 00 nop
40009148 <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
40009148: 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) {
4000914c: 80 a6 a0 00 cmp %i2, 0
40009150: 02 80 00 3a be 40009238 <_Heap_Greedy_allocate+0xf0>
40009154: ba 10 00 18 mov %i0, %i5
40009158: b5 2e a0 02 sll %i2, 2, %i2
Heap_Block *allocated_blocks = NULL;
4000915c: b8 10 20 00 clr %i4
40009160: b4 06 40 1a add %i1, %i2, %i2
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
40009164: d2 06 40 00 ld [ %i1 ], %o1
40009168: 96 10 20 00 clr %o3
4000916c: 94 10 20 00 clr %o2
40009170: 7f ff fd e4 call 40008900 <_Heap_Allocate_aligned_with_boundary>
40009174: 90 10 00 1d mov %i5, %o0
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
40009178: 80 a2 20 00 cmp %o0, 0
4000917c: 02 80 00 0c be 400091ac <_Heap_Greedy_allocate+0x64>
40009180: b2 06 60 04 add %i1, 4, %i1
return value - (value % alignment);
40009184: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
40009188: 81 80 20 00 wr %g0, %y
4000918c: 01 00 00 00 nop
40009190: 01 00 00 00 nop
40009194: 01 00 00 00 nop
40009198: 82 72 00 02 udiv %o0, %g2, %g1
4000919c: 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;
400091a0: f8 20 40 00 st %i4, [ %g1 ]
- HEAP_BLOCK_HEADER_SIZE);
400091a4: 82 00 7f f8 add %g1, -8, %g1
400091a8: b8 10 00 01 mov %g1, %i4
for (i = 0; i < block_count; ++i) {
400091ac: 80 a6 80 19 cmp %i2, %i1
400091b0: 32 bf ff ee bne,a 40009168 <_Heap_Greedy_allocate+0x20>
400091b4: d2 06 40 00 ld [ %i1 ], %o1
return _Heap_Free_list_head(heap)->next;
400091b8: f0 07 60 08 ld [ %i5 + 8 ], %i0
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
400091bc: 80 a7 40 18 cmp %i5, %i0
400091c0: 22 80 00 19 be,a 40009224 <_Heap_Greedy_allocate+0xdc>
400091c4: b0 10 20 00 clr %i0
Heap_Block *allocated_blocks = NULL;
400091c8: 10 80 00 03 b 400091d4 <_Heap_Greedy_allocate+0x8c>
400091cc: b6 10 20 00 clr %i3
400091d0: b0 10 00 01 mov %g1, %i0
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
400091d4: d6 06 20 04 ld [ %i0 + 4 ], %o3
400091d8: 96 0a ff fe and %o3, -2, %o3
_Heap_Block_allocate(
400091dc: 94 06 20 08 add %i0, 8, %o2
400091e0: 92 10 00 18 mov %i0, %o1
400091e4: 96 02 ff f8 add %o3, -8, %o3
400091e8: 7f ff fd 76 call 400087c0 <_Heap_Block_allocate>
400091ec: 90 10 00 1d mov %i5, %o0
current,
_Heap_Alloc_area_of_block( current ),
_Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE
);
current->next = blocks;
400091f0: f6 26 20 08 st %i3, [ %i0 + 8 ]
return _Heap_Free_list_head(heap)->next;
400091f4: c2 07 60 08 ld [ %i5 + 8 ], %g1
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
400091f8: 80 a7 40 01 cmp %i5, %g1
400091fc: 12 bf ff f5 bne 400091d0 <_Heap_Greedy_allocate+0x88>
40009200: b6 10 00 18 mov %i0, %i3
blocks = current;
}
while ( allocated_blocks != NULL ) {
40009204: 80 a7 20 00 cmp %i4, 0
40009208: 02 80 00 0a be 40009230 <_Heap_Greedy_allocate+0xe8>
4000920c: 01 00 00 00 nop
current = allocated_blocks;
allocated_blocks = allocated_blocks->next;
40009210: f6 07 20 08 ld [ %i4 + 8 ], %i3
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
40009214: 92 07 20 08 add %i4, 8, %o1
40009218: 90 10 00 1d mov %i5, %o0
4000921c: 7f ff ff 16 call 40008e74 <_Heap_Free>
40009220: b8 10 00 1b mov %i3, %i4
while ( allocated_blocks != NULL ) {
40009224: 80 a7 20 00 cmp %i4, 0
40009228: 32 bf ff fb bne,a 40009214 <_Heap_Greedy_allocate+0xcc>
4000922c: f6 07 20 08 ld [ %i4 + 8 ], %i3
}
return blocks;
}
40009230: 81 c7 e0 08 ret
40009234: 81 e8 00 00 restore
40009238: f0 06 20 08 ld [ %i0 + 8 ], %i0
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
4000923c: 80 a7 40 18 cmp %i5, %i0
40009240: 12 bf ff e2 bne 400091c8 <_Heap_Greedy_allocate+0x80>
<== ALWAYS TAKEN
40009244: b8 10 20 00 clr %i4
Heap_Block *blocks = NULL;
40009248: 81 c7 e0 08 ret
<== NOT EXECUTED
4000924c: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
400069e0 <_Heap_Greedy_allocate_all_except_largest>:
Heap_Block *_Heap_Greedy_allocate_all_except_largest(
Heap_Control *heap,
uintptr_t *allocatable_size
)
{
400069e0: 9d e3 bf 90 save %sp, -112, %sp
Heap_Information info;
_Heap_Get_free_information( heap, &info );
400069e4: 92 07 bf f4 add %fp, -12, %o1
400069e8: 40 00 14 5f call 4000bb64 <_Heap_Get_free_information>
400069ec: 90 10 00 18 mov %i0, %o0
if ( info.largest > 0 ) {
400069f0: c2 07 bf f8 ld [ %fp + -8 ], %g1
400069f4: 80 a0 60 00 cmp %g1, 0
400069f8: 12 80 00 08 bne 40006a18 <_Heap_Greedy_allocate_all_except_largest+0x38>
<== ALWAYS TAKEN
400069fc: 94 10 20 01 mov 1, %o2
*allocatable_size = info.largest - HEAP_BLOCK_HEADER_SIZE + HEAP_ALLOC_BONUS;
} else {
*allocatable_size = 0;
40006a00: c0 26 40 00 clr [ %i1 ]
<== NOT EXECUTED
}
return _Heap_Greedy_allocate( heap, allocatable_size, 1 );
40006a04: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40006a08: 7f ff ff b4 call 400068d8 <_Heap_Greedy_allocate>
<== NOT EXECUTED
40006a0c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
40006a10: 81 c7 e0 08 ret
<== NOT EXECUTED
40006a14: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
*allocatable_size = info.largest - HEAP_BLOCK_HEADER_SIZE + HEAP_ALLOC_BONUS;
40006a18: 82 00 7f fc add %g1, -4, %g1
40006a1c: c2 26 40 00 st %g1, [ %i1 ]
return _Heap_Greedy_allocate( heap, allocatable_size, 1 );
40006a20: 92 10 00 19 mov %i1, %o1
40006a24: 7f ff ff ad call 400068d8 <_Heap_Greedy_allocate>
40006a28: 90 10 00 18 mov %i0, %o0
}
40006a2c: 81 c7 e0 08 ret
40006a30: 91 e8 00 08 restore %g0, %o0, %o0
40006a10 <_Heap_Initialize>:
{
40006a10: 9d e3 bf a0 save %sp, -96, %sp
40006a14: a2 86 40 1a addcc %i1, %i2, %l1
40006a18: 84 40 20 00 addx %g0, 0, %g2
if ( page_size == 0 ) {
40006a1c: 80 a6 e0 00 cmp %i3, 0
40006a20: 22 80 00 33 be,a 40006aec <_Heap_Initialize+0xdc>
40006a24: b6 10 20 08 mov 8, %i3
40006a28: 82 8e e0 07 andcc %i3, 7, %g1
40006a2c: 02 80 00 05 be 40006a40 <_Heap_Initialize+0x30>
40006a30: 80 a6 e0 07 cmp %i3, 7
return value - remainder + alignment;
40006a34: b6 06 e0 08 add %i3, 8, %i3
40006a38: b6 26 c0 01 sub %i3, %g1, %i3
if ( page_size < CPU_ALIGNMENT ) {
40006a3c: 80 a6 e0 07 cmp %i3, 7
40006a40: 08 80 00 29 bleu 40006ae4 <_Heap_Initialize+0xd4>
40006a44: ba 10 20 00 clr %i5
uintptr_t remainder = value % alignment;
40006a48: 82 10 20 10 mov 0x10, %g1
40006a4c: 81 80 20 00 wr %g0, %y
40006a50: 01 00 00 00 nop
40006a54: 01 00 00 00 nop
40006a58: 01 00 00 00 nop
40006a5c: 86 70 40 1b udiv %g1, %i3, %g3
40006a60: 86 58 c0 1b smul %g3, %i3, %g3
if ( remainder != 0 ) {
40006a64: 82 a0 40 03 subcc %g1, %g3, %g1
40006a68: 02 80 00 22 be 40006af0 <_Heap_Initialize+0xe0>
40006a6c: a0 10 20 10 mov 0x10, %l0
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
40006a70: b8 06 60 08 add %i1, 8, %i4
return value - remainder + alignment;
40006a74: a0 06 e0 10 add %i3, 0x10, %l0
40006a78: a0 24 00 01 sub %l0, %g1, %l0
uintptr_t remainder = value % alignment;
40006a7c: 81 80 20 00 wr %g0, %y
40006a80: 01 00 00 00 nop
40006a84: 01 00 00 00 nop
40006a88: 01 00 00 00 nop
40006a8c: 82 77 00 1b udiv %i4, %i3, %g1
40006a90: 82 58 40 1b smul %g1, %i3, %g1
if ( remainder != 0 ) {
40006a94: 82 a7 00 01 subcc %i4, %g1, %g1
40006a98: 12 80 00 21 bne 40006b1c <_Heap_Initialize+0x10c>
<== ALWAYS TAKEN
40006a9c: b8 06 40 1b add %i1, %i3, %i4
uintptr_t const heap_area_begin = (uintptr_t) heap_area_begin_ptr;
40006aa0: b8 10 00 19 mov %i1, %i4
<== NOT EXECUTED
40006aa4: 82 10 20 08 mov 8, %g1
|| heap_area_size <= overhead
40006aa8: 80 a0 40 1a cmp %g1, %i2
_Heap_Align_down( heap_area_size - overhead, page_size );
40006aac: b4 26 80 01 sub %i2, %g1, %i2
|| heap_area_size <= overhead
40006ab0: 82 60 3f ff subx %g0, -1, %g1
return value - (value % alignment);
40006ab4: 81 80 20 00 wr %g0, %y
40006ab8: 01 00 00 00 nop
40006abc: 01 00 00 00 nop
40006ac0: 01 00 00 00 nop
40006ac4: ba 76 80 1b udiv %i2, %i3, %i5
|| first_block_size < min_block_size
40006ac8: 80 90 80 01 orcc %g2, %g1, %g0
40006acc: 12 80 00 05 bne 40006ae0 <_Heap_Initialize+0xd0>
40006ad0: ba 5f 40 1b smul %i5, %i3, %i5
40006ad4: 80 a7 40 10 cmp %i5, %l0
40006ad8: 1a 80 00 15 bcc 40006b2c <_Heap_Initialize+0x11c>
40006adc: 94 10 20 68 mov 0x68, %o2
return 0;
40006ae0: ba 10 20 00 clr %i5
}
40006ae4: 81 c7 e0 08 ret
40006ae8: 91 e8 00 1d restore %g0, %i5, %o0
} else {
return value;
40006aec: a0 10 20 10 mov 0x10, %l0
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
40006af0: b8 06 60 08 add %i1, 8, %i4
uintptr_t remainder = value % alignment;
40006af4: 81 80 20 00 wr %g0, %y
40006af8: 01 00 00 00 nop
40006afc: 01 00 00 00 nop
40006b00: 01 00 00 00 nop
40006b04: 82 77 00 1b udiv %i4, %i3, %g1
40006b08: 82 58 40 1b smul %g1, %i3, %g1
if ( remainder != 0 ) {
40006b0c: 82 a7 00 01 subcc %i4, %g1, %g1
40006b10: 22 bf ff e5 be,a 40006aa4 <_Heap_Initialize+0x94>
40006b14: b8 10 00 19 mov %i1, %i4
40006b18: b8 06 40 1b add %i1, %i3, %i4
40006b1c: b8 27 00 01 sub %i4, %g1, %i4
40006b20: 82 27 00 19 sub %i4, %i1, %g1
40006b24: 10 bf ff e1 b 40006aa8 <_Heap_Initialize+0x98>
40006b28: 82 00 60 08 add %g1, 8, %g1
memset(heap, 0, sizeof(*heap));
40006b2c: 92 10 20 00 clr %o1
40006b30: 40 00 23 1b call 4000f79c <memset>
40006b34: 90 10 00 18 mov %i0, %o0
first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED;
40006b38: 82 17 60 01 or %i5, 1, %g1
first_block->next = _Heap_Free_list_tail( heap );
40006b3c: f0 27 20 08 st %i0, [ %i4 + 8 ]
return (Heap_Block *) ((uintptr_t) block + offset);
40006b40: 86 07 40 1c add %i5, %i4, %g3
first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED;
40006b44: c2 27 20 04 st %g1, [ %i4 + 4 ]
_Heap_Block_set_size(
40006b48: 82 20 00 1d neg %i5, %g1
first_block->prev = _Heap_Free_list_head( heap );
40006b4c: f0 27 20 0c st %i0, [ %i4 + 0xc ]
stats->free_blocks = 1;
40006b50: 84 10 20 01 mov 1, %g2
first_block->prev_size = heap_area_end;
40006b54: e2 27 00 00 st %l1, [ %i4 ]
heap->page_size = page_size;
40006b58: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
heap->min_block_size = min_block_size;
40006b5c: e0 26 20 14 st %l0, [ %i0 + 0x14 ]
heap->area_begin = heap_area_begin;
40006b60: f2 26 20 18 st %i1, [ %i0 + 0x18 ]
heap->area_end = heap_area_end;
40006b64: e2 26 20 1c st %l1, [ %i0 + 0x1c ]
heap->first_block = first_block;
40006b68: f8 26 20 20 st %i4, [ %i0 + 0x20 ]
heap->last_block = last_block;
40006b6c: c6 26 20 24 st %g3, [ %i0 + 0x24 ]
_Heap_Free_list_head( heap )->next = first_block;
40006b70: f8 26 20 08 st %i4, [ %i0 + 8 ]
_Heap_Free_list_tail( heap )->prev = first_block;
40006b74: f8 26 20 0c st %i4, [ %i0 + 0xc ]
last_block->prev_size = first_block_size;
40006b78: fa 27 40 1c st %i5, [ %i5 + %i4 ]
block->size_and_flag = size | flag;
40006b7c: c2 20 e0 04 st %g1, [ %g3 + 4 ]
stats->size = first_block_size;
40006b80: fa 26 20 38 st %i5, [ %i0 + 0x38 ]
stats->free_size = first_block_size;
40006b84: fa 26 20 3c st %i5, [ %i0 + 0x3c ]
stats->min_free_size = first_block_size;
40006b88: fa 26 20 40 st %i5, [ %i0 + 0x40 ]
stats->free_blocks = 1;
40006b8c: c4 26 20 44 st %g2, [ %i0 + 0x44 ]
stats->max_free_blocks = 1;
40006b90: c4 26 20 48 st %g2, [ %i0 + 0x48 ]
}
40006b94: 81 c7 e0 08 ret
40006b98: 91 e8 00 1d restore %g0, %i5, %o0
40009ac4 <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
40009ac4: 9d e3 bf a0 save %sp, -96, %sp
Heap_Block *current = heap->first_block;
40009ac8: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
Heap_Block *end = heap->last_block;
40009acc: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
bool stop = false;
while ( !stop && current != end ) {
40009ad0: 80 a0 40 1c cmp %g1, %i4
40009ad4: 32 80 00 07 bne,a 40009af0 <_Heap_Iterate+0x2c>
<== ALWAYS TAKEN
40009ad8: d2 00 60 04 ld [ %g1 + 4 ], %o1
40009adc: 30 80 00 10 b,a 40009b1c <_Heap_Iterate+0x58>
<== NOT EXECUTED
40009ae0: 80 a7 00 1d cmp %i4, %i5
40009ae4: 02 80 00 0e be 40009b1c <_Heap_Iterate+0x58>
40009ae8: 01 00 00 00 nop
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40009aec: d2 00 60 04 ld [ %g1 + 4 ], %o1
40009af0: 92 0a 7f fe and %o1, -2, %o1
return (Heap_Block *) ((uintptr_t) block + offset);
40009af4: ba 00 40 09 add %g1, %o1, %i5
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40009af8: 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 );
40009afc: 90 10 00 01 mov %g1, %o0
40009b00: 96 10 00 1a mov %i2, %o3
40009b04: 9f c6 40 00 call %i1
40009b08: 94 0a a0 01 and %o2, 1, %o2
while ( !stop && current != end ) {
40009b0c: 90 1a 20 01 xor %o0, 1, %o0
40009b10: 80 8a 20 ff btst 0xff, %o0
40009b14: 12 bf ff f3 bne 40009ae0 <_Heap_Iterate+0x1c>
<== ALWAYS TAKEN
40009b18: 82 10 00 1d mov %i5, %g1
current = next;
}
}
40009b1c: 81 c7 e0 08 ret
40009b20: 81 e8 00 00 restore
40007d1c <_Heap_Size_of_alloc_area>:
return value - (value % alignment);
40007d1c: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
return (uintptr_t) block >= (uintptr_t) heap->first_block
40007d20: c8 02 20 20 ld [ %o0 + 0x20 ], %g4
return value - (value % alignment);
40007d24: 81 80 20 00 wr %g0, %y
40007d28: 01 00 00 00 nop
40007d2c: 01 00 00 00 nop
40007d30: 01 00 00 00 nop
40007d34: 82 72 40 02 udiv %o1, %g2, %g1
40007d38: 82 58 40 02 smul %g1, %g2, %g1
- HEAP_BLOCK_HEADER_SIZE);
40007d3c: 82 00 7f f8 add %g1, -8, %g1
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40007d40: 80 a1 00 01 cmp %g4, %g1
40007d44: 18 80 00 15 bgu 40007d98 <_Heap_Size_of_alloc_area+0x7c>
<== NEVER TAKEN
40007d48: 86 10 20 00 clr %g3
40007d4c: da 02 20 24 ld [ %o0 + 0x24 ], %o5
40007d50: 80 a3 40 01 cmp %o5, %g1
40007d54: 0a 80 00 11 bcs 40007d98 <_Heap_Size_of_alloc_area+0x7c>
<== NEVER TAKEN
40007d58: 01 00 00 00 nop
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40007d5c: c4 00 60 04 ld [ %g1 + 4 ], %g2
40007d60: 84 08 bf fe and %g2, -2, %g2
return (Heap_Block *) ((uintptr_t) block + offset);
40007d64: 82 00 80 01 add %g2, %g1, %g1
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40007d68: 80 a1 00 01 cmp %g4, %g1
40007d6c: 18 80 00 0b bgu 40007d98 <_Heap_Size_of_alloc_area+0x7c>
<== NEVER TAKEN
40007d70: 80 a3 40 01 cmp %o5, %g1
40007d74: 0a 80 00 09 bcs 40007d98 <_Heap_Size_of_alloc_area+0x7c>
<== NEVER TAKEN
40007d78: 01 00 00 00 nop
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40007d7c: c4 00 60 04 ld [ %g1 + 4 ], %g2
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
40007d80: 80 88 a0 01 btst 1, %g2
40007d84: 02 80 00 05 be 40007d98 <_Heap_Size_of_alloc_area+0x7c>
<== NEVER TAKEN
40007d88: 82 20 40 09 sub %g1, %o1, %g1
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
40007d8c: 82 00 60 04 add %g1, 4, %g1
40007d90: c2 22 80 00 st %g1, [ %o2 ]
return true;
40007d94: 86 10 20 01 mov 1, %g3
}
40007d98: 81 c3 e0 08 retl
40007d9c: 90 08 e0 ff and %g3, 0xff, %o0
400070f4 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
400070f4: 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;
400070f8: 80 a6 a0 00 cmp %i2, 0
400070fc: 02 80 00 0b be 40007128 <_Heap_Walk+0x34>
40007100: 03 10 00 5e sethi %hi(0x40017800), %g1
if ( !_System_state_Is_up( _System_state_Get() ) ) {
40007104: c2 00 60 24 ld [ %g1 + 0x24 ], %g1 ! 40017824 <_System_state_Current>
_Heap_Walk_print : _Heap_Walk_print_nothing;
40007108: 21 10 00 1c sethi %hi(0x40007000), %l0
if ( !_System_state_Is_up( _System_state_Get() ) ) {
4000710c: 80 a0 60 02 cmp %g1, 2
40007110: 02 80 00 0b be 4000713c <_Heap_Walk+0x48>
<== ALWAYS TAKEN
40007114: a0 14 20 90 or %l0, 0x90, %l0
return true;
40007118: b4 10 20 01 mov 1, %i2
4000711c: b0 0e a0 ff and %i2, 0xff, %i0
block = next_block;
} while ( block != first_block );
return true;
}
40007120: 81 c7 e0 08 ret
40007124: 81 e8 00 00 restore
if ( !_System_state_Is_up( _System_state_Get() ) ) {
40007128: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
_Heap_Walk_print : _Heap_Walk_print_nothing;
4000712c: 21 10 00 1c sethi %hi(0x40007000), %l0
if ( !_System_state_Is_up( _System_state_Get() ) ) {
40007130: 80 a0 60 02 cmp %g1, 2
40007134: 12 bf ff f9 bne 40007118 <_Heap_Walk+0x24>
40007138: a0 14 20 88 or %l0, 0x88, %l0
Heap_Block *const first_block = heap->first_block;
4000713c: e4 06 20 20 ld [ %i0 + 0x20 ], %l2
Heap_Block *const last_block = heap->last_block;
40007140: e2 06 20 24 ld [ %i0 + 0x24 ], %l1
(*printer)(
40007144: c6 06 20 0c ld [ %i0 + 0xc ], %g3
40007148: c4 06 20 08 ld [ %i0 + 8 ], %g2
4000714c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
40007150: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40007154: 15 10 00 42 sethi %hi(0x40010800), %o2
40007158: c6 23 a0 6c st %g3, [ %sp + 0x6c ]
4000715c: 94 12 a0 60 or %o2, 0x60, %o2
40007160: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
40007164: 92 10 20 00 clr %o1
40007168: e2 23 a0 64 st %l1, [ %sp + 0x64 ]
4000716c: 90 10 00 19 mov %i1, %o0
40007170: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
uintptr_t const page_size = heap->page_size;
40007174: ec 06 20 10 ld [ %i0 + 0x10 ], %l6
uintptr_t const min_block_size = heap->min_block_size;
40007178: e6 06 20 14 ld [ %i0 + 0x14 ], %l3
(*printer)(
4000717c: da 06 20 18 ld [ %i0 + 0x18 ], %o5
40007180: 98 10 00 13 mov %l3, %o4
40007184: 9f c4 00 00 call %l0
40007188: 96 10 00 16 mov %l6, %o3
if ( page_size == 0 ) {
4000718c: 80 a5 a0 00 cmp %l6, 0
40007190: 12 80 00 0a bne 400071b8 <_Heap_Walk+0xc4>
40007194: 92 10 20 01 mov 1, %o1
(*printer)( source, true, "page size is zero\n" );
40007198: 90 10 00 19 mov %i1, %o0
return false;
4000719c: b4 10 20 00 clr %i2
(*printer)( source, true, "page size is zero\n" );
400071a0: 15 10 00 42 sethi %hi(0x40010800), %o2
400071a4: b0 0e a0 ff and %i2, 0xff, %i0
400071a8: 9f c4 00 00 call %l0
400071ac: 94 12 a0 f8 or %o2, 0xf8, %o2
}
400071b0: 81 c7 e0 08 ret
400071b4: 81 e8 00 00 restore
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
400071b8: 80 8d a0 07 btst 7, %l6
400071bc: 02 80 00 0b be 400071e8 <_Heap_Walk+0xf4>
400071c0: 96 10 00 16 mov %l6, %o3
(*printer)(
400071c4: 92 10 20 01 mov 1, %o1
400071c8: 15 10 00 42 sethi %hi(0x40010800), %o2
400071cc: 90 10 00 19 mov %i1, %o0
400071d0: 94 12 a1 10 or %o2, 0x110, %o2
400071d4: 9f c4 00 00 call %l0
400071d8: b4 10 20 00 clr %i2
400071dc: b0 0e a0 ff and %i2, 0xff, %i0
400071e0: 81 c7 e0 08 ret
400071e4: 81 e8 00 00 restore
return (value % alignment) == 0;
400071e8: 81 80 20 00 wr %g0, %y
400071ec: 01 00 00 00 nop
400071f0: 01 00 00 00 nop
400071f4: 01 00 00 00 nop
400071f8: 82 74 c0 16 udiv %l3, %l6, %g1
400071fc: 82 58 40 16 smul %g1, %l6, %g1
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
40007200: 80 a4 c0 01 cmp %l3, %g1
40007204: 02 80 00 0b be 40007230 <_Heap_Walk+0x13c>
40007208: 96 10 00 13 mov %l3, %o3
(*printer)(
4000720c: 92 10 20 01 mov 1, %o1
40007210: 15 10 00 42 sethi %hi(0x40010800), %o2
40007214: 90 10 00 19 mov %i1, %o0
40007218: 94 12 a1 30 or %o2, 0x130, %o2
4000721c: 9f c4 00 00 call %l0
40007220: b4 10 20 00 clr %i2
40007224: b0 0e a0 ff and %i2, 0xff, %i0
40007228: 81 c7 e0 08 ret
4000722c: 81 e8 00 00 restore
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
40007230: 86 04 a0 08 add %l2, 8, %g3
return (value % alignment) == 0;
40007234: 81 80 20 00 wr %g0, %y
40007238: 01 00 00 00 nop
4000723c: 01 00 00 00 nop
40007240: 01 00 00 00 nop
40007244: 82 70 c0 16 udiv %g3, %l6, %g1
40007248: 82 58 40 16 smul %g1, %l6, %g1
if (
4000724c: 80 a0 c0 01 cmp %g3, %g1
40007250: 02 80 00 0b be 4000727c <_Heap_Walk+0x188>
40007254: 96 10 00 12 mov %l2, %o3
(*printer)(
40007258: 92 10 20 01 mov 1, %o1
4000725c: 15 10 00 42 sethi %hi(0x40010800), %o2
40007260: 90 10 00 19 mov %i1, %o0
40007264: 94 12 a1 58 or %o2, 0x158, %o2
40007268: 9f c4 00 00 call %l0
4000726c: b4 10 20 00 clr %i2
40007270: b0 0e a0 ff and %i2, 0xff, %i0
40007274: 81 c7 e0 08 ret
40007278: 81 e8 00 00 restore
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000727c: c2 04 a0 04 ld [ %l2 + 4 ], %g1
if ( !_Heap_Is_prev_used( first_block ) ) {
40007280: 80 88 60 01 btst 1, %g1
40007284: 12 80 00 0a bne 400072ac <_Heap_Walk+0x1b8>
40007288: 92 10 20 01 mov 1, %o1
(*printer)(
4000728c: 15 10 00 42 sethi %hi(0x40010800), %o2
40007290: 90 10 00 19 mov %i1, %o0
40007294: 94 12 a1 90 or %o2, 0x190, %o2
40007298: 9f c4 00 00 call %l0
4000729c: b4 10 20 00 clr %i2
400072a0: b0 0e a0 ff and %i2, 0xff, %i0
400072a4: 81 c7 e0 08 ret
400072a8: 81 e8 00 00 restore
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
400072ac: c2 04 60 04 ld [ %l1 + 4 ], %g1
400072b0: 82 08 7f fe and %g1, -2, %g1
return (Heap_Block *) ((uintptr_t) block + offset);
400072b4: 82 04 40 01 add %l1, %g1, %g1
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
400072b8: c6 00 60 04 ld [ %g1 + 4 ], %g3
if ( _Heap_Is_free( last_block ) ) {
400072bc: 80 88 e0 01 btst 1, %g3
400072c0: 12 80 00 09 bne 400072e4 <_Heap_Walk+0x1f0>
400072c4: 15 10 00 42 sethi %hi(0x40010800), %o2
(*printer)(
400072c8: 90 10 00 19 mov %i1, %o0
400072cc: 94 12 a1 c0 or %o2, 0x1c0, %o2
400072d0: 9f c4 00 00 call %l0
400072d4: b4 10 20 00 clr %i2
400072d8: b0 0e a0 ff and %i2, 0xff, %i0
400072dc: 81 c7 e0 08 ret
400072e0: 81 e8 00 00 restore
if (
400072e4: 80 a4 80 01 cmp %l2, %g1
400072e8: 02 80 00 0a be 40007310 <_Heap_Walk+0x21c>
400072ec: 92 10 20 01 mov 1, %o1
(*printer)(
400072f0: 15 10 00 42 sethi %hi(0x40010800), %o2
400072f4: 90 10 00 19 mov %i1, %o0
400072f8: 94 12 a1 d8 or %o2, 0x1d8, %o2
400072fc: 9f c4 00 00 call %l0
40007300: b4 10 20 00 clr %i2
40007304: b0 0e a0 ff and %i2, 0xff, %i0
40007308: 81 c7 e0 08 ret
4000730c: 81 e8 00 00 restore
uintptr_t const page_size = heap->page_size;
40007310: fa 06 20 10 ld [ %i0 + 0x10 ], %i5
return _Heap_Free_list_head(heap)->next;
40007314: e8 06 20 08 ld [ %i0 + 8 ], %l4
40007318: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
const Heap_Block *prev_block = free_list_tail;
4000731c: 88 10 00 18 mov %i0, %g4
while ( free_block != free_list_tail ) {
40007320: 80 a6 00 14 cmp %i0, %l4
40007324: 02 80 00 1f be 400073a0 <_Heap_Walk+0x2ac>
40007328: 80 a5 00 03 cmp %l4, %g3
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000732c: 0a 80 00 f9 bcs 40007710 <_Heap_Walk+0x61c>
40007330: 96 10 00 14 mov %l4, %o3
40007334: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40007338: 80 a0 40 14 cmp %g1, %l4
4000733c: 0a 80 00 f6 bcs 40007714 <_Heap_Walk+0x620>
<== NEVER TAKEN
40007340: 92 10 20 01 mov 1, %o1
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
40007344: b8 05 20 08 add %l4, 8, %i4
return (value % alignment) == 0;
40007348: 81 80 20 00 wr %g0, %y
4000734c: 01 00 00 00 nop
40007350: 01 00 00 00 nop
40007354: 01 00 00 00 nop
40007358: 82 77 00 1d udiv %i4, %i5, %g1
4000735c: 82 58 40 1d smul %g1, %i5, %g1
if (
40007360: 80 a7 00 01 cmp %i4, %g1
40007364: 12 80 00 e4 bne 400076f4 <_Heap_Walk+0x600>
40007368: 15 10 00 42 sethi %hi(0x40010800), %o2
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000736c: c2 05 20 04 ld [ %l4 + 4 ], %g1
40007370: 82 08 7f fe and %g1, -2, %g1
return _Heap_Is_prev_used( next_block );
40007374: 82 05 00 01 add %l4, %g1, %g1
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40007378: c2 00 60 04 ld [ %g1 + 4 ], %g1
if ( _Heap_Is_used( free_block ) ) {
4000737c: 80 88 60 01 btst 1, %g1
40007380: 12 80 00 d6 bne 400076d8 <_Heap_Walk+0x5e4>
40007384: 15 10 00 42 sethi %hi(0x40010800), %o2
if ( free_block->prev != prev_block ) {
40007388: d8 05 20 0c ld [ %l4 + 0xc ], %o4
4000738c: 80 a3 00 04 cmp %o4, %g4
40007390: 12 80 00 c9 bne 400076b4 <_Heap_Walk+0x5c0>
40007394: 88 10 00 14 mov %l4, %g4
free_block = free_block->next;
40007398: 10 bf ff e2 b 40007320 <_Heap_Walk+0x22c>
4000739c: e8 05 20 08 ld [ %l4 + 8 ], %l4
(*printer)(
400073a0: 2f 10 00 42 sethi %hi(0x40010800), %l7
400073a4: 82 15 e0 40 or %l7, 0x40, %g1 ! 40010840 <IMFS_node_control_sym_link+0x60>
400073a8: c2 27 bf fc st %g1, [ %fp + -4 ]
: (block->next == free_list_tail ? " (= tail)" : "")
400073ac: 03 10 00 42 sethi %hi(0x40010800), %g1
400073b0: 82 10 60 50 or %g1, 0x50, %g1 ! 40010850 <IMFS_node_control_sym_link+0x70>
400073b4: c2 27 bf f4 st %g1, [ %fp + -12 ]
(*printer)(
400073b8: 03 10 00 42 sethi %hi(0x40010800), %g1
400073bc: 82 10 60 20 or %g1, 0x20, %g1 ! 40010820 <IMFS_node_control_sym_link+0x40>
400073c0: c2 27 bf f8 st %g1, [ %fp + -8 ]
: (block->prev == free_list_head ? " (= head)" : ""),
400073c4: 03 10 00 42 sethi %hi(0x40010800), %g1
400073c8: 82 10 60 30 or %g1, 0x30, %g1 ! 40010830 <IMFS_node_control_sym_link+0x50>
400073cc: c2 27 bf f0 st %g1, [ %fp + -16 ]
: (block->next == free_list_tail ? " (= tail)" : "")
400073d0: 2b 10 00 42 sethi %hi(0x40010800), %l5
while ( free_block != free_list_tail ) {
400073d4: ba 10 00 12 mov %l2, %i5
: (block->next == free_list_tail ? " (= tail)" : "")
400073d8: aa 15 63 98 or %l5, 0x398, %l5
uintptr_t const block_size = _Heap_Block_size( block );
400073dc: c2 07 60 04 ld [ %i5 + 4 ], %g1
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
400073e0: b6 08 7f fe and %g1, -2, %i3
return (Heap_Block *) ((uintptr_t) block + offset);
400073e4: b8 07 40 1b add %i5, %i3, %i4
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
400073e8: 80 a0 c0 1c cmp %g3, %i4
400073ec: 18 80 00 06 bgu 40007404 <_Heap_Walk+0x310>
<== NEVER TAKEN
400073f0: ae 08 60 01 and %g1, 1, %l7
400073f4: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
400073f8: 80 a0 c0 1c cmp %g3, %i4
400073fc: 1a 80 00 0d bcc 40007430 <_Heap_Walk+0x33c>
40007400: 01 00 00 00 nop
(*printer)(
40007404: 98 10 00 1c mov %i4, %o4
40007408: 96 10 00 1d mov %i5, %o3
4000740c: 92 10 20 01 mov 1, %o1
40007410: 90 10 00 19 mov %i1, %o0
return false;
40007414: b4 10 20 00 clr %i2
(*printer)(
40007418: 15 10 00 43 sethi %hi(0x40010c00), %o2
4000741c: b0 0e a0 ff and %i2, 0xff, %i0
40007420: 9f c4 00 00 call %l0
40007424: 94 12 a0 30 or %o2, 0x30, %o2
}
40007428: 81 c7 e0 08 ret
4000742c: 81 e8 00 00 restore
return (value % alignment) == 0;
40007430: 81 80 20 00 wr %g0, %y
40007434: 01 00 00 00 nop
40007438: 01 00 00 00 nop
4000743c: 01 00 00 00 nop
40007440: 86 76 c0 16 udiv %i3, %l6, %g3
40007444: 86 58 c0 16 smul %g3, %l6, %g3
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
40007448: 80 a6 c0 03 cmp %i3, %g3
4000744c: 02 80 00 17 be 400074a8 <_Heap_Walk+0x3b4>
40007450: 86 1f 40 11 xor %i5, %l1, %g3
40007454: 80 a7 40 11 cmp %i5, %l1
40007458: 12 80 00 79 bne 4000763c <_Heap_Walk+0x548>
4000745c: 98 10 00 1b mov %i3, %o4
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40007460: c6 07 20 04 ld [ %i4 + 4 ], %g3
if ( !_Heap_Is_prev_used( next_block ) ) {
40007464: 80 88 e0 01 btst 1, %g3
40007468: 02 80 00 30 be 40007528 <_Heap_Walk+0x434>
4000746c: 80 a5 e0 00 cmp %l7, 0
} else if (prev_used) {
40007470: 22 80 00 25 be,a 40007504 <_Heap_Walk+0x410>
40007474: da 07 40 00 ld [ %i5 ], %o5
(*printer)(
40007478: 15 10 00 42 sethi %hi(0x40010800), %o2
4000747c: 98 10 00 1b mov %i3, %o4
40007480: 96 10 00 1d mov %i5, %o3
40007484: 94 12 a3 d0 or %o2, 0x3d0, %o2
40007488: 92 10 20 00 clr %o1
4000748c: 9f c4 00 00 call %l0
40007490: 90 10 00 19 mov %i1, %o0
} while ( block != first_block );
40007494: 80 a4 80 1c cmp %l2, %i4
40007498: 02 bf ff 20 be 40007118 <_Heap_Walk+0x24>
4000749c: ba 10 00 1c mov %i4, %i5
400074a0: 10 bf ff cf b 400073dc <_Heap_Walk+0x2e8>
400074a4: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
bool const is_not_last_block = block != last_block;
400074a8: 80 a0 00 03 cmp %g0, %g3
400074ac: 88 40 20 00 addx %g0, 0, %g4
if ( block_size < min_block_size && is_not_last_block ) {
400074b0: 80 a6 c0 13 cmp %i3, %l3
400074b4: 86 40 20 00 addx %g0, 0, %g3
400074b8: 86 09 00 03 and %g4, %g3, %g3
400074bc: 80 a0 e0 00 cmp %g3, 0
400074c0: 12 80 00 53 bne 4000760c <_Heap_Walk+0x518>
400074c4: b4 10 00 03 mov %g3, %i2
if ( next_block_begin <= block_begin && is_not_last_block ) {
400074c8: 80 a7 40 1c cmp %i5, %i4
400074cc: 0a bf ff e5 bcs 40007460 <_Heap_Walk+0x36c>
400074d0: 80 a1 20 00 cmp %g4, 0
400074d4: 22 bf ff e4 be,a 40007464 <_Heap_Walk+0x370>
400074d8: c6 07 20 04 ld [ %i4 + 4 ], %g3
(*printer)(
400074dc: 98 10 00 1c mov %i4, %o4
400074e0: 96 10 00 1d mov %i5, %o3
400074e4: 15 10 00 42 sethi %hi(0x40010800), %o2
400074e8: 92 10 20 01 mov 1, %o1
400074ec: 94 12 a2 f0 or %o2, 0x2f0, %o2
400074f0: 9f c4 00 00 call %l0
400074f4: 90 10 00 19 mov %i1, %o0
400074f8: b0 0e a0 ff and %i2, 0xff, %i0
400074fc: 81 c7 e0 08 ret
40007500: 81 e8 00 00 restore
(*printer)(
40007504: 98 10 00 1b mov %i3, %o4
40007508: 96 10 00 1d mov %i5, %o3
4000750c: 15 10 00 42 sethi %hi(0x40010800), %o2
40007510: 92 10 20 00 clr %o1
40007514: 94 12 a3 e8 or %o2, 0x3e8, %o2
40007518: 9f c4 00 00 call %l0
4000751c: 90 10 00 19 mov %i1, %o0
} while ( block != first_block );
40007520: 10 bf ff de b 40007498 <_Heap_Walk+0x3a4>
40007524: 80 a4 80 1c cmp %l2, %i4
(*printer)(
40007528: da 07 60 0c ld [ %i5 + 0xc ], %o5
4000752c: c6 06 20 08 ld [ %i0 + 8 ], %g3
return _Heap_Free_list_tail(heap)->prev;
40007530: de 06 20 0c ld [ %i0 + 0xc ], %o7
40007534: 80 a0 c0 0d cmp %g3, %o5
40007538: 02 80 00 05 be 4000754c <_Heap_Walk+0x458>
4000753c: c8 07 bf f8 ld [ %fp + -8 ], %g4
: (block->prev == free_list_head ? " (= head)" : ""),
40007540: 80 a5 00 0d cmp %l4, %o5
40007544: 02 80 00 22 be 400075cc <_Heap_Walk+0x4d8>
40007548: 88 10 00 15 mov %l5, %g4
(*printer)(
4000754c: c6 07 60 08 ld [ %i5 + 8 ], %g3
40007550: 80 a3 c0 03 cmp %o7, %g3
40007554: 02 80 00 05 be 40007568 <_Heap_Walk+0x474>
40007558: f4 07 bf fc ld [ %fp + -4 ], %i2
: (block->next == free_list_tail ? " (= tail)" : "")
4000755c: 80 a5 00 03 cmp %l4, %g3
40007560: 02 80 00 1d be 400075d4 <_Heap_Walk+0x4e0>
40007564: b4 10 00 15 mov %l5, %i2
(*printer)(
40007568: f4 23 a0 64 st %i2, [ %sp + 0x64 ]
4000756c: 98 10 00 1b mov %i3, %o4
40007570: c6 23 a0 60 st %g3, [ %sp + 0x60 ]
40007574: 96 10 00 1d mov %i5, %o3
40007578: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
4000757c: 92 10 20 00 clr %o1
40007580: 15 10 00 42 sethi %hi(0x40010800), %o2
40007584: 90 10 00 19 mov %i1, %o0
40007588: 9f c4 00 00 call %l0
4000758c: 94 12 a3 28 or %o2, 0x328, %o2
if ( block_size != next_block->prev_size ) {
40007590: da 07 00 00 ld [ %i4 ], %o5
40007594: 80 a6 c0 0d cmp %i3, %o5
40007598: 02 80 00 11 be 400075dc <_Heap_Walk+0x4e8>
4000759c: 98 10 00 1b mov %i3, %o4
(*printer)(
400075a0: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
400075a4: 96 10 00 1d mov %i5, %o3
400075a8: 92 10 20 01 mov 1, %o1
400075ac: 15 10 00 42 sethi %hi(0x40010800), %o2
400075b0: 90 10 00 19 mov %i1, %o0
400075b4: 94 12 a3 60 or %o2, 0x360, %o2
400075b8: 9f c4 00 00 call %l0
400075bc: b4 10 20 00 clr %i2
400075c0: b0 0e a0 ff and %i2, 0xff, %i0
400075c4: 81 c7 e0 08 ret
400075c8: 81 e8 00 00 restore
: (block->prev == free_list_head ? " (= head)" : ""),
400075cc: 10 bf ff e0 b 4000754c <_Heap_Walk+0x458>
400075d0: c8 07 bf f0 ld [ %fp + -16 ], %g4
: (block->next == free_list_tail ? " (= tail)" : "")
400075d4: 10 bf ff e5 b 40007568 <_Heap_Walk+0x474>
400075d8: f4 07 bf f4 ld [ %fp + -12 ], %i2
if ( !prev_used ) {
400075dc: 80 a5 e0 00 cmp %l7, 0
400075e0: 12 80 00 21 bne 40007664 <_Heap_Walk+0x570>
400075e4: 96 10 00 1d mov %i5, %o3
(*printer)(
400075e8: 92 10 20 01 mov 1, %o1
400075ec: 15 10 00 42 sethi %hi(0x40010800), %o2
400075f0: 90 10 00 19 mov %i1, %o0
400075f4: 94 12 a3 a0 or %o2, 0x3a0, %o2
400075f8: 9f c4 00 00 call %l0
400075fc: b4 10 20 00 clr %i2
40007600: b0 0e a0 ff and %i2, 0xff, %i0
40007604: 81 c7 e0 08 ret
40007608: 81 e8 00 00 restore
(*printer)(
4000760c: 9a 10 00 13 mov %l3, %o5
40007610: 98 10 00 1b mov %i3, %o4
40007614: 96 10 00 1d mov %i5, %o3
40007618: 92 10 20 01 mov 1, %o1
4000761c: 15 10 00 42 sethi %hi(0x40010800), %o2
40007620: 90 10 00 19 mov %i1, %o0
40007624: 94 12 a2 c0 or %o2, 0x2c0, %o2
40007628: 9f c4 00 00 call %l0
4000762c: b4 10 20 00 clr %i2
40007630: b0 0e a0 ff and %i2, 0xff, %i0
40007634: 81 c7 e0 08 ret
40007638: 81 e8 00 00 restore
(*printer)(
4000763c: 96 10 00 1d mov %i5, %o3
40007640: 92 10 20 01 mov 1, %o1
40007644: 15 10 00 42 sethi %hi(0x40010800), %o2
40007648: 90 10 00 19 mov %i1, %o0
4000764c: 94 12 a2 90 or %o2, 0x290, %o2
40007650: 9f c4 00 00 call %l0
40007654: b4 10 20 00 clr %i2
40007658: b0 0e a0 ff and %i2, 0xff, %i0
4000765c: 81 c7 e0 08 ret
40007660: 81 e8 00 00 restore
return _Heap_Free_list_head(heap)->next;
40007664: c2 06 20 08 ld [ %i0 + 8 ], %g1
while ( free_block != free_list_tail ) {
40007668: 80 a5 00 01 cmp %l4, %g1
4000766c: 02 80 00 09 be 40007690 <_Heap_Walk+0x59c>
<== NEVER TAKEN
40007670: 80 a7 40 01 cmp %i5, %g1
if ( free_block == block ) {
40007674: 02 bf ff 89 be 40007498 <_Heap_Walk+0x3a4>
40007678: 80 a4 80 1c cmp %l2, %i4
free_block = free_block->next;
4000767c: c2 00 60 08 ld [ %g1 + 8 ], %g1
while ( free_block != free_list_tail ) {
40007680: 80 a5 00 01 cmp %l4, %g1
40007684: 12 bf ff fc bne 40007674 <_Heap_Walk+0x580>
40007688: 80 a7 40 01 cmp %i5, %g1
(*printer)(
4000768c: 96 10 00 1d mov %i5, %o3
40007690: 92 10 20 01 mov 1, %o1
40007694: 15 10 00 43 sethi %hi(0x40010c00), %o2
40007698: 90 10 00 19 mov %i1, %o0
4000769c: 94 12 a0 60 or %o2, 0x60, %o2
400076a0: 9f c4 00 00 call %l0
400076a4: b4 10 20 00 clr %i2
400076a8: b0 0e a0 ff and %i2, 0xff, %i0
400076ac: 81 c7 e0 08 ret
400076b0: 81 e8 00 00 restore
(*printer)(
400076b4: 92 10 20 01 mov 1, %o1
400076b8: 15 10 00 42 sethi %hi(0x40010800), %o2
400076bc: 90 10 00 19 mov %i1, %o0
400076c0: 94 12 a2 58 or %o2, 0x258, %o2
400076c4: 9f c4 00 00 call %l0
400076c8: b4 10 20 00 clr %i2
400076cc: b0 0e a0 ff and %i2, 0xff, %i0
400076d0: 81 c7 e0 08 ret
400076d4: 81 e8 00 00 restore
(*printer)(
400076d8: 90 10 00 19 mov %i1, %o0
400076dc: 94 12 a2 38 or %o2, 0x238, %o2
400076e0: 9f c4 00 00 call %l0
400076e4: b4 10 20 00 clr %i2
400076e8: b0 0e a0 ff and %i2, 0xff, %i0
400076ec: 81 c7 e0 08 ret
400076f0: 81 e8 00 00 restore
(*printer)(
400076f4: 90 10 00 19 mov %i1, %o0
400076f8: 94 12 a2 08 or %o2, 0x208, %o2
400076fc: 9f c4 00 00 call %l0
40007700: b4 10 20 00 clr %i2
40007704: b0 0e a0 ff and %i2, 0xff, %i0
40007708: 81 c7 e0 08 ret
4000770c: 81 e8 00 00 restore
(*printer)(
40007710: 92 10 20 01 mov 1, %o1
40007714: 15 10 00 43 sethi %hi(0x40010c00), %o2
40007718: 90 10 00 19 mov %i1, %o0
4000771c: 94 12 a0 10 or %o2, 0x10, %o2
40007720: 9f c4 00 00 call %l0
40007724: b4 10 20 00 clr %i2
40007728: b0 0e a0 ff and %i2, 0xff, %i0
4000772c: 81 c7 e0 08 ret
40007730: 81 e8 00 00 restore
4000a1c4 <_IO_Base64>:
}
int
_IO_Base64(IO_Put_char put_char, void *arg, const void *src, size_t srclen,
const char *wordbreak, int wordlen)
{
4000a1c4: 9d e3 bf a0 save %sp, -96, %sp
4000a1c8: 80 a7 60 04 cmp %i5, 4
4000a1cc: 26 80 00 02 bl,a 4000a1d4 <_IO_Base64+0x10>
4000a1d0: ba 10 20 04 mov 4, %i5
if (wordlen < 4) {
wordlen = 4;
}
while (srclen > 2) {
4000a1d4: 80 a6 e0 02 cmp %i3, 2
4000a1d8: 08 80 00 41 bleu 4000a2dc <_IO_Base64+0x118>
4000a1dc: a2 10 20 00 clr %l1
4000a1e0: 21 10 00 ef sethi %hi(0x4003bc00), %l0
4000a1e4: a4 10 20 00 clr %l2
4000a1e8: 10 80 00 05 b 4000a1fc <_IO_Base64+0x38>
4000a1ec: a0 14 23 00 or %l0, 0x300, %l0
4000a1f0: 80 a6 e0 02 cmp %i3, 2
4000a1f4: 08 80 00 3a bleu 4000a2dc <_IO_Base64+0x118>
4000a1f8: 01 00 00 00 nop
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
4000a1fc: c2 0e 80 00 ldub [ %i2 ], %g1
4000a200: 83 30 60 02 srl %g1, 2, %g1
(*put_char)(c, arg);
4000a204: d0 4c 00 01 ldsb [ %l0 + %g1 ], %o0
4000a208: 9f c6 00 00 call %i0
4000a20c: 92 10 00 19 mov %i1, %o1
_IO_Put(base64[((in[0]<<4)&0x30)|
4000a210: c2 0e 80 00 ldub [ %i2 ], %g1
((in[1]>>4)&0x0f)], arg, put_char);
4000a214: c4 0e a0 01 ldub [ %i2 + 1 ], %g2
4000a218: 85 30 a0 04 srl %g2, 4, %g2
_IO_Put(base64[((in[0]<<4)&0x30)|
4000a21c: 83 28 60 04 sll %g1, 4, %g1
4000a220: 82 08 60 30 and %g1, 0x30, %g1
4000a224: 82 10 40 02 or %g1, %g2, %g1
(*put_char)(c, arg);
4000a228: d0 4c 00 01 ldsb [ %l0 + %g1 ], %o0
4000a22c: 9f c6 00 00 call %i0
4000a230: 92 10 00 19 mov %i1, %o1
_IO_Put(base64[((in[1]<<2)&0x3c)|
4000a234: c2 0e a0 01 ldub [ %i2 + 1 ], %g1
((in[2]>>6)&0x03)], arg, put_char);
4000a238: c4 0e a0 02 ldub [ %i2 + 2 ], %g2
4000a23c: 85 30 a0 06 srl %g2, 6, %g2
_IO_Put(base64[((in[1]<<2)&0x3c)|
4000a240: 83 28 60 02 sll %g1, 2, %g1
4000a244: 82 08 60 3c and %g1, 0x3c, %g1
4000a248: 82 10 40 02 or %g1, %g2, %g1
(*put_char)(c, arg);
4000a24c: d0 4c 00 01 ldsb [ %l0 + %g1 ], %o0
4000a250: 9f c6 00 00 call %i0
4000a254: 92 10 00 19 mov %i1, %o1
_IO_Put(base64[in[2]&0x3f], arg, put_char);
4000a258: c2 0e a0 02 ldub [ %i2 + 2 ], %g1
4000a25c: 82 08 60 3f and %g1, 0x3f, %g1
(*put_char)(c, arg);
4000a260: d0 4c 00 01 ldsb [ %l0 + %g1 ], %o0
4000a264: 9f c6 00 00 call %i0
4000a268: 92 10 00 19 mov %i1, %o1
in += 3;
4000a26c: b4 06 a0 03 add %i2, 3, %i2
srclen -= 3;
out += 4;
loops++;
if (srclen != 0 &&
4000a270: b6 86 ff fd addcc %i3, -3, %i3
4000a274: 02 80 00 35 be 4000a348 <_IO_Base64+0x184>
4000a278: a2 04 60 04 add %l1, 4, %l1
(int)((loops + 1) * 4) >= wordlen)
4000a27c: 82 04 a0 02 add %l2, 2, %g1
4000a280: 83 28 60 02 sll %g1, 2, %g1
if (srclen != 0 &&
4000a284: 80 a7 40 01 cmp %i5, %g1
4000a288: 14 bf ff da bg 4000a1f0 <_IO_Base64+0x2c>
4000a28c: a4 04 a0 01 inc %l2
{
const char *w = wordbreak;
loops = 0;
while (*w != '\0') {
4000a290: d0 0f 00 00 ldub [ %i4 ], %o0
4000a294: 91 2a 20 18 sll %o0, 0x18, %o0
4000a298: 80 a2 20 00 cmp %o0, 0
4000a29c: 02 80 00 0d be 4000a2d0 <_IO_Base64+0x10c>
<== NEVER TAKEN
4000a2a0: 80 a6 e0 02 cmp %i3, 2
4000a2a4: a4 10 00 1c mov %i4, %l2
(*put_char)(c, arg);
4000a2a8: 91 3a 20 18 sra %o0, 0x18, %o0
4000a2ac: 9f c6 00 00 call %i0
4000a2b0: 92 10 00 19 mov %i1, %o1
_IO_Put(*w, arg, put_char);
++w;
4000a2b4: a4 04 a0 01 inc %l2
while (*w != '\0') {
4000a2b8: d0 0c 80 00 ldub [ %l2 ], %o0
4000a2bc: 91 2a 20 18 sll %o0, 0x18, %o0
4000a2c0: 80 a2 20 00 cmp %o0, 0
4000a2c4: 12 bf ff f9 bne 4000a2a8 <_IO_Base64+0xe4>
<== NEVER TAKEN
4000a2c8: a2 04 60 01 inc %l1
while (srclen > 2) {
4000a2cc: 80 a6 e0 02 cmp %i3, 2
4000a2d0: 18 bf ff cb bgu 4000a1fc <_IO_Base64+0x38>
4000a2d4: a4 10 20 00 clr %l2
++out;
}
}
}
if (srclen == 2) {
4000a2d8: 80 a6 e0 02 cmp %i3, 2
4000a2dc: 12 80 00 1d bne 4000a350 <_IO_Base64+0x18c>
4000a2e0: 3b 10 00 ef sethi %hi(0x4003bc00), %i5
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
4000a2e4: c2 0e 80 00 ldub [ %i2 ], %g1
4000a2e8: 83 30 60 02 srl %g1, 2, %g1
4000a2ec: ba 17 63 00 or %i5, 0x300, %i5
(*put_char)(c, arg);
4000a2f0: d0 4f 40 01 ldsb [ %i5 + %g1 ], %o0
4000a2f4: 9f c6 00 00 call %i0
4000a2f8: 92 10 00 19 mov %i1, %o1
_IO_Put(base64[((in[0]<<4)&0x30)|
4000a2fc: c2 0e 80 00 ldub [ %i2 ], %g1
((in[1]>>4)&0x0f)], arg, put_char);
4000a300: c4 0e a0 01 ldub [ %i2 + 1 ], %g2
4000a304: 85 30 a0 04 srl %g2, 4, %g2
_IO_Put(base64[((in[0]<<4)&0x30)|
4000a308: 83 28 60 04 sll %g1, 4, %g1
4000a30c: 82 08 60 30 and %g1, 0x30, %g1
4000a310: 82 10 40 02 or %g1, %g2, %g1
(*put_char)(c, arg);
4000a314: d0 4f 40 01 ldsb [ %i5 + %g1 ], %o0
4000a318: 9f c6 00 00 call %i0
4000a31c: 92 10 00 19 mov %i1, %o1
_IO_Put(base64[((in[1]<<2)&0x3c)], arg, put_char);
4000a320: c2 0e a0 01 ldub [ %i2 + 1 ], %g1
4000a324: 83 28 60 02 sll %g1, 2, %g1
4000a328: 82 08 60 3c and %g1, 0x3c, %g1
(*put_char)(c, arg);
4000a32c: d0 4f 40 01 ldsb [ %i5 + %g1 ], %o0
4000a330: 92 10 00 19 mov %i1, %o1
4000a334: 9f c6 00 00 call %i0
4000a338: a2 04 60 04 add %l1, 4, %l1
4000a33c: 92 10 00 19 mov %i1, %o1
4000a340: 9f c6 00 00 call %i0
4000a344: 90 10 20 3d mov 0x3d, %o0
_IO_Put('=', arg, put_char);
_IO_Put('=', arg, put_char);
out += 4;
}
return out;
}
4000a348: 81 c7 e0 08 ret
4000a34c: 91 e8 00 11 restore %g0, %l1, %o0
} else if (srclen == 1) {
4000a350: 80 a6 e0 01 cmp %i3, 1
4000a354: 12 bf ff fd bne 4000a348 <_IO_Base64+0x184>
4000a358: ba 17 63 00 or %i5, 0x300, %i5
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
4000a35c: c2 0e 80 00 ldub [ %i2 ], %g1
4000a360: 83 30 60 02 srl %g1, 2, %g1
(*put_char)(c, arg);
4000a364: d0 4f 40 01 ldsb [ %i5 + %g1 ], %o0
4000a368: 9f c6 00 00 call %i0
4000a36c: 92 10 00 19 mov %i1, %o1
_IO_Put(base64[((in[0]<<4)&0x30)], arg, put_char);
4000a370: c2 0e 80 00 ldub [ %i2 ], %g1
4000a374: 83 28 60 04 sll %g1, 4, %g1
4000a378: 82 08 60 30 and %g1, 0x30, %g1
(*put_char)(c, arg);
4000a37c: d0 4f 40 01 ldsb [ %i5 + %g1 ], %o0
4000a380: 9f c6 00 00 call %i0
4000a384: 92 10 00 19 mov %i1, %o1
4000a388: 92 10 00 19 mov %i1, %o1
4000a38c: 10 bf ff ea b 4000a334 <_IO_Base64+0x170>
4000a390: 90 10 20 3d mov 0x3d, %o0
40009bd8 <_IO_Vprintf>:
return (p);
}
int
_IO_Vprintf(IO_Put_char put_char, void *arg, char const *fmt, va_list ap)
{
40009bd8: 9d e3 bf 50 save %sp, -176, %sp
char padc;
int stop = 0, retval = 0;
num = 0;
if (fmt == NULL)
40009bdc: 80 a6 a0 00 cmp %i2, 0
40009be0: 02 80 00 3e be 40009cd8 <_IO_Vprintf+0x100>
<== NEVER TAKEN
40009be4: b8 10 00 18 mov %i0, %i4
}
percent = fmt - 1;
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
sign = 0; dot = 0; dwidth = 0; upper = 0;
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
reswitch: switch (ch = (u_char)*fmt++) {
40009be8: 31 10 00 26 sethi %hi(0x40009800), %i0
40009bec: 03 10 00 5d sethi %hi(0x40017400), %g1
40009bf0: a8 10 20 00 clr %l4
40009bf4: a4 10 20 00 clr %l2
40009bf8: b0 16 22 78 or %i0, 0x278, %i0
40009bfc: ae 10 62 9f or %g1, 0x29f, %l7
while ((ch = (u_char)*fmt++) != '%' || stop) {
40009c00: c2 0e 80 00 ldub [ %i2 ], %g1
40009c04: a4 0c a0 01 and %l2, 1, %l2
40009c08: ba 06 a0 01 add %i2, 1, %i5
40009c0c: 90 10 00 01 mov %g1, %o0
40009c10: 80 a0 60 25 cmp %g1, 0x25
40009c14: 12 80 00 05 bne 40009c28 <_IO_Vprintf+0x50>
40009c18: a0 10 00 12 mov %l2, %l0
40009c1c: 80 a4 a0 00 cmp %l2, 0
40009c20: 22 80 00 16 be,a 40009c78 <_IO_Vprintf+0xa0>
<== ALWAYS TAKEN
40009c24: 82 10 00 1d mov %i5, %g1
if (ch == '\0')
40009c28: 80 a0 60 00 cmp %g1, 0
40009c2c: 02 80 00 32 be 40009cf4 <_IO_Vprintf+0x11c>
40009c30: b4 25 00 1a sub %l4, %i2, %i2
while ((ch = (u_char)*fmt++) != '%' || stop) {
40009c34: a0 0c 20 ff and %l0, 0xff, %l0
PCHAR(ch);
40009c38: 9f c7 00 00 call %i4
40009c3c: 92 10 00 19 mov %i1, %o1
while ((ch = (u_char)*fmt++) != '%' || stop) {
40009c40: 82 07 60 01 add %i5, 1, %g1
40009c44: d0 08 7f ff ldub [ %g1 + -1 ], %o0
40009c48: 80 a2 20 25 cmp %o0, 0x25
40009c4c: 12 80 00 05 bne 40009c60 <_IO_Vprintf+0x88>
40009c50: aa 07 40 1a add %i5, %i2, %l5
40009c54: 80 a4 20 00 cmp %l0, 0
40009c58: 02 80 00 0b be 40009c84 <_IO_Vprintf+0xac>
<== ALWAYS TAKEN
40009c5c: 84 10 20 20 mov 0x20, %g2
if (ch == '\0')
40009c60: 80 a2 20 00 cmp %o0, 0
40009c64: 12 bf ff f5 bne 40009c38 <_IO_Vprintf+0x60>
40009c68: ba 10 00 01 mov %g1, %i5
40009c6c: ac 10 00 15 mov %l5, %l6
stop = 1;
break;
}
}
#undef PCHAR
}
40009c70: 81 c7 e0 08 ret
40009c74: 91 e8 00 16 restore %g0, %l6, %o0
while ((ch = (u_char)*fmt++) != '%' || stop) {
40009c78: aa 10 00 14 mov %l4, %l5
40009c7c: ba 10 00 1a mov %i2, %i5
padc = ' ';
40009c80: 84 10 20 20 mov 0x20, %g2
sign = 0; dot = 0; dwidth = 0; upper = 0;
40009c84: c0 27 bf d0 clr [ %fp + -48 ]
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
40009c88: a8 10 20 00 clr %l4
padc = ' ';
40009c8c: c4 2f bf c3 stb %g2, [ %fp + -61 ]
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
40009c90: 9e 10 20 00 clr %o7
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
40009c94: c0 27 bf c4 clr [ %fp + -60 ]
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
40009c98: 9a 10 20 00 clr %o5
width = 0;
40009c9c: c0 27 bf d4 clr [ %fp + -44 ]
sign = 0; dot = 0; dwidth = 0; upper = 0;
40009ca0: 96 10 20 00 clr %o3
40009ca4: d8 08 40 00 ldub [ %g1 ], %o4
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
40009ca8: a4 10 20 00 clr %l2
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
40009cac: 88 10 20 00 clr %g4
reswitch: switch (ch = (u_char)*fmt++) {
40009cb0: 84 03 3f dd add %o4, -35, %g2
40009cb4: b4 00 60 01 add %g1, 1, %i2
40009cb8: 84 08 a0 ff and %g2, 0xff, %g2
40009cbc: 80 a0 a0 57 cmp %g2, 0x57
40009cc0: 18 80 01 d9 bgu 4000a424 <_IO_Vprintf+0x84c>
<== NEVER TAKEN
40009cc4: 90 0b 20 ff and %o4, 0xff, %o0
40009cc8: 85 28 a0 02 sll %g2, 2, %g2
40009ccc: c4 06 00 02 ld [ %i0 + %g2 ], %g2
40009cd0: 81 c0 80 00 jmp %g2
40009cd4: 01 00 00 00 nop
fmt = "(fmt null)\n";
40009cd8: 35 10 00 5d sethi %hi(0x40017400), %i2
<== NOT EXECUTED
40009cdc: 10 bf ff c3 b 40009be8 <_IO_Vprintf+0x10>
<== NOT EXECUTED
40009ce0: b4 16 a2 88 or %i2, 0x288, %i2 ! 40017688 <_Workspace_Is_unified+0x8>
<== NOT EXECUTED
40009ce4: d8 08 60 01 ldub [ %g1 + 1 ], %o4
zflag = 1;
40009ce8: 88 10 20 01 mov 1, %g4
goto reswitch;
40009cec: 10 bf ff f1 b 40009cb0 <_IO_Vprintf+0xd8>
40009cf0: 82 10 00 1a mov %i2, %g1
return (retval);
40009cf4: 10 bf ff df b 40009c70 <_IO_Vprintf+0x98>
40009cf8: ac 10 00 14 mov %l4, %l6
if (!dot) {
40009cfc: 80 a2 e0 00 cmp %o3, 0
40009d00: 32 80 02 5b bne,a 4000a66c <_IO_Vprintf+0xa94>
<== NEVER TAKEN
40009d04: c6 48 60 01 ldsb [ %g1 + 1 ], %g3
<== NOT EXECUTED
padc = '0';
40009d08: d8 2f bf c3 stb %o4, [ %fp + -61 ]
if (!dot) {
40009d0c: d8 08 60 01 ldub [ %g1 + 1 ], %o4
reswitch: switch (ch = (u_char)*fmt++) {
40009d10: 10 bf ff e8 b 40009cb0 <_IO_Vprintf+0xd8>
40009d14: 82 10 00 1a mov %i2, %g1
40009d18: 84 10 20 00 clr %g2
40009d1c: 86 10 20 10 mov 0x10, %g3
base = 16;
40009d20: 82 10 20 10 mov 0x10, %g1
reswitch: switch (ch = (u_char)*fmt++) {
40009d24: c4 3f bf b0 std %g2, [ %fp + -80 ]
sign = 0; dot = 0; dwidth = 0; upper = 0;
40009d28: ba 10 20 00 clr %i5
base = 16;
40009d2c: c2 27 bf bc st %g1, [ %fp + -68 ]
if (jflag)
40009d30: 80 a5 20 00 cmp %l4, 0
40009d34: 02 80 01 dc be 4000a4a4 <_IO_Vprintf+0x8cc>
40009d38: 80 a1 20 00 cmp %g4, 0
num = va_arg(ap, uintmax_t);
40009d3c: 92 10 00 1b mov %i3, %o1
40009d40: 94 10 20 08 mov 8, %o2
40009d44: 40 00 16 5a call 4000f6ac <memcpy>
40009d48: 90 07 bf d8 add %fp, -40, %o0
40009d4c: c4 1f bf d8 ldd [ %fp + -40 ], %g2
40009d50: c4 3f bf c8 std %g2, [ %fp + -56 ]
40009d54: b6 06 e0 08 add %i3, 8, %i3
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
40009d58: a8 10 20 00 clr %l4
40009d5c: bb 2f 60 04 sll %i5, 4, %i5
*p = '\0';
40009d60: c0 2f bf e8 clrb [ %fp + -24 ]
*++p = hex2ascii_data[upper][num % base];
40009d64: a2 05 c0 1d add %l7, %i5, %l1
40009d68: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40009d6c: ac 10 00 1c mov %i4, %l6
*p = '\0';
40009d70: c4 1f bf c8 ldd [ %fp + -56 ], %g2
*++p = hex2ascii_data[upper][num % base];
40009d74: f8 1f bf b0 ldd [ %fp + -80 ], %i4
40009d78: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
*p = '\0';
40009d7c: a6 10 00 02 mov %g2, %l3
p = nbuf;
40009d80: a0 07 bf e8 add %fp, -24, %l0
*++p = hex2ascii_data[upper][num % base];
40009d84: b6 10 00 03 mov %g3, %i3
40009d88: 94 10 00 1c mov %i4, %o2
40009d8c: 96 10 00 1d mov %i5, %o3
40009d90: 90 10 00 13 mov %l3, %o0
40009d94: 40 00 14 4a call 4000eebc <__umoddi3>
40009d98: 92 10 00 1b mov %i3, %o1
40009d9c: f4 0c 40 09 ldub [ %l1 + %o1 ], %i2
40009da0: a0 04 20 01 inc %l0
40009da4: f4 2c 00 00 stb %i2, [ %l0 ]
} while (num /= base);
40009da8: 90 10 00 13 mov %l3, %o0
40009dac: 92 10 00 1b mov %i3, %o1
40009db0: 94 10 00 1c mov %i4, %o2
40009db4: 40 00 13 c9 call 4000ecd8 <__udivdi3>
40009db8: 96 10 00 1d mov %i5, %o3
40009dbc: a6 10 00 08 mov %o0, %l3
40009dc0: 80 92 40 13 orcc %o1, %l3, %g0
40009dc4: 12 bf ff f1 bne 40009d88 <_IO_Vprintf+0x1b0>
40009dc8: b6 10 00 09 mov %o1, %i3
if (sharpflag && num != 0) {
40009dcc: c4 1f bf c8 ldd [ %fp + -56 ], %g2
40009dd0: 82 10 00 02 mov %g2, %g1
40009dd4: c4 07 bf c4 ld [ %fp + -60 ], %g2
40009dd8: 82 10 40 03 or %g1, %g3, %g1
40009ddc: 80 a0 00 01 cmp %g0, %g1
40009de0: 86 40 20 00 addx %g0, 0, %g3
40009de4: 84 88 c0 02 andcc %g3, %g2, %g2
40009de8: c4 27 bf c4 st %g2, [ %fp + -60 ]
*lenp = p - nbuf;
40009dec: 82 07 bf e8 add %fp, -24, %g1
40009df0: ba 10 00 1a mov %i2, %i5
40009df4: a2 24 00 01 sub %l0, %g1, %l1
40009df8: b8 10 00 16 mov %l6, %i4
40009dfc: f4 07 a0 4c ld [ %fp + 0x4c ], %i2
40009e00: f6 07 a0 50 ld [ %fp + 0x50 ], %i3
if (sharpflag && num != 0) {
40009e04: 02 80 00 0a be 40009e2c <_IO_Vprintf+0x254>
40009e08: 82 10 20 00 clr %g1
if (base == 8)
40009e0c: c4 07 bf bc ld [ %fp + -68 ], %g2
40009e10: 80 a0 a0 08 cmp %g2, 8
40009e14: 02 80 00 06 be 40009e2c <_IO_Vprintf+0x254>
<== NEVER TAKEN
40009e18: 82 10 20 01 mov 1, %g1
tmp = 0;
40009e1c: 82 18 a0 10 xor %g2, 0x10, %g1
40009e20: 80 a0 00 01 cmp %g0, %g1
40009e24: 82 60 3f ff subx %g0, -1, %g1
40009e28: 83 28 60 01 sll %g1, 1, %g1
tmp++;
40009e2c: 80 a0 00 14 cmp %g0, %l4
40009e30: 82 40 00 01 addx %g0, %g1, %g1
if (!ladjust && padc == '0')
40009e34: 80 8c a0 01 btst 1, %l2
40009e38: 12 80 01 8d bne 4000a46c <_IO_Vprintf+0x894>
40009e3c: c4 0f bf c3 ldub [ %fp + -61 ], %g2
40009e40: 87 28 a0 18 sll %g2, 0x18, %g3
40009e44: 87 38 e0 18 sra %g3, 0x18, %g3
40009e48: 80 a0 e0 30 cmp %g3, 0x30
40009e4c: 12 80 01 88 bne 4000a46c <_IO_Vprintf+0x894>
40009e50: c4 07 bf d4 ld [ %fp + -44 ], %g2
dwidth = width - tmp;
40009e54: ac 20 80 01 sub %g2, %g1, %l6
static inline int imax(int a, int b) { return (a > b ? a : b); }
40009e58: 80 a5 80 11 cmp %l6, %l1
40009e5c: 16 80 00 04 bge 40009e6c <_IO_Vprintf+0x294>
40009e60: 86 10 00 16 mov %l6, %g3
40009e64: 86 10 00 11 mov %l1, %g3
width -= tmp + imax(dwidth, n);
40009e68: c4 07 bf d4 ld [ %fp + -44 ], %g2
40009e6c: 82 00 c0 01 add %g3, %g1, %g1
dwidth -= n;
40009e70: a2 25 80 11 sub %l6, %l1, %l1
width -= tmp + imax(dwidth, n);
40009e74: a6 20 80 01 sub %g2, %g1, %l3
while (width-- > 0)
40009e78: ac 04 ff ff add %l3, -1, %l6
40009e7c: 80 a4 e0 00 cmp %l3, 0
40009e80: 04 80 00 0b ble 40009eac <_IO_Vprintf+0x2d4>
40009e84: a6 10 00 16 mov %l6, %l3
PCHAR(' ');
40009e88: 92 10 00 19 mov %i1, %o1
40009e8c: 9f c7 00 00 call %i4
40009e90: 90 10 20 20 mov 0x20, %o0
while (width-- > 0)
40009e94: a6 04 ff ff add %l3, -1, %l3
40009e98: 80 a4 ff ff cmp %l3, -1
40009e9c: 12 bf ff fc bne 40009e8c <_IO_Vprintf+0x2b4>
40009ea0: 92 10 00 19 mov %i1, %o1
40009ea4: 84 05 60 01 add %l5, 1, %g2
40009ea8: aa 05 80 02 add %l6, %g2, %l5
if (neg)
40009eac: 80 a5 20 00 cmp %l4, 0
40009eb0: 02 80 01 8e be 4000a4e8 <_IO_Vprintf+0x910>
40009eb4: 92 10 00 19 mov %i1, %o1
PCHAR('-');
40009eb8: 90 10 20 2d mov 0x2d, %o0
40009ebc: 9f c7 00 00 call %i4
40009ec0: a8 05 60 01 add %l5, 1, %l4
if (sharpflag && num != 0) {
40009ec4: c2 07 bf c4 ld [ %fp + -60 ], %g1
40009ec8: 80 a0 60 00 cmp %g1, 0
40009ecc: 02 80 00 0a be 40009ef4 <_IO_Vprintf+0x31c>
40009ed0: 80 a4 60 00 cmp %l1, 0
if (base == 8) {
40009ed4: c2 07 bf bc ld [ %fp + -68 ], %g1
40009ed8: 80 a0 60 08 cmp %g1, 8
40009edc: 12 80 01 92 bne 4000a524 <_IO_Vprintf+0x94c>
<== ALWAYS TAKEN
40009ee0: 92 10 00 19 mov %i1, %o1
PCHAR('0');
40009ee4: 90 10 20 30 mov 0x30, %o0
<== NOT EXECUTED
40009ee8: 9f c7 00 00 call %i4
<== NOT EXECUTED
40009eec: a8 05 20 01 inc %l4
<== NOT EXECUTED
while (dwidth-- > 0)
40009ef0: 80 a4 60 00 cmp %l1, 0
<== NOT EXECUTED
40009ef4: 04 80 00 0c ble 40009f24 <_IO_Vprintf+0x34c>
40009ef8: aa 04 7f ff add %l1, -1, %l5
40009efc: a2 10 00 15 mov %l5, %l1
PCHAR('0');
40009f00: 92 10 00 19 mov %i1, %o1
40009f04: 9f c7 00 00 call %i4
40009f08: 90 10 20 30 mov 0x30, %o0
while (dwidth-- > 0)
40009f0c: a2 04 7f ff add %l1, -1, %l1
40009f10: 80 a4 7f ff cmp %l1, -1
40009f14: 12 bf ff fc bne 40009f04 <_IO_Vprintf+0x32c>
40009f18: 92 10 00 19 mov %i1, %o1
40009f1c: a8 05 20 01 inc %l4
40009f20: a8 05 00 15 add %l4, %l5, %l4
while (*p)
40009f24: bb 2f 60 18 sll %i5, 0x18, %i5
40009f28: 80 a7 60 00 cmp %i5, 0
40009f2c: 02 80 00 0c be 40009f5c <_IO_Vprintf+0x384>
<== NEVER TAKEN
40009f30: 80 a4 a0 00 cmp %l2, 0
PCHAR(*p--);
40009f34: 91 3f 60 18 sra %i5, 0x18, %o0
40009f38: a0 04 3f ff add %l0, -1, %l0
40009f3c: 9f c7 00 00 call %i4
40009f40: 92 10 00 19 mov %i1, %o1
while (*p)
40009f44: fa 0c 00 00 ldub [ %l0 ], %i5
40009f48: bb 2f 60 18 sll %i5, 0x18, %i5
40009f4c: 80 a7 60 00 cmp %i5, 0
40009f50: 12 bf ff f9 bne 40009f34 <_IO_Vprintf+0x35c>
40009f54: a8 05 20 01 inc %l4
if (ladjust)
40009f58: 80 a4 a0 00 cmp %l2, 0
40009f5c: 22 bf ff 2a be,a 40009c04 <_IO_Vprintf+0x2c>
40009f60: c2 0e 80 00 ldub [ %i2 ], %g1
while (width-- > 0)
40009f64: 80 a4 e0 00 cmp %l3, 0
40009f68: 04 80 01 59 ble 4000a4cc <_IO_Vprintf+0x8f4>
40009f6c: a0 04 ff ff add %l3, -1, %l0
40009f70: ba 10 00 10 mov %l0, %i5
PCHAR(' ');
40009f74: 92 10 00 19 mov %i1, %o1
40009f78: 9f c7 00 00 call %i4
40009f7c: 90 10 20 20 mov 0x20, %o0
while (width-- > 0)
40009f80: ba 07 7f ff add %i5, -1, %i5
40009f84: 80 a7 7f ff cmp %i5, -1
40009f88: 12 bf ff fc bne 40009f78 <_IO_Vprintf+0x3a0>
40009f8c: 92 10 00 19 mov %i1, %o1
40009f90: a8 05 20 01 inc %l4
40009f94: a4 10 20 00 clr %l2
40009f98: 10 bf ff 1a b 40009c00 <_IO_Vprintf+0x28>
40009f9c: a8 04 00 14 add %l0, %l4, %l4
reswitch: switch (ch = (u_char)*fmt++) {
40009fa0: 84 10 20 00 clr %g2
<== NOT EXECUTED
40009fa4: 86 10 20 10 mov 0x10, %g3
<== NOT EXECUTED
base = 16;
40009fa8: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
40009fac: c4 3f bf b0 std %g2, [ %fp + -80 ]
<== NOT EXECUTED
base = 16;
40009fb0: c2 27 bf bc st %g1, [ %fp + -68 ]
<== NOT EXECUTED
if (jflag)
40009fb4: 80 a5 20 00 cmp %l4, 0
40009fb8: 02 80 01 4e be 4000a4f0 <_IO_Vprintf+0x918>
40009fbc: 82 06 e0 04 add %i3, 4, %g1
num = va_arg(ap, intmax_t);
40009fc0: 92 10 00 1b mov %i3, %o1
40009fc4: 94 10 20 08 mov 8, %o2
40009fc8: 40 00 15 b9 call 4000f6ac <memcpy>
40009fcc: 90 07 bf e0 add %fp, -32, %o0
40009fd0: c4 1f bf e0 ldd [ %fp + -32 ], %g2
40009fd4: c4 3f bf c8 std %g2, [ %fp + -56 ]
40009fd8: b6 06 e0 08 add %i3, 8, %i3
if (sign && (intmax_t)num < 0) {
40009fdc: c4 1f bf c8 ldd [ %fp + -56 ], %g2
40009fe0: 82 90 a0 00 orcc %g2, 0, %g1
40009fe4: 16 80 01 c8 bge 4000a704 <_IO_Vprintf+0xb2c>
40009fe8: 9a a0 00 03 subcc %g0, %g3, %o5
num = -(intmax_t)num;
40009fec: ba 10 20 00 clr %i5
40009ff0: 98 60 00 02 subx %g0, %g2, %o4
neg = 1;
40009ff4: a8 10 20 01 mov 1, %l4
num = -(intmax_t)num;
40009ff8: 10 bf ff 59 b 40009d5c <_IO_Vprintf+0x184>
40009ffc: d8 3f bf c8 std %o4, [ %fp + -56 ]
if (!ladjust && width > 0)
4000a000: c2 07 bf d4 ld [ %fp + -44 ], %g1
4000a004: 80 a0 60 01 cmp %g1, 1
4000a008: 14 80 00 03 bg 4000a014 <_IO_Vprintf+0x43c>
<== NEVER TAKEN
4000a00c: ba 10 20 01 mov 1, %i5
4000a010: ba 10 20 00 clr %i5
4000a014: a8 05 60 01 add %l5, 1, %l4
4000a018: 80 8c a0 01 btst 1, %l2
4000a01c: 12 80 01 52 bne 4000a564 <_IO_Vprintf+0x98c>
<== NEVER TAKEN
4000a020: a0 06 e0 04 add %i3, 4, %l0
4000a024: 80 8f 60 ff btst 0xff, %i5
4000a028: 02 80 01 4f be 4000a564 <_IO_Vprintf+0x98c>
<== ALWAYS TAKEN
4000a02c: c2 07 bf d4 ld [ %fp + -44 ], %g1
while (width--)
4000a030: a6 00 7f fe add %g1, -2, %l3
<== NOT EXECUTED
4000a034: c2 0f bf c3 ldub [ %fp + -61 ], %g1
<== NOT EXECUTED
4000a038: a3 28 60 18 sll %g1, 0x18, %l1
<== NOT EXECUTED
4000a03c: ba 10 00 13 mov %l3, %i5
<== NOT EXECUTED
4000a040: a3 3c 60 18 sra %l1, 0x18, %l1
<== NOT EXECUTED
PCHAR(padc);
4000a044: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000a048: 9f c7 00 00 call %i4
<== NOT EXECUTED
4000a04c: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
while (width--)
4000a050: ba 07 7f ff add %i5, -1, %i5
<== NOT EXECUTED
4000a054: 80 a7 7f ff cmp %i5, -1
<== NOT EXECUTED
4000a058: 12 bf ff fc bne 4000a048 <_IO_Vprintf+0x470>
<== NOT EXECUTED
4000a05c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
PCHAR(va_arg(ap, int));
4000a060: d0 06 c0 00 ld [ %i3 ], %o0
<== NOT EXECUTED
4000a064: a6 05 00 13 add %l4, %l3, %l3
<== NOT EXECUTED
4000a068: a8 04 e0 01 add %l3, 1, %l4
<== NOT EXECUTED
4000a06c: 9f c7 00 00 call %i4
<== NOT EXECUTED
4000a070: b6 10 00 10 mov %l0, %i3
<== NOT EXECUTED
4000a074: 10 bf fe e3 b 40009c00 <_IO_Vprintf+0x28>
<== NOT EXECUTED
4000a078: a4 10 20 00 clr %l2
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
4000a07c: 84 10 20 00 clr %g2
4000a080: 86 10 20 0a mov 0xa, %g3
base = 10;
4000a084: 82 10 20 0a mov 0xa, %g1
reswitch: switch (ch = (u_char)*fmt++) {
4000a088: c4 3f bf b0 std %g2, [ %fp + -80 ]
base = 10;
4000a08c: 10 bf ff ca b 40009fb4 <_IO_Vprintf+0x3dc>
4000a090: c2 27 bf bc st %g1, [ %fp + -68 ]
if (hflag) {
4000a094: 80 a3 e0 00 cmp %o7, 0
4000a098: 12 80 01 55 bne 4000a5ec <_IO_Vprintf+0xa14>
4000a09c: d8 08 60 01 ldub [ %g1 + 1 ], %o4
hflag = 1;
4000a0a0: 9e 10 20 01 mov 1, %o7
reswitch: switch (ch = (u_char)*fmt++) {
4000a0a4: 10 bf ff 03 b 40009cb0 <_IO_Vprintf+0xd8>
4000a0a8: 82 10 00 1a mov %i2, %g1
4000a0ac: d8 08 60 01 ldub [ %g1 + 1 ], %o4
jflag = 1;
4000a0b0: a8 10 20 01 mov 1, %l4
goto reswitch;
4000a0b4: 10 bf fe ff b 40009cb0 <_IO_Vprintf+0xd8>
4000a0b8: 82 10 00 1a mov %i2, %g1
reswitch: switch (ch = (u_char)*fmt++) {
4000a0bc: 84 10 20 00 clr %g2
4000a0c0: 86 10 20 10 mov 0x10, %g3
base = 16;
4000a0c4: 82 10 20 10 mov 0x10, %g1
reswitch: switch (ch = (u_char)*fmt++) {
4000a0c8: c4 3f bf b0 std %g2, [ %fp + -80 ]
upper = 1;
4000a0cc: ba 10 20 01 mov 1, %i5
base = 16;
4000a0d0: 10 bf ff 18 b 40009d30 <_IO_Vprintf+0x158>
4000a0d4: c2 27 bf bc st %g1, [ %fp + -68 ]
reswitch: switch (ch = (u_char)*fmt++) {
4000a0d8: 84 10 20 00 clr %g2
4000a0dc: 86 10 20 0a mov 0xa, %g3
base = 10;
4000a0e0: 82 10 20 0a mov 0xa, %g1
reswitch: switch (ch = (u_char)*fmt++) {
4000a0e4: c4 3f bf b0 std %g2, [ %fp + -80 ]
sign = 0; dot = 0; dwidth = 0; upper = 0;
4000a0e8: ba 10 20 00 clr %i5
base = 10;
4000a0ec: 10 bf ff 11 b 40009d30 <_IO_Vprintf+0x158>
4000a0f0: c2 27 bf bc st %g1, [ %fp + -68 ]
4000a0f4: d8 08 60 01 ldub [ %g1 + 1 ], %o4
dot = 1;
4000a0f8: 96 10 20 01 mov 1, %o3
reswitch: switch (ch = (u_char)*fmt++) {
4000a0fc: 10 bf fe ed b 40009cb0 <_IO_Vprintf+0xd8>
4000a100: 82 10 00 1a mov %i2, %g1
ch = *fmt;
4000a104: c6 48 60 01 ldsb [ %g1 + 1 ], %g3
if (ch < '0' || ch > '9')
4000a108: 84 00 ff d0 add %g3, -48, %g2
n = n * 10 + ch - '0';
4000a10c: 90 02 3f d0 add %o0, -48, %o0
if (ch < '0' || ch > '9')
4000a110: 80 a0 a0 09 cmp %g2, 9
4000a114: 18 80 00 d4 bgu 4000a464 <_IO_Vprintf+0x88c>
4000a118: d8 08 60 01 ldub [ %g1 + 1 ], %o4
reswitch: switch (ch = (u_char)*fmt++) {
4000a11c: 82 10 00 1a mov %i2, %g1
for (n = 0;; ++fmt) {
4000a120: 82 00 60 01 inc %g1
n = n * 10 + ch - '0';
4000a124: 85 2a 20 02 sll %o0, 2, %g2
4000a128: 84 00 80 08 add %g2, %o0, %g2
4000a12c: 85 28 a0 01 sll %g2, 1, %g2
4000a130: 84 00 80 03 add %g2, %g3, %g2
ch = *fmt;
4000a134: c6 48 40 00 ldsb [ %g1 ], %g3
if (ch < '0' || ch > '9')
4000a138: b4 00 ff d0 add %g3, -48, %i2
n = n * 10 + ch - '0';
4000a13c: 90 00 bf d0 add %g2, -48, %o0
if (ch < '0' || ch > '9')
4000a140: 80 a6 a0 09 cmp %i2, 9
4000a144: 08 bf ff f7 bleu 4000a120 <_IO_Vprintf+0x548>
<== NEVER TAKEN
4000a148: d8 08 40 00 ldub [ %g1 ], %o4
if (dot)
4000a14c: 80 a2 e0 00 cmp %o3, 0
4000a150: 22 bf fe d8 be,a 40009cb0 <_IO_Vprintf+0xd8>
4000a154: d0 27 bf d4 st %o0, [ %fp + -44 ]
4000a158: 10 bf fe d6 b 40009cb0 <_IO_Vprintf+0xd8>
4000a15c: d0 27 bf d0 st %o0, [ %fp + -48 ]
if (!width)
4000a160: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
up = va_arg(ap, u_char *);
4000a164: e0 06 c0 00 ld [ %i3 ], %l0
<== NOT EXECUTED
p = va_arg(ap, char *);
4000a168: e2 06 e0 04 ld [ %i3 + 4 ], %l1
<== NOT EXECUTED
if (!width)
4000a16c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000a170: 12 80 00 04 bne 4000a180 <_IO_Vprintf+0x5a8>
<== NOT EXECUTED
4000a174: b6 06 e0 08 add %i3, 8, %i3
<== NOT EXECUTED
width = 16;
4000a178: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
4000a17c: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
4000a180: 82 04 3f ff add %l0, -1, %g1
<== NOT EXECUTED
4000a184: c4 07 bf d4 ld [ %fp + -44 ], %g2
<== NOT EXECUTED
for (q=p;*q;q++)
4000a188: a8 10 00 15 mov %l5, %l4
<== NOT EXECUTED
4000a18c: a4 04 00 02 add %l0, %g2, %l2
<== NOT EXECUTED
4000a190: a6 00 40 02 add %g1, %g2, %l3
<== NOT EXECUTED
while(width--) {
4000a194: 80 a4 80 10 cmp %l2, %l0
<== NOT EXECUTED
4000a198: 22 bf fe 9a be,a 40009c00 <_IO_Vprintf+0x28>
<== NOT EXECUTED
4000a19c: a4 10 20 00 clr %l2
<== NOT EXECUTED
PCHAR(hex2ascii(*up >> 4));
4000a1a0: c2 0c 00 00 ldub [ %l0 ], %g1
<== NOT EXECUTED
4000a1a4: 83 30 60 04 srl %g1, 4, %g1
<== NOT EXECUTED
4000a1a8: d0 4d c0 01 ldsb [ %l7 + %g1 ], %o0
<== NOT EXECUTED
4000a1ac: 9f c7 00 00 call %i4
<== NOT EXECUTED
4000a1b0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
PCHAR(hex2ascii(*up & 0x0f));
4000a1b4: c2 0c 00 00 ldub [ %l0 ], %g1
<== NOT EXECUTED
4000a1b8: 82 08 60 0f and %g1, 0xf, %g1
<== NOT EXECUTED
4000a1bc: d0 4d c0 01 ldsb [ %l7 + %g1 ], %o0
<== NOT EXECUTED
4000a1c0: 9f c7 00 00 call %i4
<== NOT EXECUTED
4000a1c4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
if (width)
4000a1c8: 80 a4 c0 10 cmp %l3, %l0
<== NOT EXECUTED
4000a1cc: 02 80 00 c0 be 4000a4cc <_IO_Vprintf+0x8f4>
<== NOT EXECUTED
4000a1d0: a8 05 20 02 add %l4, 2, %l4
<== NOT EXECUTED
for (q=p;*q;q++)
4000a1d4: d0 0c 40 00 ldub [ %l1 ], %o0
<== NOT EXECUTED
4000a1d8: 91 2a 20 18 sll %o0, 0x18, %o0
<== NOT EXECUTED
4000a1dc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000a1e0: 22 bf ff ed be,a 4000a194 <_IO_Vprintf+0x5bc>
<== NOT EXECUTED
4000a1e4: a0 04 20 01 inc %l0
<== NOT EXECUTED
4000a1e8: ba 10 00 11 mov %l1, %i5
<== NOT EXECUTED
PCHAR(*q);
4000a1ec: 91 3a 20 18 sra %o0, 0x18, %o0
<== NOT EXECUTED
4000a1f0: 9f c7 00 00 call %i4
<== NOT EXECUTED
4000a1f4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
for (q=p;*q;q++)
4000a1f8: ba 07 60 01 inc %i5
<== NOT EXECUTED
4000a1fc: d0 0f 40 00 ldub [ %i5 ], %o0
<== NOT EXECUTED
4000a200: 91 2a 20 18 sll %o0, 0x18, %o0
<== NOT EXECUTED
4000a204: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000a208: 12 bf ff f9 bne 4000a1ec <_IO_Vprintf+0x614>
<== NOT EXECUTED
4000a20c: a8 05 20 01 inc %l4
<== NOT EXECUTED
4000a210: 10 bf ff e1 b 4000a194 <_IO_Vprintf+0x5bc>
<== NOT EXECUTED
4000a214: a0 04 20 01 inc %l0
<== NOT EXECUTED
if (lflag) {
4000a218: 80 a1 20 00 cmp %g4, 0
4000a21c: 02 bf fe b3 be 40009ce8 <_IO_Vprintf+0x110>
4000a220: d8 08 60 01 ldub [ %g1 + 1 ], %o4
jflag = 1;
4000a224: a8 10 00 04 mov %g4, %l4
reswitch: switch (ch = (u_char)*fmt++) {
4000a228: 10 bf fe a2 b 40009cb0 <_IO_Vprintf+0xd8>
4000a22c: 82 10 00 1a mov %i2, %g1
4000a230: 84 10 20 00 clr %g2
4000a234: 86 10 20 08 mov 8, %g3
base = 8;
4000a238: 82 10 20 08 mov 8, %g1
reswitch: switch (ch = (u_char)*fmt++) {
4000a23c: c4 3f bf b0 std %g2, [ %fp + -80 ]
sign = 0; dot = 0; dwidth = 0; upper = 0;
4000a240: ba 10 20 00 clr %i5
base = 8;
4000a244: 10 bf fe bb b 40009d30 <_IO_Vprintf+0x158>
4000a248: c2 27 bf bc st %g1, [ %fp + -68 ]
sharpflag = (width == 0);
4000a24c: c4 07 bf d4 ld [ %fp + -44 ], %g2
num = (uintptr_t)va_arg(ap, void *);
4000a250: c2 06 c0 00 ld [ %i3 ], %g1
sharpflag = (width == 0);
4000a254: 80 a0 00 02 cmp %g0, %g2
4000a258: 84 60 3f ff subx %g0, -1, %g2
num = (uintptr_t)va_arg(ap, void *);
4000a25c: 86 10 00 01 mov %g1, %g3
sharpflag = (width == 0);
4000a260: c4 27 bf c4 st %g2, [ %fp + -60 ]
num = (uintptr_t)va_arg(ap, void *);
4000a264: 84 10 20 00 clr %g2
base = 16;
4000a268: 82 10 20 10 mov 0x10, %g1
num = (uintptr_t)va_arg(ap, void *);
4000a26c: c4 3f bf c8 std %g2, [ %fp + -56 ]
4000a270: b6 06 e0 04 add %i3, 4, %i3
goto number;
4000a274: 84 10 20 00 clr %g2
4000a278: 86 10 20 10 mov 0x10, %g3
sign = 0; dot = 0; dwidth = 0; upper = 0;
4000a27c: ba 10 20 00 clr %i5
goto number;
4000a280: c4 3f bf b0 std %g2, [ %fp + -80 ]
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
4000a284: a8 10 20 00 clr %l4
goto number;
4000a288: 10 bf fe b5 b 40009d5c <_IO_Vprintf+0x184>
4000a28c: c2 27 bf bc st %g1, [ %fp + -68 ]
p = va_arg(ap, char *);
4000a290: fa 06 c0 00 ld [ %i3 ], %i5
if (p == NULL)
4000a294: 80 a7 60 00 cmp %i5, 0
4000a298: 02 80 00 fd be 4000a68c <_IO_Vprintf+0xab4>
4000a29c: b6 06 e0 04 add %i3, 4, %i3
if (!dot)
4000a2a0: 80 a2 e0 00 cmp %o3, 0
4000a2a4: 12 80 00 db bne 4000a610 <_IO_Vprintf+0xa38>
4000a2a8: c2 07 bf d0 ld [ %fp + -48 ], %g1
n = strlen (p);
4000a2ac: 40 00 16 6c call 4000fc5c <strlen>
4000a2b0: 90 10 00 1d mov %i5, %o0
4000a2b4: a2 10 00 08 mov %o0, %l1
width -= n;
4000a2b8: c2 07 bf d4 ld [ %fp + -44 ], %g1
4000a2bc: 84 20 40 11 sub %g1, %l1, %g2
4000a2c0: c4 27 bf d4 st %g2, [ %fp + -44 ]
if (!ladjust && width > 0)
4000a2c4: a1 38 a0 1f sra %g2, 0x1f, %l0
4000a2c8: 82 0c a0 01 and %l2, 1, %g1
4000a2cc: a0 24 00 02 sub %l0, %g2, %l0
4000a2d0: a8 04 7f ff add %l1, -1, %l4
4000a2d4: 80 8c a0 01 btst 1, %l2
4000a2d8: 12 80 00 c9 bne 4000a5fc <_IO_Vprintf+0xa24>
4000a2dc: a1 34 20 1f srl %l0, 0x1f, %l0
4000a2e0: 80 a4 20 00 cmp %l0, 0
4000a2e4: 02 80 00 c7 be 4000a600 <_IO_Vprintf+0xa28>
4000a2e8: 80 a4 60 00 cmp %l1, 0
while (width--)
4000a2ec: c2 07 bf d4 ld [ %fp + -44 ], %g1
4000a2f0: a6 00 7f ff add %g1, -1, %l3
4000a2f4: c2 0f bf c3 ldub [ %fp + -61 ], %g1
4000a2f8: a5 28 60 18 sll %g1, 0x18, %l2
4000a2fc: a0 10 00 13 mov %l3, %l0
4000a300: a5 3c a0 18 sra %l2, 0x18, %l2
PCHAR(padc);
4000a304: 92 10 00 19 mov %i1, %o1
4000a308: 9f c7 00 00 call %i4
4000a30c: 90 10 00 12 mov %l2, %o0
while (width--)
4000a310: a0 04 3f ff add %l0, -1, %l0
4000a314: 80 a4 3f ff cmp %l0, -1
4000a318: 12 bf ff fc bne 4000a308 <_IO_Vprintf+0x730>
4000a31c: 92 10 00 19 mov %i1, %o1
4000a320: 84 05 60 01 add %l5, 1, %g2
while (n--)
4000a324: 80 a4 60 00 cmp %l1, 0
4000a328: 02 80 00 fa be 4000a710 <_IO_Vprintf+0xb38>
<== NEVER TAKEN
4000a32c: aa 00 80 13 add %g2, %l3, %l5
4000a330: 82 10 3f ff mov -1, %g1
4000a334: c2 27 bf d4 st %g1, [ %fp + -44 ]
4000a338: a0 10 20 00 clr %l0
4000a33c: a2 05 20 01 add %l4, 1, %l1
4000a340: a2 07 40 11 add %i5, %l1, %l1
PCHAR(*p++);
4000a344: ba 07 60 01 inc %i5
4000a348: d0 4f 7f ff ldsb [ %i5 + -1 ], %o0
4000a34c: 9f c7 00 00 call %i4
4000a350: 92 10 00 19 mov %i1, %o1
while (n--)
4000a354: 80 a7 40 11 cmp %i5, %l1
4000a358: 32 bf ff fc bne,a 4000a348 <_IO_Vprintf+0x770>
4000a35c: ba 07 60 01 inc %i5
4000a360: 84 05 60 01 add %l5, 1, %g2
4000a364: a8 05 00 02 add %l4, %g2, %l4
if (ladjust && width > 0)
4000a368: 80 8c 20 ff btst 0xff, %l0
4000a36c: 02 bf fe 25 be 40009c00 <_IO_Vprintf+0x28>
4000a370: a4 10 20 00 clr %l2
while (width--)
4000a374: c2 07 bf d4 ld [ %fp + -44 ], %g1
4000a378: 80 a0 60 00 cmp %g1, 0
4000a37c: 02 bf fe 21 be 40009c00 <_IO_Vprintf+0x28>
<== NEVER TAKEN
4000a380: a2 00 7f ff add %g1, -1, %l1
4000a384: c2 0f bf c3 ldub [ %fp + -61 ], %g1
4000a388: a1 28 60 18 sll %g1, 0x18, %l0
4000a38c: ba 10 00 11 mov %l1, %i5
4000a390: a1 3c 20 18 sra %l0, 0x18, %l0
PCHAR(padc);
4000a394: 92 10 00 19 mov %i1, %o1
4000a398: 9f c7 00 00 call %i4
4000a39c: 90 10 00 10 mov %l0, %o0
while (width--)
4000a3a0: ba 07 7f ff add %i5, -1, %i5
4000a3a4: 80 a7 7f ff cmp %i5, -1
4000a3a8: 12 bf ff fc bne 4000a398 <_IO_Vprintf+0x7c0>
4000a3ac: 92 10 00 19 mov %i1, %o1
4000a3b0: a8 05 20 01 inc %l4
4000a3b4: a4 10 20 00 clr %l2
4000a3b8: 10 bf fe 12 b 40009c00 <_IO_Vprintf+0x28>
4000a3bc: a8 04 40 14 add %l1, %l4, %l4
4000a3c0: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
sharpflag = 1;
4000a3c4: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
4000a3c8: c2 27 bf c4 st %g1, [ %fp + -60 ]
<== NOT EXECUTED
goto reswitch;
4000a3cc: 10 bf fe 39 b 40009cb0 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
4000a3d0: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
PCHAR(ch);
4000a3d4: 92 10 00 19 mov %i1, %o1
4000a3d8: 9f c7 00 00 call %i4
4000a3dc: a8 05 60 01 add %l5, 1, %l4
break;
4000a3e0: 10 bf fe 08 b 40009c00 <_IO_Vprintf+0x28>
4000a3e4: a4 10 20 00 clr %l2
4000a3e8: 84 06 e0 04 add %i3, 4, %g2
if (!dot) {
4000a3ec: 80 a2 e0 00 cmp %o3, 0
4000a3f0: 12 80 00 76 bne 4000a5c8 <_IO_Vprintf+0x9f0>
<== ALWAYS TAKEN
4000a3f4: c6 06 c0 00 ld [ %i3 ], %g3
if (width < 0) {
4000a3f8: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
4000a3fc: 06 80 00 af bl 4000a6b8 <_IO_Vprintf+0xae0>
<== NOT EXECUTED
4000a400: c6 27 bf d4 st %g3, [ %fp + -44 ]
<== NOT EXECUTED
4000a404: d8 08 60 01 ldub [ %g1 + 1 ], %o4
dwidth = va_arg(ap, int);
4000a408: b6 10 00 02 mov %g2, %i3
reswitch: switch (ch = (u_char)*fmt++) {
4000a40c: 10 bf fe 29 b 40009cb0 <_IO_Vprintf+0xd8>
4000a410: 82 10 00 1a mov %i2, %g1
4000a414: d8 08 60 01 ldub [ %g1 + 1 ], %o4
ladjust = 1;
4000a418: a4 10 20 01 mov 1, %l2
goto reswitch;
4000a41c: 10 bf fe 25 b 40009cb0 <_IO_Vprintf+0xd8>
4000a420: 82 10 00 1a mov %i2, %g1
while (percent < fmt)
4000a424: a0 10 00 1d mov %i5, %l0
4000a428: a8 10 00 15 mov %l5, %l4
4000a42c: 80 a6 80 1d cmp %i2, %i5
4000a430: 08 bf fd f4 bleu 40009c00 <_IO_Vprintf+0x28>
<== NEVER TAKEN
4000a434: a4 10 20 01 mov 1, %l2
PCHAR(*percent++);
4000a438: a0 04 20 01 inc %l0
4000a43c: d0 4c 3f ff ldsb [ %l0 + -1 ], %o0
4000a440: 9f c7 00 00 call %i4
4000a444: 92 10 00 19 mov %i1, %o1
while (percent < fmt)
4000a448: 80 a6 80 10 cmp %i2, %l0
4000a44c: 32 bf ff fc bne,a 4000a43c <_IO_Vprintf+0x864>
4000a450: a0 04 20 01 inc %l0
4000a454: 84 25 40 1d sub %l5, %i5, %g2
stop = 1;
4000a458: a4 10 20 01 mov 1, %l2
4000a45c: 10 bf fd e9 b 40009c00 <_IO_Vprintf+0x28>
4000a460: a8 06 80 02 add %i2, %g2, %l4
reswitch: switch (ch = (u_char)*fmt++) {
4000a464: 10 bf ff 3a b 4000a14c <_IO_Vprintf+0x574>
4000a468: 82 10 00 1a mov %i2, %g1
static inline int imax(int a, int b) { return (a > b ? a : b); }
4000a46c: c4 07 bf d0 ld [ %fp + -48 ], %g2
4000a470: 80 a0 80 11 cmp %g2, %l1
4000a474: 16 80 00 04 bge 4000a484 <_IO_Vprintf+0x8ac>
4000a478: 86 10 00 02 mov %g2, %g3
4000a47c: 86 10 00 11 mov %l1, %g3
dwidth -= n;
4000a480: c4 07 bf d0 ld [ %fp + -48 ], %g2
4000a484: a2 20 80 11 sub %g2, %l1, %l1
width -= tmp + imax(dwidth, n);
4000a488: c4 07 bf d4 ld [ %fp + -44 ], %g2
4000a48c: 82 00 c0 01 add %g3, %g1, %g1
if (!ladjust)
4000a490: 80 a4 a0 00 cmp %l2, 0
4000a494: 12 bf fe 86 bne 40009eac <_IO_Vprintf+0x2d4>
4000a498: a6 20 80 01 sub %g2, %g1, %l3
while (width-- > 0)
4000a49c: 10 bf fe 78 b 40009e7c <_IO_Vprintf+0x2a4>
4000a4a0: ac 04 ff ff add %l3, -1, %l6
else if (lflag)
4000a4a4: 12 80 00 0c bne 4000a4d4 <_IO_Vprintf+0x8fc>
4000a4a8: 82 06 e0 04 add %i3, 4, %g1
else if (hflag)
4000a4ac: 80 a3 e0 00 cmp %o7, 0
4000a4b0: 02 80 00 48 be 4000a5d0 <_IO_Vprintf+0x9f8>
4000a4b4: 80 a3 60 00 cmp %o5, 0
num = (u_short)va_arg(ap, int);
4000a4b8: c6 16 e0 02 lduh [ %i3 + 2 ], %g3
4000a4bc: 84 10 20 00 clr %g2
4000a4c0: b6 10 00 01 mov %g1, %i3
4000a4c4: 10 bf fe 26 b 40009d5c <_IO_Vprintf+0x184>
4000a4c8: c4 3f bf c8 std %g2, [ %fp + -56 ]
while (width-- > 0)
4000a4cc: 10 bf fd cd b 40009c00 <_IO_Vprintf+0x28>
4000a4d0: a4 10 20 00 clr %l2
num = va_arg(ap, u_int);
4000a4d4: c6 06 c0 00 ld [ %i3 ], %g3
4000a4d8: 84 10 20 00 clr %g2
4000a4dc: b6 10 00 01 mov %g1, %i3
4000a4e0: 10 bf fe 1f b 40009d5c <_IO_Vprintf+0x184>
4000a4e4: c4 3f bf c8 std %g2, [ %fp + -56 ]
4000a4e8: 10 bf fe 77 b 40009ec4 <_IO_Vprintf+0x2ec>
4000a4ec: a8 10 00 15 mov %l5, %l4
else if (tflag)
4000a4f0: 80 a1 20 00 cmp %g4, 0
4000a4f4: 12 80 00 17 bne 4000a550 <_IO_Vprintf+0x978>
4000a4f8: c6 06 c0 00 ld [ %i3 ], %g3
else if (hflag)
4000a4fc: 80 a3 e0 00 cmp %o7, 0
4000a500: 02 80 00 66 be 4000a698 <_IO_Vprintf+0xac0>
<== ALWAYS TAKEN
4000a504: 80 a3 60 00 cmp %o5, 0
num = (short)va_arg(ap, int);
4000a508: 87 28 e0 10 sll %g3, 0x10, %g3
<== NOT EXECUTED
4000a50c: b6 10 00 01 mov %g1, %i3
<== NOT EXECUTED
4000a510: 83 38 e0 10 sra %g3, 0x10, %g1
<== NOT EXECUTED
4000a514: c2 27 bf cc st %g1, [ %fp + -52 ]
<== NOT EXECUTED
4000a518: 83 38 e0 1f sra %g3, 0x1f, %g1
<== NOT EXECUTED
4000a51c: 10 bf fe b0 b 40009fdc <_IO_Vprintf+0x404>
<== NOT EXECUTED
4000a520: c2 27 bf c8 st %g1, [ %fp + -56 ]
<== NOT EXECUTED
} else if (base == 16) {
4000a524: 80 a0 60 10 cmp %g1, 0x10
4000a528: 32 bf fe 73 bne,a 40009ef4 <_IO_Vprintf+0x31c>
<== NEVER TAKEN
4000a52c: 80 a4 60 00 cmp %l1, 0
<== NOT EXECUTED
PCHAR('0');
4000a530: 9f c7 00 00 call %i4
4000a534: 90 10 20 30 mov 0x30, %o0
PCHAR('x');
4000a538: 92 10 00 19 mov %i1, %o1
4000a53c: 90 10 20 78 mov 0x78, %o0
4000a540: 9f c7 00 00 call %i4
4000a544: a8 05 20 02 add %l4, 2, %l4
while (dwidth-- > 0)
4000a548: 10 bf fe 6b b 40009ef4 <_IO_Vprintf+0x31c>
4000a54c: 80 a4 60 00 cmp %l1, 0
num = va_arg(ap, int);
4000a550: b6 10 00 01 mov %g1, %i3
4000a554: c6 27 bf cc st %g3, [ %fp + -52 ]
4000a558: 83 38 e0 1f sra %g3, 0x1f, %g1
4000a55c: 10 bf fe a0 b 40009fdc <_IO_Vprintf+0x404>
4000a560: c2 27 bf c8 st %g1, [ %fp + -56 ]
PCHAR(va_arg(ap, int));
4000a564: d0 06 c0 00 ld [ %i3 ], %o0
4000a568: 9f c7 00 00 call %i4
4000a56c: 92 10 00 19 mov %i1, %o1
if (ladjust && width > 0)
4000a570: 80 8c a0 01 btst 1, %l2
4000a574: 02 80 00 3b be 4000a660 <_IO_Vprintf+0xa88>
<== ALWAYS TAKEN
4000a578: 80 8f 60 ff btst 0xff, %i5
4000a57c: 02 80 00 39 be 4000a660 <_IO_Vprintf+0xa88>
<== NOT EXECUTED
4000a580: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
while (width--)
4000a584: a8 00 7f fe add %g1, -2, %l4
<== NOT EXECUTED
4000a588: c2 0f bf c3 ldub [ %fp + -61 ], %g1
<== NOT EXECUTED
4000a58c: b7 28 60 18 sll %g1, 0x18, %i3
<== NOT EXECUTED
4000a590: ba 10 00 14 mov %l4, %i5
<== NOT EXECUTED
4000a594: b7 3e e0 18 sra %i3, 0x18, %i3
<== NOT EXECUTED
PCHAR(padc);
4000a598: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000a59c: 9f c7 00 00 call %i4
<== NOT EXECUTED
4000a5a0: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
while (width--)
4000a5a4: ba 07 7f ff add %i5, -1, %i5
<== NOT EXECUTED
4000a5a8: 80 a7 7f ff cmp %i5, -1
<== NOT EXECUTED
4000a5ac: 12 bf ff fc bne 4000a59c <_IO_Vprintf+0x9c4>
<== NOT EXECUTED
4000a5b0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000a5b4: 84 05 60 02 add %l5, 2, %g2
<== NOT EXECUTED
PCHAR(va_arg(ap, int));
4000a5b8: b6 10 00 10 mov %l0, %i3
<== NOT EXECUTED
4000a5bc: a8 05 00 02 add %l4, %g2, %l4
<== NOT EXECUTED
while (width--)
4000a5c0: 10 bf fd 90 b 40009c00 <_IO_Vprintf+0x28>
<== NOT EXECUTED
4000a5c4: a4 10 20 00 clr %l2
<== NOT EXECUTED
dwidth = va_arg(ap, int);
4000a5c8: 10 bf ff 8f b 4000a404 <_IO_Vprintf+0x82c>
4000a5cc: c6 27 bf d0 st %g3, [ %fp + -48 ]
else if (cflag)
4000a5d0: 22 bf ff c2 be,a 4000a4d8 <_IO_Vprintf+0x900>
4000a5d4: c6 06 c0 00 ld [ %i3 ], %g3
num = (u_char)va_arg(ap, int);
4000a5d8: c6 0e e0 03 ldub [ %i3 + 3 ], %g3
4000a5dc: 84 10 20 00 clr %g2
4000a5e0: b6 10 00 01 mov %g1, %i3
4000a5e4: 10 bf fd de b 40009d5c <_IO_Vprintf+0x184>
4000a5e8: c4 3f bf c8 std %g2, [ %fp + -56 ]
cflag = 1;
4000a5ec: 9a 10 00 0f mov %o7, %o5
reswitch: switch (ch = (u_char)*fmt++) {
4000a5f0: 82 10 00 1a mov %i2, %g1
hflag = 0;
4000a5f4: 10 bf fd af b 40009cb0 <_IO_Vprintf+0xd8>
4000a5f8: 9e 10 20 00 clr %o7
while (n--)
4000a5fc: 80 a4 60 00 cmp %l1, 0
4000a600: 12 bf ff 4f bne 4000a33c <_IO_Vprintf+0x764>
4000a604: a0 0c 00 01 and %l0, %g1, %l0
4000a608: 10 bf ff 58 b 4000a368 <_IO_Vprintf+0x790>
4000a60c: a8 10 00 15 mov %l5, %l4
for (n = 0; n < dwidth && p[n]; n++)
4000a610: 80 a0 60 00 cmp %g1, 0
4000a614: 04 80 00 06 ble 4000a62c <_IO_Vprintf+0xa54>
<== NEVER TAKEN
4000a618: c4 07 bf d4 ld [ %fp + -44 ], %g2
4000a61c: c2 4f 40 00 ldsb [ %i5 ], %g1
4000a620: 80 a0 60 00 cmp %g1, 0
4000a624: 12 80 00 2d bne 4000a6d8 <_IO_Vprintf+0xb00>
<== ALWAYS TAKEN
4000a628: a2 10 20 00 clr %l1
if (!ladjust && width > 0)
4000a62c: a1 38 a0 1f sra %g2, 0x1f, %l0
<== NOT EXECUTED
4000a630: 82 0c a0 01 and %l2, 1, %g1
<== NOT EXECUTED
4000a634: a0 24 00 02 sub %l0, %g2, %l0
<== NOT EXECUTED
4000a638: 80 8c a0 01 btst 1, %l2
<== NOT EXECUTED
4000a63c: 12 80 00 06 bne 4000a654 <_IO_Vprintf+0xa7c>
<== NOT EXECUTED
4000a640: a1 34 20 1f srl %l0, 0x1f, %l0
<== NOT EXECUTED
4000a644: a8 10 3f ff mov -1, %l4
<== NOT EXECUTED
4000a648: 80 a4 20 00 cmp %l0, 0
<== NOT EXECUTED
4000a64c: 12 bf ff 28 bne 4000a2ec <_IO_Vprintf+0x714>
<== NOT EXECUTED
4000a650: a2 10 20 00 clr %l1
<== NOT EXECUTED
4000a654: a0 0c 00 01 and %l0, %g1, %l0
<== NOT EXECUTED
4000a658: 10 bf ff 44 b 4000a368 <_IO_Vprintf+0x790>
<== NOT EXECUTED
4000a65c: a8 10 00 15 mov %l5, %l4
<== NOT EXECUTED
PCHAR(va_arg(ap, int));
4000a660: b6 10 00 10 mov %l0, %i3
4000a664: 10 bf fd 67 b 40009c00 <_IO_Vprintf+0x28>
4000a668: a4 10 20 00 clr %l2
if (ch < '0' || ch > '9')
4000a66c: 84 00 ff d0 add %g3, -48, %g2
<== NOT EXECUTED
n = n * 10 + ch - '0';
4000a670: 90 02 3f d0 add %o0, -48, %o0
<== NOT EXECUTED
if (ch < '0' || ch > '9')
4000a674: 80 a0 a0 09 cmp %g2, 9
<== NOT EXECUTED
4000a678: 08 bf fe a9 bleu 4000a11c <_IO_Vprintf+0x544>
<== NOT EXECUTED
4000a67c: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
n = n * 10 + ch - '0';
4000a680: d0 27 bf d0 st %o0, [ %fp + -48 ]
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
4000a684: 10 bf fd 8b b 40009cb0 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
4000a688: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
p = "(null)";
4000a68c: 3b 10 00 5d sethi %hi(0x40017400), %i5
4000a690: 10 bf ff 04 b 4000a2a0 <_IO_Vprintf+0x6c8>
4000a694: ba 17 62 98 or %i5, 0x298, %i5 ! 40017698 <_Workspace_Is_unified+0x18>
else if (cflag)
4000a698: 02 bf ff af be 4000a554 <_IO_Vprintf+0x97c>
<== ALWAYS TAKEN
4000a69c: b6 10 00 01 mov %g1, %i3
num = (char)va_arg(ap, int);
4000a6a0: 87 28 e0 18 sll %g3, 0x18, %g3
<== NOT EXECUTED
4000a6a4: 83 38 e0 18 sra %g3, 0x18, %g1
<== NOT EXECUTED
4000a6a8: c2 27 bf cc st %g1, [ %fp + -52 ]
<== NOT EXECUTED
4000a6ac: 83 38 e0 1f sra %g3, 0x1f, %g1
<== NOT EXECUTED
4000a6b0: 10 bf fe 4b b 40009fdc <_IO_Vprintf+0x404>
<== NOT EXECUTED
4000a6b4: c2 27 bf c8 st %g1, [ %fp + -56 ]
<== NOT EXECUTED
4000a6b8: d8 08 60 01 ldub [ %g1 + 1 ], %o4
<== NOT EXECUTED
width = -width;
4000a6bc: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
4000a6c0: 82 20 00 01 neg %g1
<== NOT EXECUTED
4000a6c4: a4 1c a0 01 xor %l2, 1, %l2
<== NOT EXECUTED
4000a6c8: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
width = va_arg(ap, int);
4000a6cc: b6 10 00 02 mov %g2, %i3
<== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
4000a6d0: 10 bf fd 78 b 40009cb0 <_IO_Vprintf+0xd8>
<== NOT EXECUTED
4000a6d4: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
for (n = 0; n < dwidth && p[n]; n++)
4000a6d8: c2 07 bf d0 ld [ %fp + -48 ], %g1
4000a6dc: a2 04 60 01 inc %l1
4000a6e0: 80 a4 40 01 cmp %l1, %g1
4000a6e4: 02 bf fe f6 be 4000a2bc <_IO_Vprintf+0x6e4>
4000a6e8: c2 07 bf d4 ld [ %fp + -44 ], %g1
4000a6ec: c2 4f 40 11 ldsb [ %i5 + %l1 ], %g1
4000a6f0: 80 a0 60 00 cmp %g1, 0
4000a6f4: 22 bf fe f2 be,a 4000a2bc <_IO_Vprintf+0x6e4>
4000a6f8: c2 07 bf d4 ld [ %fp + -44 ], %g1
4000a6fc: 10 bf ff f8 b 4000a6dc <_IO_Vprintf+0xb04>
4000a700: c2 07 bf d0 ld [ %fp + -48 ], %g1
4000a704: ba 10 20 00 clr %i5
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
4000a708: 10 bf fd 95 b 40009d5c <_IO_Vprintf+0x184>
4000a70c: a8 10 20 00 clr %l4
while (n--)
4000a710: a8 10 00 15 mov %l5, %l4
<== NOT EXECUTED
4000a714: 10 bf fd 3b b 40009c00 <_IO_Vprintf+0x28>
<== NOT EXECUTED
4000a718: a4 10 20 00 clr %l2
<== NOT EXECUTED
400098e4 <_Internal_error>:
/* will not return from this routine */
while (true);
}
void _Internal_error( Internal_errors_Core_list core_error )
{
400098e4: 9d e3 bf a0 save %sp, -96, %sp
_Terminate( INTERNAL_ERROR_CORE, core_error );
400098e8: 90 10 20 00 clr %o0
400098ec: 7f ff ff eb call 40009898 <_Terminate>
400098f0: 92 10 00 18 mov %i0, %o1
400098f4: 01 00 00 00 nop
<== NOT EXECUTED
40006494 <_Memory_Fill>:
#include <rtems/score/memory.h>
#include <string.h>
void _Memory_Fill( const Memory_Information *information, int c )
{
40006494: 9d e3 bf a0 save %sp, -96, %sp
Memory_Area *area;
const Memory_Area *end;
area = &information->areas[ 0 ];
40006498: fa 06 20 04 ld [ %i0 + 4 ], %i5
end = &information->areas[ information->count ];
4000649c: c2 06 00 00 ld [ %i0 ], %g1
400064a0: b9 28 60 01 sll %g1, 1, %i4
400064a4: b8 07 00 01 add %i4, %g1, %i4
400064a8: b9 2f 20 02 sll %i4, 2, %i4
400064ac: b8 07 40 1c add %i5, %i4, %i4
while ( area != end ) {
400064b0: 80 a7 40 1c cmp %i5, %i4
400064b4: 02 80 00 0b be 400064e0 <_Memory_Fill+0x4c>
<== NEVER TAKEN
400064b8: 01 00 00 00 nop
memset( _Memory_Get_free_begin( area ), c, _Memory_Get_free_size( area ) );
400064bc: d0 07 60 04 ld [ %i5 + 4 ], %o0
return (uintptr_t) area->end - (uintptr_t) area->free;
400064c0: d4 07 60 08 ld [ %i5 + 8 ], %o2
400064c4: 94 22 80 08 sub %o2, %o0, %o2
400064c8: 40 00 1d 58 call 4000da28 <memset>
400064cc: 92 10 00 19 mov %i1, %o1
++area;
400064d0: ba 07 60 0c add %i5, 0xc, %i5
while ( area != end ) {
400064d4: 80 a7 00 1d cmp %i4, %i5
400064d8: 32 bf ff fa bne,a 400064c0 <_Memory_Fill+0x2c>
<== NEVER TAKEN
400064dc: d0 07 60 04 ld [ %i5 + 4 ], %o0
<== NOT EXECUTED
}
}
400064e0: 81 c7 e0 08 ret
400064e4: 81 e8 00 00 restore
4000c638 <_Objects_Close>:
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
4000c638: c4 02 20 04 ld [ %o0 + 4 ], %g2
<== NOT EXECUTED
4000c63c: c2 12 60 0a lduh [ %o1 + 0xa ], %g1
<== NOT EXECUTED
4000c640: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
4000c644: 82 00 7f fc add %g1, -4, %g1
<== NOT EXECUTED
4000c648: c0 20 80 01 clr [ %g2 + %g1 ]
<== NOT EXECUTED
)
{
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove_u32( information, the_object );
}
4000c64c: 81 c3 e0 08 retl
<== NOT EXECUTED
4000c650: c0 22 60 0c clr [ %o1 + 0xc ]
<== NOT EXECUTED
400097e8 <_Objects_Extend_information>:
#include <string.h> /* for memcpy() */
Objects_Maximum _Objects_Extend_information(
Objects_Information *information
)
{
400097e8: 9d e3 bf 98 save %sp, -104, %sp
_Objects_Allocator_is_owner()
|| !_System_state_Is_up( _System_state_Get() )
);
_Assert( _Objects_Is_auto_extend( information ) );
extend_count = _Objects_Extend_size( information );
400097ec: c6 16 20 12 lduh [ %i0 + 0x12 ], %g3
400097f0: e4 16 20 02 lduh [ %i0 + 2 ], %l2
*/
do_extend = true;
index_base = extend_count;
block = 1;
if ( information->object_blocks == NULL ) {
400097f4: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
new_maximum = (uint32_t) old_maximum + extend_count;
400097f8: 87 28 e0 10 sll %g3, 0x10, %g3
400097fc: e6 06 00 00 ld [ %i0 ], %l3
40009800: b5 30 e0 10 srl %g3, 0x10, %i2
if ( information->object_blocks == NULL ) {
40009804: 80 a0 a0 00 cmp %g2, 0
40009808: 02 80 00 4e be 40009940 <_Objects_Extend_information+0x158>
4000980c: a2 06 80 12 add %i2, %l2, %l1
block_count = 1;
} else {
block_count = old_maximum / extend_count;
40009810: 83 2c e0 10 sll %l3, 0x10, %g1
40009814: 83 30 60 10 srl %g1, 0x10, %g1
40009818: 81 80 20 00 wr %g0, %y
4000981c: 01 00 00 00 nop
40009820: 01 00 00 00 nop
40009824: 01 00 00 00 nop
40009828: b2 70 40 1a udiv %g1, %i2, %i1
for ( ; block < block_count; block++ ) {
4000982c: 80 a6 60 01 cmp %i1, 1
40009830: 08 80 00 78 bleu 40009a10 <_Objects_Extend_information+0x228>
<== NEVER TAKEN
40009834: b8 10 00 1a mov %i2, %i4
if ( information->object_blocks[ block ] == NULL ) {
40009838: c2 00 a0 04 ld [ %g2 + 4 ], %g1
4000983c: 80 a0 60 00 cmp %g1, 0
40009840: 02 80 00 77 be 40009a1c <_Objects_Extend_information+0x234>
40009844: aa 10 20 00 clr %l5
block = 1;
40009848: 10 80 00 06 b 40009860 <_Objects_Extend_information+0x78>
4000984c: ba 10 20 01 mov 1, %i5
if ( information->object_blocks[ block ] == NULL ) {
40009850: c2 00 80 01 ld [ %g2 + %g1 ], %g1
40009854: 80 a0 60 00 cmp %g1, 0
40009858: 02 80 00 08 be 40009878 <_Objects_Extend_information+0x90>
4000985c: aa 10 20 00 clr %l5
for ( ; block < block_count; block++ ) {
40009860: ba 07 60 01 inc %i5
do_extend = false;
break;
} else
index_base += extend_count;
40009864: b8 07 00 1a add %i4, %i2, %i4
for ( ; block < block_count; block++ ) {
40009868: 80 a6 40 1d cmp %i1, %i5
4000986c: 12 bf ff f9 bne 40009850 <_Objects_Extend_information+0x68>
40009870: 83 2f 60 02 sll %i5, 2, %g1
do_extend = true;
40009874: aa 10 20 01 mov 1, %l5
/*
* 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 ) {
40009878: 03 00 00 3f sethi %hi(0xfc00), %g1
4000987c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <_ISR_Stack_size+0xefff>
40009880: 80 a4 40 01 cmp %l1, %g1
40009884: 28 80 00 07 bleu,a 400098a0 <_Objects_Extend_information+0xb8>
40009888: d0 16 20 14 lduh [ %i0 + 0x14 ], %o0
+ local_table_size
+ block_count * sizeof( *inactive_per_block );
object_blocks = _Workspace_Allocate( table_size );
if ( object_blocks == NULL ) {
_Workspace_Free( new_object_block );
return 0;
4000988c: ba 10 20 00 clr %i5
40009890: b1 2f 60 10 sll %i5, 0x10, %i0
the_object = _Addresses_Add_offset( the_object, information->object_size );
}
return block;
}
40009894: b1 36 20 10 srl %i0, 0x10, %i0
40009898: 81 c7 e0 08 ret
4000989c: 81 e8 00 00 restore
object_block_size = extend_count * information->object_size;
400098a0: a1 30 e0 10 srl %g3, 0x10, %l0
new_object_block = _Workspace_Allocate( object_block_size );
400098a4: 40 00 0b 4a call 4000c5cc <_Workspace_Allocate>
400098a8: 90 5a 00 10 smul %o0, %l0, %o0
if ( new_object_block == NULL ) {
400098ac: b6 92 20 00 orcc %o0, 0, %i3
400098b0: 02 bf ff f7 be 4000988c <_Objects_Extend_information+0xa4>
<== NEVER TAKEN
400098b4: 29 3f ff c0 sethi %hi(0xffff0000), %l4
index_end = index_base + extend_count;
400098b8: b4 06 80 1c add %i2, %i4, %i2
if ( do_extend ) {
400098bc: 80 8d 60 ff btst 0xff, %l5
400098c0: 12 80 00 25 bne 40009954 <_Objects_Extend_information+0x16c>
400098c4: a8 0c c0 14 and %l3, %l4, %l4
information->object_blocks[ block ] = new_object_block;
400098c8: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
400098cc: 83 2f 60 02 sll %i5, 2, %g1
information->inactive_per_block[ block ] = information->objects_per_block;
400098d0: c6 16 20 12 lduh [ %i0 + 0x12 ], %g3
information->object_blocks[ block ] = new_object_block;
400098d4: f6 20 80 01 st %i3, [ %g2 + %g1 ]
information->inactive_per_block[ block ] = information->objects_per_block;
400098d8: 83 2f 60 01 sll %i5, 1, %g1
400098dc: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
400098e0: c6 30 80 01 sth %g3, [ %g2 + %g1 ]
for ( index = index_base ; index < index_end ; ++index ) {
400098e4: 80 a7 00 1a cmp %i4, %i2
information->inactive += information->objects_per_block;
400098e8: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
400098ec: c4 16 20 12 lduh [ %i0 + 0x12 ], %g2
400098f0: 82 00 40 02 add %g1, %g2, %g1
for ( index = index_base ; index < index_end ; ++index ) {
400098f4: 1a bf ff e7 bcc 40009890 <_Objects_Extend_information+0xa8>
<== NEVER TAKEN
400098f8: c2 36 20 10 sth %g1, [ %i0 + 0x10 ]
the_object = _Addresses_Add_offset( the_object, information->object_size );
400098fc: c8 16 20 14 lduh [ %i0 + 0x14 ], %g4
40009900: 86 06 20 1c add %i0, 0x1c, %g3
old_last = tail->previous;
40009904: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
| ( ( index + OBJECTS_INDEX_MINIMUM ) << OBJECTS_INDEX_START_BIT );
40009908: b8 07 20 01 inc %i4
the_node->next = tail;
4000990c: c6 26 c0 00 st %g3, [ %i3 ]
40009910: 84 17 00 14 or %i4, %l4, %g2
the_object->id = api_class_and_node
40009914: c4 26 e0 08 st %g2, [ %i3 + 8 ]
for ( index = index_base ; index < index_end ; ++index ) {
40009918: 80 a7 00 1a cmp %i4, %i2
tail->previous = the_node;
4000991c: f6 26 20 20 st %i3, [ %i0 + 0x20 ]
old_last->next = the_node;
40009920: f6 20 40 00 st %i3, [ %g1 ]
the_node->previous = old_last;
40009924: c2 26 e0 04 st %g1, [ %i3 + 4 ]
40009928: 12 bf ff f7 bne 40009904 <_Objects_Extend_information+0x11c>
4000992c: b6 06 c0 04 add %i3, %g4, %i3
40009930: b1 2f 60 10 sll %i5, 0x10, %i0
}
40009934: b1 36 20 10 srl %i0, 0x10, %i0
40009938: 81 c7 e0 08 ret
4000993c: 81 e8 00 00 restore
index_base = extend_count;
40009940: b8 10 00 1a mov %i2, %i4
do_extend = true;
40009944: aa 10 20 01 mov 1, %l5
block = 1;
40009948: ba 10 20 01 mov 1, %i5
block_count = 1;
4000994c: 10 bf ff cb b 40009878 <_Objects_Extend_information+0x90>
40009950: b2 10 20 01 mov 1, %i1
block_count++;
40009954: b2 06 60 01 inc %i1
object_blocks_size = block_count * sizeof( *object_blocks );
40009958: 95 2e 60 02 sll %i1, 2, %o2
local_table_size = new_maximum * sizeof( *local_table );
4000995c: af 2c 60 02 sll %l1, 2, %l7
table_size = object_blocks_size
40009960: d4 27 bf fc st %o2, [ %fp + -4 ]
+ block_count * sizeof( *inactive_per_block );
40009964: b3 2e 60 01 sll %i1, 1, %i1
table_size = object_blocks_size
40009968: 90 06 40 0a add %i1, %o2, %o0
object_blocks = _Workspace_Allocate( table_size );
4000996c: 40 00 0b 18 call 4000c5cc <_Workspace_Allocate>
40009970: 90 02 00 17 add %o0, %l7, %o0
if ( object_blocks == NULL ) {
40009974: ac 92 20 00 orcc %o0, 0, %l6
40009978: 02 80 00 34 be 40009a48 <_Objects_Extend_information+0x260>
4000997c: d4 07 bf fc ld [ %fp + -4 ], %o2
if ( old_maximum > extend_count ) {
40009980: 83 2c e0 10 sll %l3, 0x10, %g1
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
40009984: aa 05 80 0a add %l6, %o2, %l5
40009988: 83 30 60 10 srl %g1, 0x10, %g1
4000998c: 80 a0 40 10 cmp %g1, %l0
40009990: 18 80 00 25 bgu 40009a24 <_Objects_Extend_information+0x23c>
40009994: a6 05 c0 15 add %l7, %l5, %l3
object_blocks[ 0 ] = NULL;
40009998: c0 25 80 00 clr [ %l6 ]
inactive_per_block[ 0 ] = 0;
4000999c: c0 35 c0 15 clrh [ %l7 + %l5 ]
memcpy(
400099a0: 95 2c a0 02 sll %l2, 2, %o2
400099a4: d2 06 20 04 ld [ %i0 + 4 ], %o1
400099a8: 40 00 48 96 call 4001bc00 <memcpy>
400099ac: 90 10 00 15 mov %l5, %o0
for ( index = index_base ; index < index_end ; ++index ) {
400099b0: 80 a7 00 1a cmp %i4, %i2
400099b4: 1a 80 00 0a bcc 400099dc <_Objects_Extend_information+0x1f4>
<== NEVER TAKEN
400099b8: 83 2f 20 02 sll %i4, 2, %g1
400099bc: 85 2e a0 02 sll %i2, 2, %g2
400099c0: 82 00 40 15 add %g1, %l5, %g1
400099c4: 84 00 80 15 add %g2, %l5, %g2
local_table[ index ] = NULL;
400099c8: c0 20 40 00 clr [ %g1 ]
400099cc: 82 00 60 04 add %g1, 4, %g1
for ( index = index_base ; index < index_end ; ++index ) {
400099d0: 80 a0 80 01 cmp %g2, %g1
400099d4: 32 bf ff fe bne,a 400099cc <_Objects_Extend_information+0x1e4>
400099d8: c0 20 40 00 clr [ %g1 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400099dc: 91 d0 20 09 ta 9
old_tables = information->object_blocks;
400099e0: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
| (new_maximum << OBJECTS_INDEX_START_BIT);
400099e4: a2 14 40 14 or %l1, %l4, %l1
information->object_blocks = object_blocks;
400099e8: ec 26 20 28 st %l6, [ %i0 + 0x28 ]
information->inactive_per_block = inactive_per_block;
400099ec: e6 26 20 24 st %l3, [ %i0 + 0x24 ]
information->local_table = local_table;
400099f0: ea 26 20 04 st %l5, [ %i0 + 4 ]
information->maximum_id = api_class_and_node
400099f4: e2 26 00 00 st %l1, [ %i0 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400099f8: 91 d0 20 0a ta 0xa
400099fc: 01 00 00 00 nop
_Workspace_Free( old_tables );
40009a00: 40 00 0a fb call 4000c5ec <_Workspace_Free>
40009a04: 01 00 00 00 nop
40009a08: 10 bf ff b1 b 400098cc <_Objects_Extend_information+0xe4>
40009a0c: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
do_extend = true;
40009a10: aa 10 20 01 mov 1, %l5
<== NOT EXECUTED
block = 1;
40009a14: 10 bf ff 99 b 40009878 <_Objects_Extend_information+0x90>
<== NOT EXECUTED
40009a18: ba 10 20 01 mov 1, %i5
<== NOT EXECUTED
40009a1c: 10 bf ff 97 b 40009878 <_Objects_Extend_information+0x90>
40009a20: ba 10 20 01 mov 1, %i5
memcpy(
40009a24: d2 06 20 28 ld [ %i0 + 0x28 ], %o1
40009a28: 40 00 48 76 call 4001bc00 <memcpy>
40009a2c: 94 02 bf fc add %o2, -4, %o2
memcpy(
40009a30: d2 06 20 24 ld [ %i0 + 0x24 ], %o1
40009a34: 94 06 7f fe add %i1, -2, %o2
40009a38: 40 00 48 72 call 4001bc00 <memcpy>
40009a3c: 90 10 00 13 mov %l3, %o0
40009a40: 10 bf ff d9 b 400099a4 <_Objects_Extend_information+0x1bc>
40009a44: 95 2c a0 02 sll %l2, 2, %o2
_Workspace_Free( new_object_block );
40009a48: 40 00 0a e9 call 4000c5ec <_Workspace_Free>
40009a4c: 90 10 00 1b mov %i3, %o0
return 0;
40009a50: 10 bf ff 90 b 40009890 <_Objects_Extend_information+0xa8>
40009a54: ba 10 20 00 clr %i5
40009b20 <_Objects_Free_objects_block>:
void _Objects_Free_objects_block(
Objects_Information *information,
Objects_Maximum block
)
{
40009b20: 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;
40009b24: f4 16 20 12 lduh [ %i0 + 0x12 ], %i2
return _Chain_Immutable_head( the_chain )->next;
40009b28: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
return &the_chain->Tail.Node;
40009b2c: b8 06 20 1c add %i0, 0x1c, %i4
_Assert( block >= 1 );
_Assert(
block < _Objects_Get_maximum_index( information ) / objects_per_block
);
index_base = block * objects_per_block;
40009b30: 88 5e 40 1a smul %i1, %i2, %g4
index_end = index_base + objects_per_block;
node = _Chain_First( &information->Inactive );
tail = _Chain_Immutable_tail( &information->Inactive );
while ( node != tail ) {
40009b34: 80 a0 80 1c cmp %g2, %i4
40009b38: 02 80 00 17 be 40009b94 <_Objects_Free_objects_block+0x74>
<== NEVER TAKEN
40009b3c: b6 01 00 1a add %g4, %i2, %i3
40009b40: 89 29 20 10 sll %g4, 0x10, %g4
/*
* Get the next node before the node is extracted
*/
node = _Chain_Next( node );
if ( index >= index_base && index < index_end ) {
40009b44: b7 2e e0 10 sll %i3, 0x10, %i3
index = _Objects_Get_index( object->id ) - OBJECTS_INDEX_MINIMUM;
40009b48: 3b 00 00 3f sethi %hi(0xfc00), %i5
40009b4c: 89 31 20 10 srl %g4, 0x10, %g4
40009b50: ba 17 63 ff or %i5, 0x3ff, %i5
if ( index >= index_base && index < index_end ) {
40009b54: b7 36 e0 10 srl %i3, 0x10, %i3
index = _Objects_Get_index( object->id ) - OBJECTS_INDEX_MINIMUM;
40009b58: c2 00 a0 08 ld [ %g2 + 8 ], %g1
40009b5c: 82 08 40 1d and %g1, %i5, %g1
40009b60: 82 00 7f ff add %g1, -1, %g1
if ( index >= index_base && index < index_end ) {
40009b64: 80 a0 40 04 cmp %g1, %g4
40009b68: 0a 80 00 08 bcs 40009b88 <_Objects_Free_objects_block+0x68>
40009b6c: c6 00 80 00 ld [ %g2 ], %g3
40009b70: 80 a6 c0 01 cmp %i3, %g1
40009b74: 08 80 00 06 bleu 40009b8c <_Objects_Free_objects_block+0x6c>
40009b78: 80 a7 00 03 cmp %i4, %g3
previous = the_node->previous;
40009b7c: c2 00 a0 04 ld [ %g2 + 4 ], %g1
next->previous = previous;
40009b80: c2 20 e0 04 st %g1, [ %g3 + 4 ]
previous->next = next;
40009b84: c6 20 40 00 st %g3, [ %g1 ]
while ( node != tail ) {
40009b88: 80 a7 00 03 cmp %i4, %g3
40009b8c: 12 bf ff f3 bne 40009b58 <_Objects_Free_objects_block+0x38>
40009b90: 84 10 00 03 mov %g3, %g2
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
40009b94: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
40009b98: bb 2e 60 02 sll %i1, 2, %i5
40009b9c: 40 00 0a 94 call 4000c5ec <_Workspace_Free>
40009ba0: d0 00 40 1d ld [ %g1 + %i5 ], %o0
information->object_blocks[ block ] = NULL;
40009ba4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
40009ba8: c0 20 40 1d clr [ %g1 + %i5 ]
information->inactive_per_block[ block ] = 0;
40009bac: b3 2e 60 01 sll %i1, 1, %i1
40009bb0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40009bb4: c0 30 40 19 clrh [ %g1 + %i1 ]
information->inactive -= objects_per_block;
40009bb8: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
40009bbc: 82 20 40 1a sub %g1, %i2, %g1
40009bc0: c2 36 20 10 sth %g1, [ %i0 + 0x10 ]
}
40009bc4: 81 c7 e0 08 ret
40009bc8: 81 e8 00 00 restore
40009a58 <_Objects_Free_unlimited>:
old_last = tail->previous;
40009a58: c4 02 20 20 ld [ %o0 + 0x20 ], %g2
return &the_chain->Tail.Node;
40009a5c: 86 02 20 1c add %o0, 0x1c, %g3
the_node->next = tail;
40009a60: c6 22 40 00 st %g3, [ %o1 ]
tail->previous = the_node;
40009a64: d2 22 20 20 st %o1, [ %o0 + 0x20 ]
old_last->next = the_node;
40009a68: d2 20 80 00 st %o1, [ %g2 ]
the_node->previous = old_last;
40009a6c: c4 22 60 04 st %g2, [ %o1 + 4 ]
Objects_Control *the_object
)
{
_Chain_Append_unprotected( &information->Inactive, &the_object->Node );
if ( _Objects_Is_auto_extend( information ) ) {
40009a70: c4 12 20 12 lduh [ %o0 + 0x12 ], %g2
40009a74: 85 28 a0 10 sll %g2, 0x10, %g2
40009a78: 89 30 a0 10 srl %g2, 0x10, %g4
40009a7c: 80 a1 20 00 cmp %g4, 0
40009a80: 02 80 00 1c be 40009af0 <_Objects_Free_unlimited+0x98>
<== NEVER TAKEN
40009a84: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Get_index(
Objects_Id id
)
{
return
(Objects_Maximum)((id >> OBJECTS_INDEX_START_BIT) &
40009a88: c6 02 60 08 ld [ %o1 + 8 ], %g3
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;
40009a8c: 86 00 ff ff add %g3, -1, %g3
if ( block > objects_per_block ) {
40009a90: 87 28 e0 10 sll %g3, 0x10, %g3
40009a94: 87 30 e0 10 srl %g3, 0x10, %g3
40009a98: 80 a0 c0 04 cmp %g3, %g4
40009a9c: 08 80 00 15 bleu 40009af0 <_Objects_Free_unlimited+0x98>
40009aa0: 85 30 a0 11 srl %g2, 0x11, %g2
block /= objects_per_block;
++information->inactive_per_block[ block ];
40009aa4: d8 02 20 24 ld [ %o0 + 0x24 ], %o4
40009aa8: 81 80 20 00 wr %g0, %y
40009aac: 01 00 00 00 nop
40009ab0: 01 00 00 00 nop
40009ab4: 01 00 00 00 nop
40009ab8: 9a 70 c0 04 udiv %g3, %g4, %o5
40009abc: 87 2b 60 01 sll %o5, 1, %g3
40009ac0: da 13 00 03 lduh [ %o4 + %g3 ], %o5
40009ac4: 9a 03 60 01 inc %o5
40009ac8: da 33 00 03 sth %o5, [ %o4 + %g3 ]
inactive = information->inactive;
40009acc: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3
++inactive;
40009ad0: 86 00 e0 01 inc %g3
information->inactive = inactive;
40009ad4: c6 32 20 10 sth %g3, [ %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 ) ) ) {
40009ad8: 84 00 80 04 add %g2, %g4, %g2
40009adc: 87 28 e0 10 sll %g3, 0x10, %g3
40009ae0: 87 30 e0 10 srl %g3, 0x10, %g3
40009ae4: 80 a0 c0 02 cmp %g3, %g2
40009ae8: 14 80 00 04 bg 40009af8 <_Objects_Free_unlimited+0xa0>
40009aec: 01 00 00 00 nop
_Objects_Shrink_information( information );
}
}
}
}
40009af0: 81 c3 e0 08 retl
40009af4: 01 00 00 00 nop
_Objects_Shrink_information( information );
40009af8: 82 13 c0 00 mov %o7, %g1
40009afc: 40 00 00 34 call 40009bcc <_Objects_Shrink_information>
40009b00: 9e 10 40 00 mov %g1, %o7
4000e020 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
4000e020: 9d e3 bf a0 save %sp, -96, %sp
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
4000e024: 80 a6 60 00 cmp %i1, 0
4000e028: 02 80 00 19 be 4000e08c <_Objects_Get_information+0x6c>
4000e02c: 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 );
4000e030: 40 00 00 19 call 4000e094 <_Objects_API_maximum_class>
4000e034: 90 10 00 18 mov %i0, %o0
if ( the_class_api_maximum == 0 )
4000e038: 80 a2 20 00 cmp %o0, 0
4000e03c: 02 80 00 14 be 4000e08c <_Objects_Get_information+0x6c>
4000e040: 80 a2 00 19 cmp %o0, %i1
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
4000e044: 0a 80 00 12 bcs 4000e08c <_Objects_Get_information+0x6c>
4000e048: 03 10 00 5d sethi %hi(0x40017400), %g1
return NULL;
if ( !_Objects_Information_table[ the_api ] )
4000e04c: b1 2e 20 02 sll %i0, 2, %i0
4000e050: 82 10 62 d0 or %g1, 0x2d0, %g1
4000e054: c2 00 40 18 ld [ %g1 + %i0 ], %g1
4000e058: 80 a0 60 00 cmp %g1, 0
4000e05c: 02 80 00 0c be 4000e08c <_Objects_Get_information+0x6c>
<== NEVER TAKEN
4000e060: b3 2e 60 02 sll %i1, 2, %i1
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
4000e064: f0 00 40 19 ld [ %g1 + %i1 ], %i0
if ( !info )
4000e068: 80 a6 20 00 cmp %i0, 0
4000e06c: 02 80 00 08 be 4000e08c <_Objects_Get_information+0x6c>
4000e070: 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 )
4000e074: c2 16 20 02 lduh [ %i0 + 2 ], %g1
4000e078: 80 a0 60 00 cmp %g1, 0
4000e07c: 02 80 00 04 be 4000e08c <_Objects_Get_information+0x6c>
4000e080: 01 00 00 00 nop
return NULL;
#endif
return info;
}
4000e084: 81 c7 e0 08 ret
4000e088: 81 e8 00 00 restore
return NULL;
4000e08c: 81 c7 e0 08 ret
4000e090: 91 e8 20 00 restore %g0, 0, %o0
4000a788 <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
4000a788: 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;
4000a78c: 80 a6 20 00 cmp %i0, 0
4000a790: 12 80 00 04 bne 4000a7a0 <_Objects_Id_to_name+0x18>
4000a794: 01 00 00 00 nop
4000a798: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1
4000a79c: f0 00 60 08 ld [ %g1 + 8 ], %i0
information = _Objects_Get_information_id( tmpId );
4000a7a0: 40 00 00 69 call 4000a944 <_Objects_Get_information_id>
4000a7a4: 90 10 00 18 mov %i0, %o0
if ( !information )
4000a7a8: 80 a2 20 00 cmp %o0, 0
4000a7ac: 02 80 00 13 be 4000a7f8 <_Objects_Id_to_name+0x70>
4000a7b0: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
if ( _Objects_Has_string_name( information ) )
4000a7b4: c2 12 20 16 lduh [ %o0 + 0x16 ], %g1
4000a7b8: 80 a0 60 00 cmp %g1, 0
4000a7bc: 12 80 00 0f bne 4000a7f8 <_Objects_Id_to_name+0x70>
<== NEVER TAKEN
4000a7c0: 94 10 00 08 mov %o0, %o2
return OBJECTS_INVALID_ID;
the_object = _Objects_Get(
4000a7c4: 92 07 bf fc add %fp, -4, %o1
4000a7c8: 40 00 00 65 call 4000a95c <_Objects_Get>
4000a7cc: 90 10 00 18 mov %i0, %o0
tmpId,
&lock_context,
information
);
if ( !the_object )
4000a7d0: 80 a2 20 00 cmp %o0, 0
4000a7d4: 02 80 00 09 be 4000a7f8 <_Objects_Id_to_name+0x70>
4000a7d8: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
*name = the_object->name;
4000a7dc: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4000a7e0: c2 26 40 00 st %g1, [ %i1 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a7e4: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a7e8: 91 d0 20 0a ta 0xa
4000a7ec: 01 00 00 00 nop
_ISR_lock_ISR_enable( &lock_context );
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
4000a7f0: 81 c7 e0 08 ret
4000a7f4: 91 e8 20 00 restore %g0, 0, %o0
return OBJECTS_INVALID_ID;
4000a7f8: 81 c7 e0 08 ret
4000a7fc: 91 e8 20 03 restore %g0, 3, %o0
4000a800 <_Objects_Name_to_string>:
Objects_Name name,
bool is_string,
char *buffer,
size_t buffer_size
)
{
4000a800: 9c 03 bf b0 add %sp, -80, %sp
char lname[ 5 ];
const char *s;
char *d;
size_t i;
if ( is_string ) {
4000a804: 80 a2 60 00 cmp %o1, 0
4000a808: 02 80 00 0b be 4000a834 <_Objects_Name_to_string+0x34>
<== ALWAYS TAKEN
4000a80c: c6 02 00 00 ld [ %o0 ], %g3
}
d = buffer;
i = 1;
if ( s != NULL ) {
4000a810: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
4000a814: 12 80 00 26 bne 4000a8ac <_Objects_Name_to_string+0xac>
<== NOT EXECUTED
4000a818: 82 10 00 03 mov %g3, %g1
<== NOT EXECUTED
while ( *s != '\0' ) {
if ( i < buffer_size ) {
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
4000a81c: 90 10 20 00 clr %o0
++s;
++i;
}
}
if ( buffer_size > 0 ) {
4000a820: 80 a2 e0 00 cmp %o3, 0
4000a824: 32 80 00 02 bne,a 4000a82c <_Objects_Name_to_string+0x2c>
4000a828: c0 2a 80 00 clrb [ %o2 ]
*d = '\0';
}
return i - 1;
}
4000a82c: 81 c3 e0 08 retl
4000a830: 9c 03 a0 50 add %sp, 0x50, %sp
lname[ 0 ] = (name.name_u32 >> 24) & 0xff;
4000a834: 85 30 e0 18 srl %g3, 0x18, %g2
lname[ 2 ] = (name.name_u32 >> 8) & 0xff;
4000a838: 89 30 e0 08 srl %g3, 8, %g4
lname[ 0 ] = (name.name_u32 >> 24) & 0xff;
4000a83c: c4 2b a0 48 stb %g2, [ %sp + 0x48 ]
lname[ 1 ] = (name.name_u32 >> 16) & 0xff;
4000a840: 83 30 e0 10 srl %g3, 0x10, %g1
lname[ 2 ] = (name.name_u32 >> 8) & 0xff;
4000a844: c8 2b a0 4a stb %g4, [ %sp + 0x4a ]
lname[ 3 ] = (name.name_u32 >> 0) & 0xff;
4000a848: c6 2b a0 4b stb %g3, [ %sp + 0x4b ]
lname[ 4 ] = '\0';
4000a84c: c0 2b a0 4c clrb [ %sp + 0x4c ]
lname[ 1 ] = (name.name_u32 >> 16) & 0xff;
4000a850: c2 2b a0 49 stb %g1, [ %sp + 0x49 ]
s = lname;
4000a854: 82 03 a0 48 add %sp, 0x48, %g1
while ( *s != '\0' ) {
4000a858: 87 28 a0 18 sll %g2, 0x18, %g3
4000a85c: 80 a0 e0 00 cmp %g3, 0
4000a860: 02 bf ff ef be 4000a81c <_Objects_Name_to_string+0x1c>
4000a864: 90 10 20 01 mov 1, %o0
if ( i < buffer_size ) {
4000a868: 80 a2 c0 08 cmp %o3, %o0
4000a86c: 08 80 00 09 bleu 4000a890 <_Objects_Name_to_string+0x90>
4000a870: 82 00 60 01 inc %g1
return uc >= ' ' && uc <= '~';
4000a874: 86 00 bf e0 add %g2, -32, %g3
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
4000a878: 86 08 e0 ff and %g3, 0xff, %g3
4000a87c: 80 a0 e0 5e cmp %g3, 0x5e
4000a880: 38 80 00 02 bgu,a 4000a888 <_Objects_Name_to_string+0x88>
4000a884: 84 10 20 2a mov 0x2a, %g2
4000a888: c4 2a 80 00 stb %g2, [ %o2 ]
++d;
4000a88c: 94 02 a0 01 inc %o2
while ( *s != '\0' ) {
4000a890: c6 48 40 00 ldsb [ %g1 ], %g3
++i;
4000a894: 88 02 20 01 add %o0, 1, %g4
while ( *s != '\0' ) {
4000a898: 80 a0 e0 00 cmp %g3, 0
4000a89c: 02 bf ff e1 be 4000a820 <_Objects_Name_to_string+0x20>
4000a8a0: c4 08 40 00 ldub [ %g1 ], %g2
++i;
4000a8a4: 10 bf ff f1 b 4000a868 <_Objects_Name_to_string+0x68>
4000a8a8: 90 10 00 04 mov %g4, %o0
4000a8ac: 10 bf ff eb b 4000a858 <_Objects_Name_to_string+0x58>
<== NOT EXECUTED
4000a8b0: c4 08 c0 00 ldub [ %g3 ], %g2
<== NOT EXECUTED
40006d94 <_Objects_Set_name>:
bool _Objects_Set_name(
const Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
40006d94: 9d e3 bf 98 save %sp, -104, %sp
if ( _Objects_Has_string_name( information ) ) {
40006d98: d2 16 20 16 lduh [ %i0 + 0x16 ], %o1
40006d9c: 80 a2 60 00 cmp %o1, 0
40006da0: 02 80 00 10 be 40006de0 <_Objects_Set_name+0x4c>
40006da4: 03 08 08 08 sethi %hi(0x20202000), %g1
size_t length;
char *dup;
length = strnlen( name, information->name_length );
40006da8: 40 00 23 17 call 4000fa04 <strnlen>
40006dac: 90 10 00 1a mov %i2, %o0
dup = _Workspace_String_duplicate( name, length );
if ( dup == NULL ) {
return false;
40006db0: b0 10 20 00 clr %i0
dup = _Workspace_String_duplicate( name, length );
40006db4: 92 10 00 08 mov %o0, %o1
40006db8: 40 00 09 6b call 40009364 <_Workspace_String_duplicate>
40006dbc: 90 10 00 1a mov %i2, %o0
if ( dup == NULL ) {
40006dc0: 80 a2 20 00 cmp %o0, 0
40006dc4: 22 80 00 05 be,a 40006dd8 <_Objects_Set_name+0x44>
<== ALWAYS TAKEN
40006dc8: b0 0e 20 01 and %i0, 1, %i0
}
the_object->name.name_p = dup;
40006dcc: d0 26 60 0c st %o0, [ %i1 + 0xc ]
<== NOT EXECUTED
the_object->name.name_u32 =
_Objects_Build_name( c[ 0 ], c[ 1 ], c[ 2 ], c[ 3 ] );
}
return true;
40006dd0: b0 10 20 01 mov 1, %i0
<== NOT EXECUTED
}
40006dd4: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
40006dd8: 81 c7 e0 08 ret
40006ddc: 81 e8 00 00 restore
memset( c, ' ', sizeof( c ) );
40006de0: 82 10 60 20 or %g1, 0x20, %g1
c[ i ] = name[ i ];
40006de4: 88 07 bf f8 add %fp, -8, %g4
memset( c, ' ', sizeof( c ) );
40006de8: c2 27 bf f8 st %g1, [ %fp + -8 ]
for ( i = 0; i < 4; ++i ) {
40006dec: 82 10 20 00 clr %g1
if ( name[ i ] == '\0') {
40006df0: c4 4e 80 01 ldsb [ %i2 + %g1 ], %g2
40006df4: 80 a0 a0 00 cmp %g2, 0
40006df8: 02 80 00 07 be 40006e14 <_Objects_Set_name+0x80>
40006dfc: c6 0e 80 01 ldub [ %i2 + %g1 ], %g3
c[ i ] = name[ i ];
40006e00: c6 28 40 04 stb %g3, [ %g1 + %g4 ]
for ( i = 0; i < 4; ++i ) {
40006e04: 82 00 60 01 inc %g1
40006e08: 80 a0 60 04 cmp %g1, 4
40006e0c: 32 bf ff fa bne,a 40006df4 <_Objects_Set_name+0x60>
40006e10: c4 4e 80 01 ldsb [ %i2 + %g1 ], %g2
_Objects_Build_name( c[ 0 ], c[ 1 ], c[ 2 ], c[ 3 ] );
40006e14: c2 4f bf f8 ldsb [ %fp + -8 ], %g1
40006e18: c6 4f bf f9 ldsb [ %fp + -7 ], %g3
40006e1c: c8 4f bf fb ldsb [ %fp + -5 ], %g4
40006e20: c4 4f bf fa ldsb [ %fp + -6 ], %g2
40006e24: 87 28 e0 10 sll %g3, 0x10, %g3
40006e28: 85 28 a0 08 sll %g2, 8, %g2
40006e2c: 83 28 60 18 sll %g1, 0x18, %g1
return true;
40006e30: b0 10 20 01 mov 1, %i0
_Objects_Build_name( c[ 0 ], c[ 1 ], c[ 2 ], c[ 3 ] );
40006e34: 82 10 40 03 or %g1, %g3, %g1
}
40006e38: b0 0e 20 01 and %i0, 1, %i0
_Objects_Build_name( c[ 0 ], c[ 1 ], c[ 2 ], c[ 3 ] );
40006e3c: 82 10 40 04 or %g1, %g4, %g1
40006e40: 82 10 40 02 or %g1, %g2, %g1
the_object->name.name_u32 =
40006e44: c2 26 60 0c st %g1, [ %i1 + 0xc ]
}
40006e48: 81 c7 e0 08 ret
40006e4c: 81 e8 00 00 restore
40009bcc <_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;
40009bcc: c4 12 20 02 lduh [ %o0 + 2 ], %g2
<== NOT EXECUTED
40009bd0: c8 12 20 12 lduh [ %o0 + 0x12 ], %g4
<== NOT EXECUTED
40009bd4: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40009bd8: 01 00 00 00 nop
<== NOT EXECUTED
40009bdc: 01 00 00 00 nop
<== NOT EXECUTED
40009be0: 01 00 00 00 nop
<== NOT EXECUTED
40009be4: 82 70 80 04 udiv %g2, %g4, %g1
<== NOT EXECUTED
for ( block = 1; block < block_count; block++ ) {
40009be8: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
40009bec: 08 80 00 15 bleu 40009c40 <_Objects_Shrink_information+0x74>
<== NOT EXECUTED
40009bf0: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
if ( information->inactive_per_block[ block ] == objects_per_block ) {
40009bf4: c4 02 20 24 ld [ %o0 + 0x24 ], %g2
<== NOT EXECUTED
40009bf8: c2 10 a0 02 lduh [ %g2 + 2 ], %g1
<== NOT EXECUTED
40009bfc: 80 a1 00 01 cmp %g4, %g1
<== NOT EXECUTED
40009c00: 02 80 00 12 be 40009c48 <_Objects_Shrink_information+0x7c>
<== NOT EXECUTED
40009c04: 87 28 e0 10 sll %g3, 0x10, %g3
<== NOT EXECUTED
40009c08: 84 00 a0 04 add %g2, 4, %g2
<== NOT EXECUTED
for ( block = 1; block < block_count; block++ ) {
40009c0c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
40009c10: 10 80 00 06 b 40009c28 <_Objects_Shrink_information+0x5c>
<== NOT EXECUTED
40009c14: 87 30 e0 10 srl %g3, 0x10, %g3
<== NOT EXECUTED
if ( information->inactive_per_block[ block ] == objects_per_block ) {
40009c18: c2 10 bf fe lduh [ %g2 + -2 ], %g1
<== NOT EXECUTED
40009c1c: 80 a0 40 04 cmp %g1, %g4
<== NOT EXECUTED
40009c20: 22 80 00 0c be,a 40009c50 <_Objects_Shrink_information+0x84>
<== NOT EXECUTED
40009c24: 93 2a 60 10 sll %o1, 0x10, %o1
<== NOT EXECUTED
for ( block = 1; block < block_count; block++ ) {
40009c28: 92 02 60 01 inc %o1
<== NOT EXECUTED
40009c2c: 83 2a 60 10 sll %o1, 0x10, %g1
<== NOT EXECUTED
40009c30: 83 30 60 10 srl %g1, 0x10, %g1
<== NOT EXECUTED
40009c34: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
40009c38: 12 bf ff f8 bne 40009c18 <_Objects_Shrink_information+0x4c>
<== NOT EXECUTED
40009c3c: 84 00 a0 02 add %g2, 2, %g2
<== NOT EXECUTED
_Objects_Free_objects_block( information, block );
return;
}
}
}
40009c40: 81 c3 e0 08 retl
<== NOT EXECUTED
40009c44: 01 00 00 00 nop
<== NOT EXECUTED
for ( block = 1; block < block_count; block++ ) {
40009c48: 92 10 20 01 mov 1, %o1 ! 1 <_TLS_Alignment>
<== NOT EXECUTED
_Objects_Free_objects_block( information, block );
40009c4c: 93 2a 60 10 sll %o1, 0x10, %o1
<== NOT EXECUTED
40009c50: 93 32 60 10 srl %o1, 0x10, %o1
<== NOT EXECUTED
40009c54: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40009c58: 7f ff ff b2 call 40009b20 <_Objects_Free_objects_block>
<== NOT EXECUTED
40009c5c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000a910 <_Once>:
.Mutex = RTEMS_MUTEX_INITIALIZER( "_Once" ),
.State = RTEMS_CONDITION_VARIABLE_INITIALIZER( "_Once" )
};
int _Once( unsigned char *once_state, void ( *init_routine )( void ) )
{
4000a910: 9d e3 bf a0 save %sp, -96, %sp
_Atomic_Fence( ATOMIC_ORDER_ACQUIRE );
if ( RTEMS_PREDICT_FALSE( *once_state != ONCE_STATE_COMPLETE ) ) {
4000a914: c2 0e 00 00 ldub [ %i0 ], %g1
4000a918: 80 a0 60 02 cmp %g1, 2
4000a91c: 12 80 00 04 bne 4000a92c <_Once+0x1c>
4000a920: 01 00 00 00 nop
_Once_Unlock( thread_life_state );
}
return 0;
}
4000a924: 81 c7 e0 08 ret
4000a928: 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 );
4000a92c: 7f ff f6 69 call 400082d0 <_Thread_Set_life_protection>
4000a930: 90 10 20 01 mov 1, %o0
mutex->_Queue._name = name;
}
static __inline void rtems_mutex_lock( rtems_mutex *mutex )
{
_Mutex_Acquire( mutex );
4000a934: 39 10 00 68 sethi %hi(0x4001a000), %i4
4000a938: b6 10 00 08 mov %o0, %i3
4000a93c: 7f ff ff 85 call 4000a750 <_Mutex_Acquire>
4000a940: 90 17 23 3c or %i4, 0x33c, %o0
if ( *once_state == ONCE_STATE_INIT ) {
4000a944: c2 0e 00 00 ldub [ %i0 ], %g1
4000a948: 80 a0 60 00 cmp %g1, 0
4000a94c: 02 80 00 12 be 4000a994 <_Once+0x84>
<== ALWAYS TAKEN
4000a950: 80 a0 60 02 cmp %g1, 2
while ( *once_state != ONCE_STATE_COMPLETE ) {
4000a954: 02 80 00 09 be 4000a978 <_Once+0x68>
<== NOT EXECUTED
4000a958: ba 17 23 3c or %i4, 0x33c, %i5
<== NOT EXECUTED
static __inline void rtems_condition_variable_wait(
rtems_condition_variable *condition_variable,
rtems_mutex *mutex
)
{
_Condition_Wait( condition_variable, mutex );
4000a95c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000a960: 40 00 0c 4b call 4000da8c <_Condition_Wait>
<== NOT EXECUTED
4000a964: 90 07 60 14 add %i5, 0x14, %o0
<== NOT EXECUTED
4000a968: c2 0e 00 00 ldub [ %i0 ], %g1
<== NOT EXECUTED
4000a96c: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
4000a970: 12 bf ff fc bne 4000a960 <_Once+0x50>
<== NOT EXECUTED
4000a974: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
_Mutex_Release( mutex );
4000a978: 7f ff ff 92 call 4000a7c0 <_Mutex_Release>
4000a97c: 90 17 23 3c or %i4, 0x33c, %o0
}
void _Once_Unlock( Thread_Life_state thread_life_state )
{
rtems_mutex_unlock( &_Once_Information.Mutex );
_Thread_Set_life_protection( thread_life_state );
4000a980: 90 10 00 1b mov %i3, %o0
4000a984: 7f ff f6 53 call 400082d0 <_Thread_Set_life_protection>
4000a988: b0 10 20 00 clr %i0
}
4000a98c: 81 c7 e0 08 ret
4000a990: 81 e8 00 00 restore
*once_state = ONCE_STATE_RUNNING;
4000a994: 82 10 20 01 mov 1, %g1
4000a998: c2 2e 00 00 stb %g1, [ %i0 ]
4000a99c: 7f ff ff 89 call 4000a7c0 <_Mutex_Release>
4000a9a0: 90 17 23 3c or %i4, 0x33c, %o0
_Thread_Set_life_protection( thread_life_state );
4000a9a4: 7f ff f6 4b call 400082d0 <_Thread_Set_life_protection>
4000a9a8: 90 10 20 01 mov 1, %o0
( *init_routine )();
4000a9ac: 9f c6 40 00 call %i1
4000a9b0: 01 00 00 00 nop
thread_life_state = _Thread_Set_life_protection( THREAD_LIFE_PROTECTED );
4000a9b4: 7f ff f6 47 call 400082d0 <_Thread_Set_life_protection>
4000a9b8: 90 10 20 01 mov 1, %o0 ! 1 <_TLS_Alignment>
_Mutex_Acquire( mutex );
4000a9bc: 7f ff ff 65 call 4000a750 <_Mutex_Acquire>
4000a9c0: 90 17 23 3c or %i4, 0x33c, %o0
*once_state = ONCE_STATE_COMPLETE;
4000a9c4: 82 10 20 02 mov 2, %g1
4000a9c8: c2 2e 00 00 stb %g1, [ %i0 ]
static __inline void rtems_condition_variable_broadcast(
rtems_condition_variable *condition_variable
)
{
_Condition_Broadcast( condition_variable );
4000a9cc: 11 10 00 68 sethi %hi(0x4001a000), %o0
4000a9d0: 40 00 0c 42 call 4000dad8 <_Condition_Broadcast>
4000a9d4: 90 12 23 50 or %o0, 0x350, %o0 ! 4001a350 <_Once_Information+0x14>
4000a9d8: 30 bf ff e8 b,a 4000a978 <_Once+0x68>
4000bb64 <_Once_Lock>:
return 0;
}
Thread_Life_state _Once_Lock( void )
{
4000bb64: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Thread_Life_state thread_life_state;
thread_life_state = _Thread_Set_life_protection( THREAD_LIFE_PROTECTED );
4000bb68: 7f ff f5 c4 call 40009278 <_Thread_Set_life_protection>
<== NOT EXECUTED
4000bb6c: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
4000bb70: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
mutex->_Queue._name = name;
}
static __inline void rtems_mutex_lock( rtems_mutex *mutex )
{
_Mutex_Acquire( mutex );
4000bb74: 11 10 00 4f sethi %hi(0x40013c00), %o0
<== NOT EXECUTED
4000bb78: 7f ff ff 8b call 4000b9a4 <_Mutex_Acquire>
<== NOT EXECUTED
4000bb7c: 90 12 23 c0 or %o0, 0x3c0, %o0 ! 40013fc0 <_Once_Information>
<== NOT EXECUTED
rtems_mutex_lock( &_Once_Information.Mutex );
return thread_life_state;
}
4000bb80: 81 c7 e0 08 ret
<== NOT EXECUTED
4000bb84: 81 e8 00 00 restore
<== NOT EXECUTED
4000bb88 <_Once_Unlock>:
void _Once_Unlock( Thread_Life_state thread_life_state )
{
4000bb88: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
}
static __inline void rtems_mutex_unlock( rtems_mutex *mutex )
{
_Mutex_Release( mutex );
4000bb8c: 11 10 00 4f sethi %hi(0x40013c00), %o0
<== NOT EXECUTED
4000bb90: 7f ff ff a1 call 4000ba14 <_Mutex_Release>
<== NOT EXECUTED
4000bb94: 90 12 23 c0 or %o0, 0x3c0, %o0 ! 40013fc0 <_Once_Information>
<== NOT EXECUTED
rtems_mutex_unlock( &_Once_Information.Mutex );
_Thread_Set_life_protection( thread_life_state );
4000bb98: 7f ff f5 b8 call 40009278 <_Thread_Set_life_protection>
<== NOT EXECUTED
4000bb9c: 81 e8 00 00 restore
<== NOT EXECUTED
40018428 <_Processor_mask_Copy>:
long *dst,
size_t dst_size,
const long *src,
size_t src_size
)
{
40018428: 82 10 00 08 mov %o0, %g1
long inclusive = 0;
long exclusive = 0;
if ( ( dst_size | src_size ) % sizeof( long ) != 0 ) {
4001842c: 84 12 40 0b or %o1, %o3, %g2
40018430: 80 88 a0 03 btst 3, %g2
40018434: 12 80 00 2b bne 400184e0 <_Processor_mask_Copy+0xb8>
40018438: 90 10 20 03 mov 3, %o0
return PROCESSOR_MASK_COPY_INVALID_SIZE;
}
while ( dst_size > 0 && src_size > 0 ) {
4001843c: 80 a2 e0 00 cmp %o3, 0
40018440: 02 80 00 11 be 40018484 <_Processor_mask_Copy+0x5c>
40018444: 86 10 20 00 clr %g3
40018448: 80 a2 60 00 cmp %o1, 0
4001844c: 32 80 00 07 bne,a 40018468 <_Processor_mask_Copy+0x40>
40018450: c4 02 80 00 ld [ %o2 ], %g2
40018454: 30 80 00 0d b,a 40018488 <_Processor_mask_Copy+0x60>
40018458: 80 a2 e0 00 cmp %o3, 0
4001845c: 02 80 00 0b be 40018488 <_Processor_mask_Copy+0x60>
<== ALWAYS TAKEN
40018460: 80 a2 60 00 cmp %o1, 0
long bits = *src;
40018464: c4 02 80 00 ld [ %o2 ], %g2
<== NOT EXECUTED
inclusive |= bits;
*dst = bits;
40018468: c4 20 40 00 st %g2, [ %g1 ]
++dst;
++src;
dst_size -= sizeof( long );
src_size -= sizeof( long );
4001846c: 96 02 ff fc add %o3, -4, %o3
while ( dst_size > 0 && src_size > 0 ) {
40018470: 92 82 7f fc addcc %o1, -4, %o1
inclusive |= bits;
40018474: 86 10 c0 02 or %g3, %g2, %g3
++dst;
40018478: 82 00 60 04 add %g1, 4, %g1
while ( dst_size > 0 && src_size > 0 ) {
4001847c: 12 bf ff f7 bne 40018458 <_Processor_mask_Copy+0x30>
40018480: 94 02 a0 04 add %o2, 4, %o2
}
while ( dst_size > 0 ) {
40018484: 80 a2 60 00 cmp %o1, 0
40018488: 02 80 00 07 be 400184a4 <_Processor_mask_Copy+0x7c>
4001848c: 80 a2 e0 00 cmp %o3, 0
*dst = 0;
40018490: c0 20 40 00 clr [ %g1 ]
while ( dst_size > 0 ) {
40018494: 92 82 7f fc addcc %o1, -4, %o1
40018498: 12 bf ff fe bne 40018490 <_Processor_mask_Copy+0x68>
<== NEVER TAKEN
4001849c: 82 00 60 04 add %g1, 4, %g1
++dst;
dst_size -= sizeof( long );
}
while ( src_size > 0 ) {
400184a0: 80 a2 e0 00 cmp %o3, 0
400184a4: 02 80 00 0e be 400184dc <_Processor_mask_Copy+0xb4>
400184a8: 82 10 20 00 clr %g1
exclusive |= *src;
400184ac: c4 02 80 00 ld [ %o2 ], %g2
400184b0: 82 10 40 02 or %g1, %g2, %g1
while ( src_size > 0 ) {
400184b4: 96 82 ff fc addcc %o3, -4, %o3
400184b8: 12 bf ff fd bne 400184ac <_Processor_mask_Copy+0x84>
<== NEVER TAKEN
400184bc: 94 02 a0 04 add %o2, 4, %o2
++src;
src_size -= sizeof( long );
}
if ( exclusive != 0 ) {
400184c0: 80 a0 60 00 cmp %g1, 0
400184c4: 02 80 00 07 be 400184e0 <_Processor_mask_Copy+0xb8>
400184c8: 90 10 20 00 clr %o0
if ( inclusive != 0 ) {
return PROCESSOR_MASK_COPY_PARTIAL_LOSS;
} else {
return PROCESSOR_MASK_COPY_COMPLETE_LOSS;
400184cc: 80 a0 00 03 cmp %g0, %g3
400184d0: 90 60 3f ff subx %g0, -1, %o0
400184d4: 81 c3 e0 08 retl
400184d8: 90 02 20 01 inc %o0
}
}
return PROCESSOR_MASK_COPY_LOSSLESS;
400184dc: 90 10 20 00 clr %o0
}
400184e0: 81 c3 e0 08 retl
400184e4: 01 00 00 00 nop
4000c724 <_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 )
4000c724: c6 02 40 00 ld [ %o1 ], %g3
4000c728: 80 a0 e0 00 cmp %g3, 0
4000c72c: 02 80 00 d0 be 4000ca6c <_RBTree_Extract+0x348>
4000c730: c4 02 60 04 ld [ %o1 + 4 ], %g2
4000c734: 80 a0 a0 00 cmp %g2, 0
4000c738: 32 80 00 13 bne,a 4000c784 <_RBTree_Extract+0x60>
4000c73c: c2 00 80 00 ld [ %g2 ], %g1
4000c740: c2 02 60 08 ld [ %o1 + 8 ], %g1
4000c744: c8 02 60 0c ld [ %o1 + 0xc ], %g4
4000c748: c2 20 e0 08 st %g1, [ %g3 + 8 ]
4000c74c: 80 a0 60 00 cmp %g1, 0
4000c750: 22 80 00 cf be,a 4000ca8c <_RBTree_Extract+0x368>
4000c754: c6 22 00 00 st %g3, [ %o0 ]
4000c758: c4 00 40 00 ld [ %g1 ], %g2
4000c75c: 80 a2 40 02 cmp %o1, %g2
4000c760: 22 80 00 d3 be,a 4000caac <_RBTree_Extract+0x388>
4000c764: c6 20 40 00 st %g3, [ %g1 ]
4000c768: c6 20 60 04 st %g3, [ %g1 + 4 ]
4000c76c: 80 a1 20 00 cmp %g4, 0
4000c770: 02 80 00 55 be 4000c8c4 <_RBTree_Extract+0x1a0>
4000c774: 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 );
}
4000c778: 81 c3 e0 08 retl
4000c77c: 01 00 00 00 nop
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
4000c780: c2 00 80 00 ld [ %g2 ], %g1
4000c784: 80 a0 60 00 cmp %g1, 0
4000c788: 32 bf ff fe bne,a 4000c780 <_RBTree_Extract+0x5c>
4000c78c: 84 10 00 01 mov %g1, %g2
4000c790: c6 00 a0 04 ld [ %g2 + 4 ], %g3
4000c794: c2 00 a0 08 ld [ %g2 + 8 ], %g1
4000c798: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
4000c79c: 80 a0 e0 00 cmp %g3, 0
4000c7a0: 02 80 00 04 be 4000c7b0 <_RBTree_Extract+0x8c>
4000c7a4: 9a 10 00 01 mov %g1, %o5
4000c7a8: c2 20 e0 08 st %g1, [ %g3 + 8 ]
4000c7ac: da 00 a0 08 ld [ %g2 + 8 ], %o5
4000c7b0: 80 a0 60 00 cmp %g1, 0
4000c7b4: 22 80 00 07 be,a 4000c7d0 <_RBTree_Extract+0xac>
<== NEVER TAKEN
4000c7b8: c6 22 00 00 st %g3, [ %o0 ]
<== NOT EXECUTED
4000c7bc: d8 00 40 00 ld [ %g1 ], %o4
4000c7c0: 80 a0 80 0c cmp %g2, %o4
4000c7c4: 22 80 00 03 be,a 4000c7d0 <_RBTree_Extract+0xac>
4000c7c8: c6 20 40 00 st %g3, [ %g1 ]
4000c7cc: c6 20 60 04 st %g3, [ %g1 + 4 ]
4000c7d0: 80 a2 40 0d cmp %o1, %o5
4000c7d4: 22 80 00 02 be,a 4000c7dc <_RBTree_Extract+0xb8>
4000c7d8: 82 10 00 02 mov %g2, %g1
4000c7dc: da 02 40 00 ld [ %o1 ], %o5
4000c7e0: da 20 80 00 st %o5, [ %g2 ]
4000c7e4: da 02 60 04 ld [ %o1 + 4 ], %o5
4000c7e8: da 20 a0 04 st %o5, [ %g2 + 4 ]
4000c7ec: da 02 60 08 ld [ %o1 + 8 ], %o5
4000c7f0: da 20 a0 08 st %o5, [ %g2 + 8 ]
4000c7f4: da 02 60 0c ld [ %o1 + 0xc ], %o5
4000c7f8: da 20 a0 0c st %o5, [ %g2 + 0xc ]
4000c7fc: da 02 60 08 ld [ %o1 + 8 ], %o5
4000c800: 80 a3 60 00 cmp %o5, 0
4000c804: 22 80 00 07 be,a 4000c820 <_RBTree_Extract+0xfc>
4000c808: c4 22 00 00 st %g2, [ %o0 ]
4000c80c: d8 03 40 00 ld [ %o5 ], %o4
4000c810: 80 a2 40 0c cmp %o1, %o4
4000c814: 22 80 00 03 be,a 4000c820 <_RBTree_Extract+0xfc>
4000c818: c4 23 40 00 st %g2, [ %o5 ]
4000c81c: c4 23 60 04 st %g2, [ %o5 + 4 ]
4000c820: da 02 40 00 ld [ %o1 ], %o5
4000c824: c4 23 60 08 st %g2, [ %o5 + 8 ]
4000c828: da 02 60 04 ld [ %o1 + 4 ], %o5
4000c82c: 80 a3 60 00 cmp %o5, 0
4000c830: 32 80 00 02 bne,a 4000c838 <_RBTree_Extract+0x114>
4000c834: c4 23 60 08 st %g2, [ %o5 + 8 ]
4000c838: 80 a0 60 00 cmp %g1, 0
4000c83c: 02 bf ff cc be 4000c76c <_RBTree_Extract+0x48>
<== NEVER TAKEN
4000c840: 84 10 00 01 mov %g1, %g2
4000c844: c4 00 a0 08 ld [ %g2 + 8 ], %g2
4000c848: 80 a0 a0 00 cmp %g2, 0
4000c84c: 32 bf ff ff bne,a 4000c848 <_RBTree_Extract+0x124>
4000c850: c4 00 a0 08 ld [ %g2 + 8 ], %g2
4000c854: 80 a1 20 00 cmp %g4, 0
4000c858: 12 bf ff c8 bne 4000c778 <_RBTree_Extract+0x54>
4000c85c: 9a 10 20 01 mov 1, %o5
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
4000c860: 10 80 00 1a b 4000c8c8 <_RBTree_Extract+0x1a4>
4000c864: 80 a0 e0 00 cmp %g3, 0
4000c868: 80 a0 e0 01 cmp %g3, 1
4000c86c: 22 80 00 54 be,a 4000c9bc <_RBTree_Extract+0x298>
4000c870: c8 00 a0 04 ld [ %g2 + 4 ], %g4
4000c874: c6 00 80 00 ld [ %g2 ], %g3
4000c878: 80 a0 e0 00 cmp %g3, 0
4000c87c: 22 80 00 07 be,a 4000c898 <_RBTree_Extract+0x174>
4000c880: c8 00 a0 04 ld [ %g2 + 4 ], %g4
4000c884: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
4000c888: 80 a1 20 00 cmp %g4, 0
4000c88c: 32 80 00 98 bne,a 4000caec <_RBTree_Extract+0x3c8>
4000c890: da 00 60 0c ld [ %g1 + 0xc ], %o5
4000c894: c8 00 a0 04 ld [ %g2 + 4 ], %g4
4000c898: 80 a1 20 00 cmp %g4, 0
4000c89c: 22 80 00 07 be,a 4000c8b8 <_RBTree_Extract+0x194>
4000c8a0: da 20 a0 0c st %o5, [ %g2 + 0xc ]
4000c8a4: d8 01 20 0c ld [ %g4 + 0xc ], %o4
4000c8a8: 80 a3 20 00 cmp %o4, 0
4000c8ac: 12 80 00 89 bne 4000cad0 <_RBTree_Extract+0x3ac>
4000c8b0: 80 a0 e0 00 cmp %g3, 0
4000c8b4: da 20 a0 0c st %o5, [ %g2 + 0xc ]
4000c8b8: 86 10 00 01 mov %g1, %g3
4000c8bc: c4 00 60 08 ld [ %g1 + 8 ], %g2
4000c8c0: 82 10 00 02 mov %g2, %g1
4000c8c4: 80 a0 e0 00 cmp %g3, 0
4000c8c8: 22 80 00 07 be,a 4000c8e4 <_RBTree_Extract+0x1c0>
4000c8cc: c4 02 00 00 ld [ %o0 ], %g2
4000c8d0: c4 00 e0 0c ld [ %g3 + 0xc ], %g2
4000c8d4: 80 a0 a0 00 cmp %g2, 0
4000c8d8: 12 80 00 37 bne 4000c9b4 <_RBTree_Extract+0x290>
4000c8dc: 01 00 00 00 nop
4000c8e0: c4 02 00 00 ld [ %o0 ], %g2
4000c8e4: 80 a0 c0 02 cmp %g3, %g2
4000c8e8: 02 80 00 31 be 4000c9ac <_RBTree_Extract+0x288>
4000c8ec: 80 a0 e0 00 cmp %g3, 0
4000c8f0: c4 00 40 00 ld [ %g1 ], %g2
4000c8f4: 80 a0 80 03 cmp %g2, %g3
4000c8f8: 32 bf ff dc bne,a 4000c868 <_RBTree_Extract+0x144>
4000c8fc: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
4000c900: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000c904: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
4000c908: 80 a1 20 01 cmp %g4, 1
4000c90c: 02 80 00 40 be 4000ca0c <_RBTree_Extract+0x2e8>
4000c910: c6 00 80 00 ld [ %g2 ], %g3
4000c914: 80 a0 e0 00 cmp %g3, 0
4000c918: 22 80 00 06 be,a 4000c930 <_RBTree_Extract+0x20c>
4000c91c: c8 00 a0 04 ld [ %g2 + 4 ], %g4
4000c920: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
4000c924: 80 a1 20 00 cmp %g4, 0
4000c928: 12 80 00 ac bne 4000cbd8 <_RBTree_Extract+0x4b4>
4000c92c: c8 00 a0 04 ld [ %g2 + 4 ], %g4
4000c930: 80 a1 20 00 cmp %g4, 0
4000c934: 22 bf ff e1 be,a 4000c8b8 <_RBTree_Extract+0x194>
4000c938: da 20 a0 0c st %o5, [ %g2 + 0xc ]
4000c93c: c6 01 20 0c ld [ %g4 + 0xc ], %g3
4000c940: 80 a0 e0 00 cmp %g3, 0
4000c944: 22 bf ff dd be,a 4000c8b8 <_RBTree_Extract+0x194>
4000c948: da 20 a0 0c st %o5, [ %g2 + 0xc ]
4000c94c: c6 00 60 0c ld [ %g1 + 0xc ], %g3
4000c950: da 00 60 04 ld [ %g1 + 4 ], %o5
4000c954: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
4000c958: c0 20 60 0c clr [ %g1 + 0xc ]
4000c95c: c0 21 20 0c clr [ %g4 + 0xc ]
4000c960: c4 03 40 00 ld [ %o5 ], %g2
4000c964: 80 a0 a0 00 cmp %g2, 0
4000c968: 02 80 00 03 be 4000c974 <_RBTree_Extract+0x250>
4000c96c: c4 20 60 04 st %g2, [ %g1 + 4 ]
4000c970: c2 20 a0 08 st %g1, [ %g2 + 8 ]
4000c974: c4 00 60 08 ld [ %g1 + 8 ], %g2
4000c978: 80 a0 a0 00 cmp %g2, 0
4000c97c: 02 80 00 c1 be 4000cc80 <_RBTree_Extract+0x55c>
4000c980: c4 23 60 08 st %g2, [ %o5 + 8 ]
4000c984: c4 00 60 08 ld [ %g1 + 8 ], %g2
4000c988: c6 00 80 00 ld [ %g2 ], %g3
4000c98c: 80 a0 40 03 cmp %g1, %g3
4000c990: 22 80 00 c1 be,a 4000cc94 <_RBTree_Extract+0x570>
4000c994: da 20 80 00 st %o5, [ %g2 ]
4000c998: da 20 a0 04 st %o5, [ %g2 + 4 ]
4000c99c: c6 02 00 00 ld [ %o0 ], %g3
4000c9a0: c2 23 40 00 st %g1, [ %o5 ]
4000c9a4: da 20 60 08 st %o5, [ %g1 + 8 ]
4000c9a8: 80 a0 e0 00 cmp %g3, 0
4000c9ac: 02 bf ff 73 be 4000c778 <_RBTree_Extract+0x54>
4000c9b0: 01 00 00 00 nop
}
4000c9b4: 81 c3 e0 08 retl
4000c9b8: c0 20 e0 0c clr [ %g3 + 0xc ]
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
4000c9bc: c0 20 a0 0c clr [ %g2 + 0xc ]
4000c9c0: 80 a1 20 00 cmp %g4, 0
4000c9c4: c6 20 60 0c st %g3, [ %g1 + 0xc ]
4000c9c8: 02 80 00 03 be 4000c9d4 <_RBTree_Extract+0x2b0>
<== NEVER TAKEN
4000c9cc: c8 20 40 00 st %g4, [ %g1 ]
4000c9d0: c2 21 20 08 st %g1, [ %g4 + 8 ]
4000c9d4: c6 00 60 08 ld [ %g1 + 8 ], %g3
4000c9d8: 80 a0 e0 00 cmp %g3, 0
4000c9dc: 02 80 00 22 be 4000ca64 <_RBTree_Extract+0x340>
4000c9e0: c6 20 a0 08 st %g3, [ %g2 + 8 ]
4000c9e4: c6 00 60 08 ld [ %g1 + 8 ], %g3
4000c9e8: d8 00 c0 00 ld [ %g3 ], %o4
4000c9ec: 80 a0 40 0c cmp %g1, %o4
4000c9f0: 22 80 00 25 be,a 4000ca84 <_RBTree_Extract+0x360>
4000c9f4: c4 20 c0 00 st %g2, [ %g3 ]
4000c9f8: c4 20 e0 04 st %g2, [ %g3 + 4 ]
4000c9fc: c2 20 a0 04 st %g1, [ %g2 + 4 ]
4000ca00: c4 20 60 08 st %g2, [ %g1 + 8 ]
4000ca04: 10 bf ff 9c b 4000c874 <_RBTree_Extract+0x150>
4000ca08: 84 10 00 04 mov %g4, %g2
4000ca0c: c0 20 a0 0c clr [ %g2 + 0xc ]
4000ca10: 80 a0 e0 00 cmp %g3, 0
4000ca14: c8 20 60 0c st %g4, [ %g1 + 0xc ]
4000ca18: 02 80 00 03 be 4000ca24 <_RBTree_Extract+0x300>
<== NEVER TAKEN
4000ca1c: c6 20 60 04 st %g3, [ %g1 + 4 ]
4000ca20: c2 20 e0 08 st %g1, [ %g3 + 8 ]
4000ca24: c8 00 60 08 ld [ %g1 + 8 ], %g4
4000ca28: 80 a1 20 00 cmp %g4, 0
4000ca2c: 02 80 00 1d be 4000caa0 <_RBTree_Extract+0x37c>
4000ca30: c8 20 a0 08 st %g4, [ %g2 + 8 ]
4000ca34: c8 00 60 08 ld [ %g1 + 8 ], %g4
4000ca38: d8 01 00 00 ld [ %g4 ], %o4
4000ca3c: 80 a0 40 0c cmp %g1, %o4
4000ca40: 22 80 00 22 be,a 4000cac8 <_RBTree_Extract+0x3a4>
4000ca44: c4 21 00 00 st %g2, [ %g4 ]
4000ca48: c4 21 20 04 st %g2, [ %g4 + 4 ]
4000ca4c: c8 00 60 04 ld [ %g1 + 4 ], %g4
4000ca50: c2 20 80 00 st %g1, [ %g2 ]
4000ca54: c6 01 00 00 ld [ %g4 ], %g3
4000ca58: c4 20 60 08 st %g2, [ %g1 + 8 ]
4000ca5c: 10 bf ff ae b 4000c914 <_RBTree_Extract+0x1f0>
4000ca60: 84 10 00 04 mov %g4, %g2
4000ca64: 10 bf ff e6 b 4000c9fc <_RBTree_Extract+0x2d8>
4000ca68: c4 22 00 00 st %g2, [ %o0 ]
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
4000ca6c: c2 02 60 08 ld [ %o1 + 8 ], %g1
4000ca70: 80 a0 a0 00 cmp %g2, 0
4000ca74: 02 bf ff 36 be 4000c74c <_RBTree_Extract+0x28>
4000ca78: c8 02 60 0c ld [ %o1 + 0xc ], %g4
4000ca7c: 10 bf ff 33 b 4000c748 <_RBTree_Extract+0x24>
4000ca80: 86 10 00 02 mov %g2, %g3
4000ca84: 10 bf ff de b 4000c9fc <_RBTree_Extract+0x2d8>
4000ca88: c8 00 40 00 ld [ %g1 ], %g4
4000ca8c: 80 a1 20 00 cmp %g4, 0
4000ca90: 12 bf ff 3a bne 4000c778 <_RBTree_Extract+0x54>
<== NEVER TAKEN
4000ca94: 9a 10 20 01 mov 1, %o5
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
4000ca98: 10 bf ff 8c b 4000c8c8 <_RBTree_Extract+0x1a4>
4000ca9c: 80 a0 e0 00 cmp %g3, 0
4000caa0: c4 22 00 00 st %g2, [ %o0 ]
4000caa4: 10 bf ff eb b 4000ca50 <_RBTree_Extract+0x32c>
4000caa8: 88 10 00 03 mov %g3, %g4
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
4000caac: 80 a1 20 00 cmp %g4, 0
4000cab0: 12 bf ff 32 bne 4000c778 <_RBTree_Extract+0x54>
4000cab4: 9a 10 20 01 mov 1, %o5
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
4000cab8: 10 bf ff 84 b 4000c8c8 <_RBTree_Extract+0x1a4>
4000cabc: 80 a0 e0 00 cmp %g3, 0
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
4000cac0: 10 bf ff 58 b 4000c820 <_RBTree_Extract+0xfc>
<== NOT EXECUTED
4000cac4: c4 23 40 00 st %g2, [ %o5 ]
<== NOT EXECUTED
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
4000cac8: 10 bf ff e2 b 4000ca50 <_RBTree_Extract+0x32c>
4000cacc: 88 10 00 03 mov %g3, %g4
4000cad0: 22 80 00 21 be,a 4000cb54 <_RBTree_Extract+0x430>
4000cad4: c6 01 00 00 ld [ %g4 ], %g3
4000cad8: da 00 e0 0c ld [ %g3 + 0xc ], %o5
4000cadc: 80 a3 60 00 cmp %o5, 0
4000cae0: 22 80 00 1d be,a 4000cb54 <_RBTree_Extract+0x430>
<== ALWAYS TAKEN
4000cae4: c6 01 00 00 ld [ %g4 ], %g3
4000cae8: da 00 60 0c ld [ %g1 + 0xc ], %o5
<== NOT EXECUTED
4000caec: c8 00 40 00 ld [ %g1 ], %g4
4000caf0: da 20 a0 0c st %o5, [ %g2 + 0xc ]
4000caf4: c0 20 60 0c clr [ %g1 + 0xc ]
4000caf8: c0 20 e0 0c clr [ %g3 + 0xc ]
4000cafc: c4 01 20 04 ld [ %g4 + 4 ], %g2
4000cb00: 80 a0 a0 00 cmp %g2, 0
4000cb04: 02 80 00 03 be 4000cb10 <_RBTree_Extract+0x3ec>
4000cb08: c4 20 40 00 st %g2, [ %g1 ]
4000cb0c: c2 20 a0 08 st %g1, [ %g2 + 8 ]
4000cb10: c4 00 60 08 ld [ %g1 + 8 ], %g2
4000cb14: 80 a0 a0 00 cmp %g2, 0
4000cb18: 02 80 00 2b be 4000cbc4 <_RBTree_Extract+0x4a0>
4000cb1c: c4 21 20 08 st %g2, [ %g4 + 8 ]
4000cb20: c4 00 60 08 ld [ %g1 + 8 ], %g2
4000cb24: c6 00 80 00 ld [ %g2 ], %g3
4000cb28: 80 a0 40 03 cmp %g1, %g3
4000cb2c: 22 80 00 4f be,a 4000cc68 <_RBTree_Extract+0x544>
4000cb30: c8 20 80 00 st %g4, [ %g2 ]
4000cb34: c8 20 a0 04 st %g4, [ %g2 + 4 ]
4000cb38: c6 02 00 00 ld [ %o0 ], %g3
4000cb3c: c2 21 20 04 st %g1, [ %g4 + 4 ]
4000cb40: c8 20 60 08 st %g4, [ %g1 + 8 ]
4000cb44: 80 a0 e0 00 cmp %g3, 0
4000cb48: 12 bf ff 9b bne 4000c9b4 <_RBTree_Extract+0x290>
<== ALWAYS TAKEN
4000cb4c: 01 00 00 00 nop
4000cb50: 30 bf ff 0a b,a 4000c778 <_RBTree_Extract+0x54>
<== NOT EXECUTED
4000cb54: c0 21 20 0c clr [ %g4 + 0xc ]
4000cb58: 9a 10 20 01 mov 1, %o5
4000cb5c: c6 20 a0 04 st %g3, [ %g2 + 4 ]
4000cb60: 80 a0 e0 00 cmp %g3, 0
4000cb64: 02 80 00 03 be 4000cb70 <_RBTree_Extract+0x44c>
4000cb68: da 20 a0 0c st %o5, [ %g2 + 0xc ]
4000cb6c: c4 20 e0 08 st %g2, [ %g3 + 8 ]
4000cb70: c6 00 a0 08 ld [ %g2 + 8 ], %g3
4000cb74: 80 a0 e0 00 cmp %g3, 0
4000cb78: 02 80 00 40 be 4000cc78 <_RBTree_Extract+0x554>
<== NEVER TAKEN
4000cb7c: c6 21 20 08 st %g3, [ %g4 + 8 ]
4000cb80: c6 00 a0 08 ld [ %g2 + 8 ], %g3
4000cb84: da 00 c0 00 ld [ %g3 ], %o5
4000cb88: 80 a0 80 0d cmp %g2, %o5
4000cb8c: 22 80 00 03 be,a 4000cb98 <_RBTree_Extract+0x474>
<== ALWAYS TAKEN
4000cb90: c8 20 c0 00 st %g4, [ %g3 ]
4000cb94: c8 20 e0 04 st %g4, [ %g3 + 4 ]
<== NOT EXECUTED
4000cb98: c4 21 00 00 st %g2, [ %g4 ]
4000cb9c: c8 20 a0 08 st %g4, [ %g2 + 8 ]
4000cba0: c8 00 40 00 ld [ %g1 ], %g4
4000cba4: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000cba8: c4 21 20 0c st %g2, [ %g4 + 0xc ]
4000cbac: c6 01 00 00 ld [ %g4 ], %g3
4000cbb0: 80 a0 e0 00 cmp %g3, 0
4000cbb4: 02 bf ff d2 be 4000cafc <_RBTree_Extract+0x3d8>
<== NEVER TAKEN
4000cbb8: c0 20 60 0c clr [ %g1 + 0xc ]
4000cbbc: 10 bf ff d0 b 4000cafc <_RBTree_Extract+0x3d8>
4000cbc0: c0 20 e0 0c clr [ %g3 + 0xc ]
4000cbc4: c8 22 00 00 st %g4, [ %o0 ]
4000cbc8: 86 10 00 04 mov %g4, %g3
4000cbcc: c2 21 20 04 st %g1, [ %g4 + 4 ]
4000cbd0: 10 bf ff dd b 4000cb44 <_RBTree_Extract+0x420>
4000cbd4: c8 20 60 08 st %g4, [ %g1 + 8 ]
4000cbd8: 80 a1 20 00 cmp %g4, 0
4000cbdc: 22 80 00 07 be,a 4000cbf8 <_RBTree_Extract+0x4d4>
4000cbe0: c8 00 e0 04 ld [ %g3 + 4 ], %g4
4000cbe4: da 01 20 0c ld [ %g4 + 0xc ], %o5
4000cbe8: 80 a3 60 00 cmp %o5, 0
4000cbec: 32 bf ff 59 bne,a 4000c950 <_RBTree_Extract+0x22c>
4000cbf0: c6 00 60 0c ld [ %g1 + 0xc ], %g3
4000cbf4: c8 00 e0 04 ld [ %g3 + 4 ], %g4
4000cbf8: c0 20 e0 0c clr [ %g3 + 0xc ]
4000cbfc: 9a 10 20 01 mov 1, %o5
4000cc00: c8 20 80 00 st %g4, [ %g2 ]
4000cc04: 80 a1 20 00 cmp %g4, 0
4000cc08: 02 80 00 03 be 4000cc14 <_RBTree_Extract+0x4f0>
4000cc0c: da 20 a0 0c st %o5, [ %g2 + 0xc ]
4000cc10: c4 21 20 08 st %g2, [ %g4 + 8 ]
4000cc14: c8 00 a0 08 ld [ %g2 + 8 ], %g4
4000cc18: 80 a1 20 00 cmp %g4, 0
4000cc1c: 02 80 00 22 be 4000cca4 <_RBTree_Extract+0x580>
<== NEVER TAKEN
4000cc20: c8 20 e0 08 st %g4, [ %g3 + 8 ]
4000cc24: c8 00 a0 08 ld [ %g2 + 8 ], %g4
4000cc28: da 01 00 00 ld [ %g4 ], %o5
4000cc2c: 80 a0 80 0d cmp %g2, %o5
4000cc30: 22 80 00 03 be,a 4000cc3c <_RBTree_Extract+0x518>
<== NEVER TAKEN
4000cc34: c6 21 00 00 st %g3, [ %g4 ]
<== NOT EXECUTED
4000cc38: c6 21 20 04 st %g3, [ %g4 + 4 ]
4000cc3c: c4 20 e0 04 st %g2, [ %g3 + 4 ]
4000cc40: c6 20 a0 08 st %g3, [ %g2 + 8 ]
4000cc44: da 00 60 04 ld [ %g1 + 4 ], %o5
4000cc48: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000cc4c: c4 23 60 0c st %g2, [ %o5 + 0xc ]
4000cc50: c8 03 60 04 ld [ %o5 + 4 ], %g4
4000cc54: 80 a1 20 00 cmp %g4, 0
4000cc58: 02 bf ff 42 be 4000c960 <_RBTree_Extract+0x23c>
<== NEVER TAKEN
4000cc5c: c0 20 60 0c clr [ %g1 + 0xc ]
4000cc60: 10 bf ff 40 b 4000c960 <_RBTree_Extract+0x23c>
4000cc64: c0 21 20 0c clr [ %g4 + 0xc ]
4000cc68: c6 02 00 00 ld [ %o0 ], %g3
4000cc6c: c2 21 20 04 st %g1, [ %g4 + 4 ]
4000cc70: 10 bf ff b5 b 4000cb44 <_RBTree_Extract+0x420>
4000cc74: c8 20 60 08 st %g4, [ %g1 + 8 ]
4000cc78: 10 bf ff c8 b 4000cb98 <_RBTree_Extract+0x474>
<== NOT EXECUTED
4000cc7c: c8 22 00 00 st %g4, [ %o0 ]
<== NOT EXECUTED
4000cc80: da 22 00 00 st %o5, [ %o0 ]
4000cc84: 86 10 00 0d mov %o5, %g3
4000cc88: c2 23 40 00 st %g1, [ %o5 ]
4000cc8c: 10 bf ff 47 b 4000c9a8 <_RBTree_Extract+0x284>
4000cc90: da 20 60 08 st %o5, [ %g1 + 8 ]
4000cc94: c6 02 00 00 ld [ %o0 ], %g3
4000cc98: c2 23 40 00 st %g1, [ %o5 ]
4000cc9c: 10 bf ff 43 b 4000c9a8 <_RBTree_Extract+0x284>
4000cca0: da 20 60 08 st %o5, [ %g1 + 8 ]
4000cca4: 10 bf ff e6 b 4000cc3c <_RBTree_Extract+0x518>
<== NOT EXECUTED
4000cca8: c6 22 00 00 st %g3, [ %o0 ]
<== NOT EXECUTED
4000ccac <_RBTree_Insert_color>:
#include "config.h"
#endif
#include <rtems/score/rbtreeimpl.h>
RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline )
4000ccac: 98 10 20 01 mov 1, %o4
4000ccb0: c2 02 60 08 ld [ %o1 + 8 ], %g1
4000ccb4: 80 a0 60 00 cmp %g1, 0
4000ccb8: 22 80 00 2f be,a 4000cd74 <_RBTree_Insert_color+0xc8>
4000ccbc: c2 02 00 00 ld [ %o0 ], %g1
4000ccc0: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000ccc4: 80 a0 a0 01 cmp %g2, 1
4000ccc8: 32 80 00 2b bne,a 4000cd74 <_RBTree_Insert_color+0xc8>
4000cccc: c2 02 00 00 ld [ %o0 ], %g1
4000ccd0: c6 00 60 08 ld [ %g1 + 8 ], %g3
4000ccd4: c8 00 c0 00 ld [ %g3 ], %g4
4000ccd8: 80 a0 40 04 cmp %g1, %g4
4000ccdc: 02 80 00 28 be 4000cd7c <_RBTree_Insert_color+0xd0>
4000cce0: 84 10 00 03 mov %g3, %g2
4000cce4: 80 a1 20 00 cmp %g4, 0
4000cce8: 22 80 00 07 be,a 4000cd04 <_RBTree_Insert_color+0x58>
4000ccec: c8 00 40 00 ld [ %g1 ], %g4
4000ccf0: da 01 20 0c ld [ %g4 + 0xc ], %o5
4000ccf4: 80 a3 60 01 cmp %o5, 1
4000ccf8: 22 80 00 58 be,a 4000ce58 <_RBTree_Insert_color+0x1ac>
4000ccfc: c0 21 20 0c clr [ %g4 + 0xc ]
4000cd00: c8 00 40 00 ld [ %g1 ], %g4
4000cd04: 80 a2 40 04 cmp %o1, %g4
4000cd08: 22 80 00 3c be,a 4000cdf8 <_RBTree_Insert_color+0x14c>
4000cd0c: c8 02 60 04 ld [ %o1 + 4 ], %g4
4000cd10: c6 00 a0 04 ld [ %g2 + 4 ], %g3
4000cd14: c0 20 60 0c clr [ %g1 + 0xc ]
4000cd18: c2 00 c0 00 ld [ %g3 ], %g1
4000cd1c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
4000cd20: 80 a0 60 00 cmp %g1, 0
4000cd24: 02 80 00 03 be 4000cd30 <_RBTree_Insert_color+0x84>
4000cd28: d8 20 a0 0c st %o4, [ %g2 + 0xc ]
4000cd2c: c4 20 60 08 st %g2, [ %g1 + 8 ]
4000cd30: c2 00 a0 08 ld [ %g2 + 8 ], %g1
4000cd34: 80 a0 60 00 cmp %g1, 0
4000cd38: 02 80 00 44 be 4000ce48 <_RBTree_Insert_color+0x19c>
4000cd3c: c2 20 e0 08 st %g1, [ %g3 + 8 ]
4000cd40: c2 00 a0 08 ld [ %g2 + 8 ], %g1
4000cd44: c8 00 40 00 ld [ %g1 ], %g4
4000cd48: 80 a0 80 04 cmp %g2, %g4
4000cd4c: 22 80 00 47 be,a 4000ce68 <_RBTree_Insert_color+0x1bc>
4000cd50: c6 20 40 00 st %g3, [ %g1 ]
4000cd54: c6 20 60 04 st %g3, [ %g1 + 4 ]
4000cd58: c4 20 c0 00 st %g2, [ %g3 ]
4000cd5c: c6 20 a0 08 st %g3, [ %g2 + 8 ]
4000cd60: c2 02 60 08 ld [ %o1 + 8 ], %g1
4000cd64: 80 a0 60 00 cmp %g1, 0
4000cd68: 32 bf ff d7 bne,a 4000ccc4 <_RBTree_Insert_color+0x18>
<== ALWAYS TAKEN
4000cd6c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000cd70: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Control_RB_INSERT_COLOR( the_rbtree, the_node );
}
4000cd74: 81 c3 e0 08 retl
4000cd78: c0 20 60 0c clr [ %g1 + 0xc ]
RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline )
4000cd7c: c8 00 e0 04 ld [ %g3 + 4 ], %g4
4000cd80: 80 a1 20 00 cmp %g4, 0
4000cd84: 22 80 00 07 be,a 4000cda0 <_RBTree_Insert_color+0xf4>
4000cd88: da 00 60 04 ld [ %g1 + 4 ], %o5
4000cd8c: da 01 20 0c ld [ %g4 + 0xc ], %o5
4000cd90: 80 a3 60 01 cmp %o5, 1
4000cd94: 22 80 00 31 be,a 4000ce58 <_RBTree_Insert_color+0x1ac>
4000cd98: c0 21 20 0c clr [ %g4 + 0xc ]
4000cd9c: da 00 60 04 ld [ %g1 + 4 ], %o5
4000cda0: 80 a3 40 09 cmp %o5, %o1
4000cda4: 02 80 00 3a be 4000ce8c <_RBTree_Insert_color+0x1e0>
4000cda8: 88 10 00 01 mov %g1, %g4
4000cdac: c0 20 60 0c clr [ %g1 + 0xc ]
4000cdb0: 80 a3 60 00 cmp %o5, 0
4000cdb4: d8 20 a0 0c st %o4, [ %g2 + 0xc ]
4000cdb8: 02 80 00 03 be 4000cdc4 <_RBTree_Insert_color+0x118>
4000cdbc: da 20 80 00 st %o5, [ %g2 ]
4000cdc0: c4 23 60 08 st %g2, [ %o5 + 8 ]
4000cdc4: c2 00 a0 08 ld [ %g2 + 8 ], %g1
4000cdc8: 80 a0 60 00 cmp %g1, 0
4000cdcc: 02 80 00 2c be 4000ce7c <_RBTree_Insert_color+0x1d0>
4000cdd0: c2 21 20 08 st %g1, [ %g4 + 8 ]
4000cdd4: c2 00 a0 08 ld [ %g2 + 8 ], %g1
4000cdd8: c6 00 40 00 ld [ %g1 ], %g3
4000cddc: 80 a0 80 03 cmp %g2, %g3
4000cde0: 22 80 00 4a be,a 4000cf08 <_RBTree_Insert_color+0x25c>
4000cde4: c8 20 40 00 st %g4, [ %g1 ]
4000cde8: c8 20 60 04 st %g4, [ %g1 + 4 ]
4000cdec: c4 21 20 04 st %g2, [ %g4 + 4 ]
4000cdf0: 10 bf ff b0 b 4000ccb0 <_RBTree_Insert_color+0x4>
4000cdf4: c8 20 a0 08 st %g4, [ %g2 + 8 ]
4000cdf8: 80 a1 20 00 cmp %g4, 0
4000cdfc: 02 80 00 3b be 4000cee8 <_RBTree_Insert_color+0x23c>
4000ce00: c8 20 40 00 st %g4, [ %g1 ]
4000ce04: c2 21 20 08 st %g1, [ %g4 + 8 ]
4000ce08: c6 00 60 08 ld [ %g1 + 8 ], %g3
4000ce0c: 80 a0 e0 00 cmp %g3, 0
4000ce10: 02 80 00 19 be 4000ce74 <_RBTree_Insert_color+0x1c8>
<== NEVER TAKEN
4000ce14: c6 22 60 08 st %g3, [ %o1 + 8 ]
4000ce18: c6 00 60 08 ld [ %g1 + 8 ], %g3
4000ce1c: c8 00 c0 00 ld [ %g3 ], %g4
4000ce20: 80 a0 40 04 cmp %g1, %g4
4000ce24: 22 80 00 03 be,a 4000ce30 <_RBTree_Insert_color+0x184>
<== NEVER TAKEN
4000ce28: d2 20 c0 00 st %o1, [ %g3 ]
<== NOT EXECUTED
4000ce2c: d2 20 e0 04 st %o1, [ %g3 + 4 ]
4000ce30: 86 10 00 09 mov %o1, %g3
4000ce34: c2 22 60 04 st %g1, [ %o1 + 4 ]
4000ce38: d2 20 60 08 st %o1, [ %g1 + 8 ]
4000ce3c: 92 10 00 01 mov %g1, %o1
4000ce40: 10 bf ff b4 b 4000cd10 <_RBTree_Insert_color+0x64>
4000ce44: 82 10 00 03 mov %g3, %g1
4000ce48: c6 22 00 00 st %g3, [ %o0 ]
4000ce4c: c4 20 c0 00 st %g2, [ %g3 ]
4000ce50: 10 bf ff c4 b 4000cd60 <_RBTree_Insert_color+0xb4>
4000ce54: c6 20 a0 08 st %g3, [ %g2 + 8 ]
4000ce58: 92 10 00 03 mov %g3, %o1
4000ce5c: c0 20 60 0c clr [ %g1 + 0xc ]
4000ce60: 10 bf ff 94 b 4000ccb0 <_RBTree_Insert_color+0x4>
4000ce64: da 20 e0 0c st %o5, [ %g3 + 0xc ]
4000ce68: c4 20 c0 00 st %g2, [ %g3 ]
4000ce6c: 10 bf ff bd b 4000cd60 <_RBTree_Insert_color+0xb4>
4000ce70: c6 20 a0 08 st %g3, [ %g2 + 8 ]
4000ce74: 10 bf ff ef b 4000ce30 <_RBTree_Insert_color+0x184>
<== NOT EXECUTED
4000ce78: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
4000ce7c: c8 22 00 00 st %g4, [ %o0 ]
4000ce80: c4 21 20 04 st %g2, [ %g4 + 4 ]
4000ce84: 10 bf ff 8b b 4000ccb0 <_RBTree_Insert_color+0x4>
4000ce88: c8 20 a0 08 st %g4, [ %g2 + 8 ]
4000ce8c: c8 02 40 00 ld [ %o1 ], %g4
4000ce90: 80 a1 20 00 cmp %g4, 0
4000ce94: 02 80 00 04 be 4000cea4 <_RBTree_Insert_color+0x1f8>
4000ce98: c8 20 60 04 st %g4, [ %g1 + 4 ]
4000ce9c: c2 21 20 08 st %g1, [ %g4 + 8 ]
4000cea0: c6 00 60 08 ld [ %g1 + 8 ], %g3
4000cea4: 80 a0 e0 00 cmp %g3, 0
4000cea8: 02 80 00 1b be 4000cf14 <_RBTree_Insert_color+0x268>
<== NEVER TAKEN
4000ceac: c6 22 60 08 st %g3, [ %o1 + 8 ]
4000ceb0: c6 00 60 08 ld [ %g1 + 8 ], %g3
4000ceb4: c8 00 c0 00 ld [ %g3 ], %g4
4000ceb8: 80 a0 40 04 cmp %g1, %g4
4000cebc: 22 80 00 03 be,a 4000cec8 <_RBTree_Insert_color+0x21c>
<== ALWAYS TAKEN
4000cec0: d2 20 c0 00 st %o1, [ %g3 ]
4000cec4: d2 20 e0 04 st %o1, [ %g3 + 4 ]
<== NOT EXECUTED
4000cec8: 86 10 00 09 mov %o1, %g3
4000cecc: c2 22 40 00 st %g1, [ %o1 ]
4000ced0: c8 00 80 00 ld [ %g2 ], %g4
4000ced4: da 01 20 04 ld [ %g4 + 4 ], %o5
4000ced8: d2 20 60 08 st %o1, [ %g1 + 8 ]
4000cedc: 92 10 00 01 mov %g1, %o1
4000cee0: 10 bf ff b3 b 4000cdac <_RBTree_Insert_color+0x100>
4000cee4: 82 10 00 03 mov %g3, %g1
4000cee8: c6 22 60 08 st %g3, [ %o1 + 8 ]
4000ceec: c6 00 60 08 ld [ %g1 + 8 ], %g3
4000cef0: c8 00 c0 00 ld [ %g3 ], %g4
4000cef4: 80 a0 40 04 cmp %g1, %g4
4000cef8: 32 bf ff ce bne,a 4000ce30 <_RBTree_Insert_color+0x184>
<== ALWAYS TAKEN
4000cefc: d2 20 e0 04 st %o1, [ %g3 + 4 ]
4000cf00: 10 bf ff cc b 4000ce30 <_RBTree_Insert_color+0x184>
<== NOT EXECUTED
4000cf04: d2 20 c0 00 st %o1, [ %g3 ]
<== NOT EXECUTED
4000cf08: c4 21 20 04 st %g2, [ %g4 + 4 ]
4000cf0c: 10 bf ff 69 b 4000ccb0 <_RBTree_Insert_color+0x4>
4000cf10: c8 20 a0 08 st %g4, [ %g2 + 8 ]
4000cf14: 10 bf ff ed b 4000cec8 <_RBTree_Insert_color+0x21c>
<== NOT EXECUTED
4000cf18: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
4000799c <_RBTree_Iterate>:
void _RBTree_Iterate(
const RBTree_Control *rbtree,
RBTree_Visitor visitor,
void *visitor_arg
)
{
4000799c: 9d e3 bf a0 save %sp, -96, %sp
const RBTree_Node *current = _RBTree_Minimum( rbtree );
400079a0: 40 00 00 12 call 400079e8 <_RBTree_Minimum>
400079a4: 90 10 00 18 mov %i0, %o0
400079a8: 10 80 00 0b b 400079d4 <_RBTree_Iterate+0x38>
400079ac: ba 10 00 08 mov %o0, %i5
bool stop = false;
while ( !stop && current != NULL ) {
stop = ( *visitor )( current, visitor_arg );
400079b0: 9f c6 40 00 call %i1
400079b4: 90 10 00 1d mov %i5, %o0
400079b8: b8 10 00 08 mov %o0, %i4
current = _RBTree_Successor( current );
400079bc: 40 00 00 18 call 40007a1c <_RBTree_Successor>
400079c0: 90 10 00 1d mov %i5, %o0
while ( !stop && current != NULL ) {
400079c4: b8 1f 20 01 xor %i4, 1, %i4
400079c8: 80 8f 20 ff btst 0xff, %i4
400079cc: 02 80 00 05 be 400079e0 <_RBTree_Iterate+0x44>
<== NEVER TAKEN
400079d0: ba 10 00 08 mov %o0, %i5
400079d4: 80 a7 60 00 cmp %i5, 0
400079d8: 12 bf ff f6 bne 400079b0 <_RBTree_Iterate+0x14>
400079dc: 92 10 00 1a mov %i2, %o1
}
}
400079e0: 81 c7 e0 08 ret
400079e4: 81 e8 00 00 restore
400167a0 <_RBTree_Predecessor>:
RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static )
400167a0: c2 02 00 00 ld [ %o0 ], %g1
400167a4: 80 a0 60 00 cmp %g1, 0
400167a8: 32 80 00 05 bne,a 400167bc <_RBTree_Predecessor+0x1c>
400167ac: c4 00 60 04 ld [ %g1 + 4 ], %g2
400167b0: 10 80 00 08 b 400167d0 <_RBTree_Predecessor+0x30>
400167b4: c2 02 20 08 ld [ %o0 + 8 ], %g1
400167b8: c4 00 60 04 ld [ %g1 + 4 ], %g2
400167bc: 80 a0 a0 00 cmp %g2, 0
400167c0: 32 bf ff fe bne,a 400167b8 <_RBTree_Predecessor+0x18>
400167c4: 82 10 00 02 mov %g2, %g1
RBTree_Node *_RBTree_Predecessor( const RBTree_Node *node )
{
return RB_PREV( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
}
400167c8: 81 c3 e0 08 retl
400167cc: 90 10 00 01 mov %g1, %o0
RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static )
400167d0: 80 a0 60 00 cmp %g1, 0
400167d4: 02 bf ff fd be 400167c8 <_RBTree_Predecessor+0x28>
400167d8: 01 00 00 00 nop
400167dc: c4 00 60 04 ld [ %g1 + 4 ], %g2
400167e0: 80 a2 00 02 cmp %o0, %g2
400167e4: 02 bf ff f9 be 400167c8 <_RBTree_Predecessor+0x28>
400167e8: 01 00 00 00 nop
400167ec: c4 00 40 00 ld [ %g1 ], %g2
400167f0: 80 a0 80 08 cmp %g2, %o0
400167f4: 12 bf ff f5 bne 400167c8 <_RBTree_Predecessor+0x28>
<== NEVER TAKEN
400167f8: 01 00 00 00 nop
400167fc: c4 00 60 08 ld [ %g1 + 8 ], %g2
40016800: 80 a0 a0 00 cmp %g2, 0
40016804: 02 80 00 09 be 40016828 <_RBTree_Predecessor+0x88>
40016808: 90 10 00 01 mov %g1, %o0
4001680c: 82 10 00 02 mov %g2, %g1
40016810: c4 00 40 00 ld [ %g1 ], %g2
40016814: 80 a0 80 08 cmp %g2, %o0
40016818: 22 bf ff fa be,a 40016800 <_RBTree_Predecessor+0x60>
4001681c: c4 00 60 08 ld [ %g1 + 8 ], %g2
}
40016820: 81 c3 e0 08 retl
40016824: 90 10 00 01 mov %g1, %o0
return RB_PREV( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
40016828: 10 bf ff e8 b 400167c8 <_RBTree_Predecessor+0x28>
4001682c: 82 10 20 00 clr %g1
40016710 <_RBTree_Successor>:
RB_GENERATE_NEXT( RBTree_Control, RBTree_Node, Node, static )
40016710: c2 02 20 04 ld [ %o0 + 4 ], %g1
40016714: 80 a0 60 00 cmp %g1, 0
40016718: 32 80 00 05 bne,a 4001672c <_RBTree_Successor+0x1c>
4001671c: c4 00 40 00 ld [ %g1 ], %g2
40016720: 10 80 00 08 b 40016740 <_RBTree_Successor+0x30>
40016724: c2 02 20 08 ld [ %o0 + 8 ], %g1
40016728: c4 00 40 00 ld [ %g1 ], %g2
4001672c: 80 a0 a0 00 cmp %g2, 0
40016730: 32 bf ff fe bne,a 40016728 <_RBTree_Successor+0x18>
40016734: 82 10 00 02 mov %g2, %g1
RBTree_Node *_RBTree_Successor( const RBTree_Node *node )
{
return RB_NEXT( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
}
40016738: 81 c3 e0 08 retl
4001673c: 90 10 00 01 mov %g1, %o0
RB_GENERATE_NEXT( RBTree_Control, RBTree_Node, Node, static )
40016740: 80 a0 60 00 cmp %g1, 0
40016744: 02 bf ff fd be 40016738 <_RBTree_Successor+0x28>
40016748: 01 00 00 00 nop
4001674c: c4 00 40 00 ld [ %g1 ], %g2
40016750: 80 a2 00 02 cmp %o0, %g2
40016754: 02 bf ff f9 be 40016738 <_RBTree_Successor+0x28>
40016758: 01 00 00 00 nop
4001675c: c4 00 60 04 ld [ %g1 + 4 ], %g2
40016760: 80 a0 80 08 cmp %g2, %o0
40016764: 12 bf ff f5 bne 40016738 <_RBTree_Successor+0x28>
<== NEVER TAKEN
40016768: 01 00 00 00 nop
4001676c: c4 00 60 08 ld [ %g1 + 8 ], %g2
40016770: 80 a0 a0 00 cmp %g2, 0
40016774: 02 80 00 09 be 40016798 <_RBTree_Successor+0x88>
40016778: 90 10 00 01 mov %g1, %o0
4001677c: 82 10 00 02 mov %g2, %g1
40016780: c4 00 60 04 ld [ %g1 + 4 ], %g2
40016784: 80 a0 80 08 cmp %g2, %o0
40016788: 22 bf ff fa be,a 40016770 <_RBTree_Successor+0x60>
4001678c: c4 00 60 08 ld [ %g1 + 8 ], %g2
}
40016790: 81 c3 e0 08 retl
40016794: 90 10 00 01 mov %g1, %o0
return RB_NEXT( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
40016798: 10 bf ff e8 b 40016738 <_RBTree_Successor+0x28>
4001679c: 82 10 20 00 clr %g1
4000f450 <_SMP_barrier_Wait>:
SMP_barrier_Control *control,
SMP_barrier_State *state,
unsigned int count
)
{
unsigned int sense = ~state->sense;
4000f450: c4 02 40 00 ld [ %o1 ], %g2
4000f454: 84 38 00 02 xnor %g0, %g2, %g2
unsigned int previous_value;
bool performed_release;
state->sense = sense;
4000f458: c4 22 40 00 st %g2, [ %o1 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000f45c: 91 d0 20 09 ta 9
*obj = val + arg;
4000f460: c6 02 00 00 ld [ %o0 ], %g3
4000f464: 86 00 e0 01 inc %g3
4000f468: c6 22 00 00 st %g3, [ %o0 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f46c: 91 d0 20 0a ta 0xa
4000f470: 01 00 00 00 nop
&control->value,
1U,
ATOMIC_ORDER_RELAXED
);
if ( previous_value + 1U == count ) {
4000f474: 80 a2 80 03 cmp %o2, %g3
4000f478: 02 80 00 09 be 4000f49c <_SMP_barrier_Wait+0x4c>
<== ALWAYS TAKEN
4000f47c: 01 00 00 00 nop
_Atomic_Store_uint( &control->value, 0U, ATOMIC_ORDER_RELAXED );
_Atomic_Store_uint( &control->sense, sense, ATOMIC_ORDER_RELEASE );
performed_release = true;
} else {
while (
_Atomic_Load_uint( &control->sense, ATOMIC_ORDER_ACQUIRE ) != sense
4000f480: c2 02 20 04 ld [ %o0 + 4 ], %g1
<== NOT EXECUTED
while (
4000f484: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4000f488: 32 bf ff ff bne,a 4000f484 <_SMP_barrier_Wait+0x34>
<== NOT EXECUTED
4000f48c: c2 02 20 04 ld [ %o0 + 4 ], %g1
<== NOT EXECUTED
) {
/* Wait */
}
performed_release = false;
4000f490: 82 10 20 00 clr %g1
<== NOT EXECUTED
}
return performed_release;
}
4000f494: 81 c3 e0 08 retl
<== NOT EXECUTED
4000f498: 90 08 60 01 and %g1, 1, %o0
<== NOT EXECUTED
*obj = desired;
4000f49c: c0 22 00 00 clr [ %o0 ]
performed_release = true;
4000f4a0: 82 10 20 01 mov 1, %g1
4000f4a4: c4 22 20 04 st %g2, [ %o0 + 4 ]
}
4000f4a8: 81 c3 e0 08 retl
4000f4ac: 90 08 60 01 and %g1, 1, %o0
400089f0 <_Scheduler_CBS_Attach_thread>:
int _Scheduler_CBS_Attach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
400089f0: 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 ) {
400089f4: 03 10 00 47 sethi %hi(0x40011c00), %g1
400089f8: c2 00 63 c8 ld [ %g1 + 0x3c8 ], %g1 ! 40011fc8 <_Scheduler_CBS_Maximum_servers>
400089fc: 80 a0 40 18 cmp %g1, %i0
40008a00: 08 80 00 2c bleu 40008ab0 <_Scheduler_CBS_Attach_thread+0xc0>
40008a04: 3b 10 00 5c sethi %hi(0x40017000), %i5
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
}
server = &_Scheduler_CBS_Server_list[ server_id ];
40008a08: b1 2e 20 05 sll %i0, 5, %i0
40008a0c: ba 17 62 f8 or %i5, 0x2f8, %i5
40008a10: b8 06 00 1d add %i0, %i5, %i4
if ( !server->initialized ) {
40008a14: c2 0f 20 1c ldub [ %i4 + 0x1c ], %g1
40008a18: 80 a0 60 00 cmp %g1, 0
40008a1c: 02 80 00 27 be 40008ab8 <_Scheduler_CBS_Attach_thread+0xc8>
40008a20: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_NOSERVER;
}
if ( server->task_id != -1 ) {
40008a24: c2 07 40 18 ld [ %i5 + %i0 ], %g1
40008a28: 80 a0 7f ff cmp %g1, -1
40008a2c: 12 80 00 1a bne 40008a94 <_Scheduler_CBS_Attach_thread+0xa4>
40008a30: 92 07 bf fc add %fp, -4, %o1
return SCHEDULER_CBS_ERROR_FULL;
}
the_thread = _Thread_Get( task_id, &lock_context );
40008a34: 40 00 05 85 call 4000a048 <_Thread_Get>
40008a38: 90 10 00 19 mov %i1, %o0
if ( the_thread == NULL ) {
40008a3c: 80 a2 20 00 cmp %o0, 0
40008a40: 02 80 00 1c be 40008ab0 <_Scheduler_CBS_Attach_thread+0xc0>
40008a44: 01 00 00 00 nop
40008a48: 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 ) {
40008a4c: c4 00 60 50 ld [ %g1 + 0x50 ], %g2
40008a50: 80 a0 a0 00 cmp %g2, 0
40008a54: 12 80 00 12 bne 40008a9c <_Scheduler_CBS_Attach_thread+0xac>
<== NEVER TAKEN
40008a58: 01 00 00 00 nop
_ISR_lock_ISR_enable( &lock_context );
return SCHEDULER_CBS_ERROR_FULL;
}
node->cbs_server = server;
40008a5c: f8 20 60 50 st %i4, [ %g1 + 0x50 ]
server->task_id = task_id;
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
40008a60: 03 10 00 22 sethi %hi(0x40008800), %g1
server->task_id = task_id;
40008a64: f2 27 40 18 st %i1, [ %i5 + %i0 ]
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
40008a68: 82 10 61 5c or %g1, 0x15c, %g1
40008a6c: c2 22 20 94 st %g1, [ %o0 + 0x94 ]
the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
40008a70: 82 10 20 03 mov 3, %g1
40008a74: c2 22 20 90 st %g1, [ %o0 + 0x90 ]
the_thread->is_preemptible = true;
40008a78: 82 10 20 01 mov 1, %g1
40008a7c: c2 2a 20 89 stb %g1, [ %o0 + 0x89 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008a80: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008a84: 91 d0 20 0a ta 0xa
40008a88: 01 00 00 00 nop
_ISR_lock_ISR_enable( &lock_context );
return SCHEDULER_CBS_OK;
40008a8c: 81 c7 e0 08 ret
40008a90: 91 e8 20 00 restore %g0, 0, %o0
}
40008a94: 81 c7 e0 08 ret
40008a98: 91 e8 3f e6 restore %g0, -26, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008a9c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008aa0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008aa4: 01 00 00 00 nop
<== NOT EXECUTED
return SCHEDULER_CBS_ERROR_FULL;
40008aa8: 81 c7 e0 08 ret
<== NOT EXECUTED
40008aac: 91 e8 3f e6 restore %g0, -26, %o0
<== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
40008ab0: 81 c7 e0 08 ret
40008ab4: 91 e8 3f ee restore %g0, -18, %o0
return SCHEDULER_CBS_ERROR_NOSERVER;
40008ab8: 81 c7 e0 08 ret
40008abc: 91 e8 3f e7 restore %g0, -25, %o0
4000895c <_Scheduler_CBS_Budget_callout>:
#include <rtems/score/schedulercbsimpl.h>
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
4000895c: 9d e3 bf 78 save %sp, -136, %sp
*/
RTEMS_INLINE_ROUTINE Scheduler_CBS_Node *_Scheduler_CBS_Thread_get_node(
Thread_Control *the_thread
)
{
return (Scheduler_CBS_Node *) _Thread_Scheduler_get_home_node( the_thread );
40008960: 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(
40008964: d4 07 60 54 ld [ %i5 + 0x54 ], %o2
40008968: 96 07 bf dc add %fp, -36, %o3
4000896c: 92 10 00 18 mov %i0, %o1
40008970: 90 10 20 00 clr %o0
40008974: 40 00 01 ba call 4000905c <_Scheduler_CBS_Cancel_job>
40008978: c0 27 bf f0 clr [ %fp + -16 ]
NULL,
the_thread,
node->deadline_node,
&queue_context
);
_Thread_Priority_update( &queue_context );
4000897c: 40 00 05 0a call 40009da4 <_Thread_Priority_update>
40008980: 90 07 bf dc add %fp, -36, %o0
/* Invoke callback function if any. */
if ( node->cbs_server->cbs_budget_overrun ) {
40008984: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
40008988: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4000898c: 80 a0 a0 00 cmp %g2, 0
40008990: 02 80 00 09 be 400089b4 <_Scheduler_CBS_Budget_callout+0x58>
<== NEVER TAKEN
40008994: 01 00 00 00 nop
_Scheduler_CBS_Get_server_id(
40008998: d0 00 40 00 ld [ %g1 ], %o0
4000899c: 40 00 01 60 call 40008f1c <_Scheduler_CBS_Get_server_id>
400089a0: 92 07 bf d8 add %fp, -40, %o1
node->cbs_server->task_id,
&server_id
);
node->cbs_server->cbs_budget_overrun( server_id );
400089a4: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
400089a8: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
400089ac: 9f c0 40 00 call %g1
400089b0: d0 07 bf d8 ld [ %fp + -40 ], %o0
}
}
400089b4: 81 c7 e0 08 ret
400089b8: 81 e8 00 00 restore
40008ac0 <_Scheduler_CBS_Cleanup>:
#include <rtems/score/schedulercbs.h>
#include <rtems/score/wkspace.h>
int _Scheduler_CBS_Cleanup (void)
{
40008ac0: 9d e3 bf a0 save %sp, -96, %sp
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
40008ac4: 03 10 00 47 sethi %hi(0x40011c00), %g1
40008ac8: f6 00 63 c8 ld [ %g1 + 0x3c8 ], %i3 ! 40011fc8 <_Scheduler_CBS_Maximum_servers>
40008acc: 80 a6 e0 00 cmp %i3, 0
40008ad0: 02 80 00 12 be 40008b18 <_Scheduler_CBS_Cleanup+0x58>
<== NEVER TAKEN
40008ad4: 39 10 00 5c sethi %hi(0x40017000), %i4
40008ad8: ba 10 20 00 clr %i5
40008adc: 10 80 00 05 b 40008af0 <_Scheduler_CBS_Cleanup+0x30>
40008ae0: b8 17 23 14 or %i4, 0x314, %i4
40008ae4: 80 a7 40 1b cmp %i5, %i3
40008ae8: 02 80 00 0c be 40008b18 <_Scheduler_CBS_Cleanup+0x58>
40008aec: b8 07 20 20 add %i4, 0x20, %i4
if ( _Scheduler_CBS_Server_list[ i ].initialized )
40008af0: c2 0f 00 00 ldub [ %i4 ], %g1
40008af4: 80 a0 60 00 cmp %g1, 0
40008af8: 22 bf ff fb be,a 40008ae4 <_Scheduler_CBS_Cleanup+0x24>
40008afc: ba 07 60 01 inc %i5
_Scheduler_CBS_Destroy_server( i );
40008b00: 40 00 00 43 call 40008c0c <_Scheduler_CBS_Destroy_server>
40008b04: 90 10 00 1d mov %i5, %o0
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
40008b08: ba 07 60 01 inc %i5
40008b0c: 80 a7 40 1b cmp %i5, %i3
40008b10: 12 bf ff f8 bne 40008af0 <_Scheduler_CBS_Cleanup+0x30>
<== ALWAYS TAKEN
40008b14: b8 07 20 20 add %i4, 0x20, %i4
}
return SCHEDULER_CBS_OK;
}
40008b18: 81 c7 e0 08 ret
40008b1c: 91 e8 20 00 restore %g0, 0, %o0
40008b20 <_Scheduler_CBS_Create_server>:
)
{
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
40008b20: c2 02 20 08 ld [ %o0 + 8 ], %g1
40008b24: 80 a0 60 00 cmp %g1, 0
40008b28: 04 80 00 2a ble 40008bd0 <_Scheduler_CBS_Create_server+0xb0>
<== ALWAYS TAKEN
40008b2c: 01 00 00 00 nop
40008b30: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
40008b34: 80 a0 60 00 cmp %g1, 0
40008b38: 04 80 00 2e ble 40008bf0 <_Scheduler_CBS_Create_server+0xd0>
<== ALWAYS TAKEN
40008b3c: 03 10 00 47 sethi %hi(0x40011c00), %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++ ) {
40008b40: c8 00 63 c8 ld [ %g1 + 0x3c8 ], %g4 ! 40011fc8 <_Scheduler_CBS_Maximum_servers>
40008b44: 80 a1 20 00 cmp %g4, 0
40008b48: 02 80 00 11 be 40008b8c <_Scheduler_CBS_Create_server+0x6c>
<== NEVER TAKEN
40008b4c: 1b 10 00 5c sethi %hi(0x40017000), %o5
if ( !_Scheduler_CBS_Server_list[i].initialized )
40008b50: 9a 13 62 f8 or %o5, 0x2f8, %o5 ! 400172f8 <_Scheduler_CBS_Server_list>
40008b54: c2 0b 60 1c ldub [ %o5 + 0x1c ], %g1
40008b58: 80 a0 60 00 cmp %g1, 0
40008b5c: 02 80 00 0e be 40008b94 <_Scheduler_CBS_Create_server+0x74>
40008b60: 84 03 60 3c add %o5, 0x3c, %g2
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
40008b64: 10 80 00 06 b 40008b7c <_Scheduler_CBS_Create_server+0x5c>
40008b68: 82 10 20 00 clr %g1
if ( !_Scheduler_CBS_Server_list[i].initialized )
40008b6c: c6 08 bf e0 ldub [ %g2 + -32 ], %g3
40008b70: 80 a0 e0 00 cmp %g3, 0
40008b74: 22 80 00 0a be,a 40008b9c <_Scheduler_CBS_Create_server+0x7c>
40008b78: c2 22 80 00 st %g1, [ %o2 ]
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
40008b7c: 82 00 60 01 inc %g1
40008b80: 80 a1 00 01 cmp %g4, %g1
40008b84: 12 bf ff fa bne 40008b6c <_Scheduler_CBS_Create_server+0x4c>
40008b88: 84 00 a0 20 add %g2, 0x20, %g2
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
40008b8c: 81 c3 e0 08 retl
40008b90: 90 10 3f e6 mov -26, %o0
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
40008b94: 82 10 20 00 clr %g1
*server_id = i;
40008b98: c2 22 80 00 st %g1, [ %o2 ]
the_server = &_Scheduler_CBS_Server_list[*server_id];
the_server->parameters = *params;
40008b9c: 83 28 60 05 sll %g1, 5, %g1
40008ba0: d4 1a 00 00 ldd [ %o0 ], %o2
40008ba4: 84 03 40 01 add %o5, %g1, %g2
40008ba8: d4 38 a0 08 std %o2, [ %g2 + 8 ]
the_server->task_id = -1;
40008bac: 86 10 3f ff mov -1, %g3
the_server->parameters = *params;
40008bb0: d4 1a 20 08 ldd [ %o0 + 8 ], %o2
40008bb4: d4 38 a0 10 std %o2, [ %g2 + 0x10 ]
the_server->cbs_budget_overrun = budget_overrun_callback;
the_server->initialized = true;
return SCHEDULER_CBS_OK;
40008bb8: 90 10 20 00 clr %o0
the_server->task_id = -1;
40008bbc: c6 23 40 01 st %g3, [ %o5 + %g1 ]
the_server->initialized = true;
40008bc0: 82 10 20 01 mov 1, %g1
the_server->cbs_budget_overrun = budget_overrun_callback;
40008bc4: d2 20 a0 18 st %o1, [ %g2 + 0x18 ]
}
40008bc8: 81 c3 e0 08 retl
40008bcc: c2 28 a0 1c stb %g1, [ %g2 + 0x1c ]
if ( params->budget <= 0 ||
40008bd0: 12 80 00 06 bne 40008be8 <_Scheduler_CBS_Create_server+0xc8>
40008bd4: 01 00 00 00 nop
40008bd8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40008bdc: 80 a0 60 00 cmp %g1, 0
40008be0: 32 bf ff d5 bne,a 40008b34 <_Scheduler_CBS_Create_server+0x14>
<== ALWAYS TAKEN
40008be4: c2 02 00 00 ld [ %o0 ], %g1
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
40008be8: 81 c3 e0 08 retl
40008bec: 90 10 3f ee mov -18, %o0
if ( params->budget <= 0 ||
40008bf0: 12 bf ff fe bne 40008be8 <_Scheduler_CBS_Create_server+0xc8>
40008bf4: 01 00 00 00 nop
40008bf8: c2 02 20 04 ld [ %o0 + 4 ], %g1
40008bfc: 80 a0 60 00 cmp %g1, 0
40008c00: 12 bf ff d0 bne 40008b40 <_Scheduler_CBS_Create_server+0x20>
<== ALWAYS TAKEN
40008c04: 03 10 00 47 sethi %hi(0x40011c00), %g1
40008c08: 30 bf ff f8 b,a 40008be8 <_Scheduler_CBS_Create_server+0xc8>
<== NOT EXECUTED
40008f1c <_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++ ) {
40008f1c: 03 10 00 47 sethi %hi(0x40011c00), %g1
40008f20: c8 00 63 c8 ld [ %g1 + 0x3c8 ], %g4 ! 40011fc8 <_Scheduler_CBS_Maximum_servers>
40008f24: 80 a1 20 00 cmp %g4, 0
40008f28: 02 80 00 10 be 40008f68 <_Scheduler_CBS_Get_server_id+0x4c>
<== NEVER TAKEN
40008f2c: 03 10 00 5c sethi %hi(0x40017000), %g1
40008f30: 84 10 20 00 clr %g2
40008f34: 82 10 62 f8 or %g1, 0x2f8, %g1
if ( _Scheduler_CBS_Server_list[i].initialized &&
40008f38: c6 08 60 1c ldub [ %g1 + 0x1c ], %g3
40008f3c: 80 a0 e0 00 cmp %g3, 0
40008f40: 22 80 00 07 be,a 40008f5c <_Scheduler_CBS_Get_server_id+0x40>
40008f44: 84 00 a0 01 inc %g2
40008f48: c6 00 40 00 ld [ %g1 ], %g3
40008f4c: 80 a0 c0 08 cmp %g3, %o0
40008f50: 22 80 00 08 be,a 40008f70 <_Scheduler_CBS_Get_server_id+0x54>
40008f54: c4 22 40 00 st %g2, [ %o1 ]
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
40008f58: 84 00 a0 01 inc %g2
40008f5c: 80 a0 80 04 cmp %g2, %g4
40008f60: 12 bf ff f6 bne 40008f38 <_Scheduler_CBS_Get_server_id+0x1c>
40008f64: 82 00 60 20 add %g1, 0x20, %g1
*server_id = i;
return SCHEDULER_CBS_OK;
}
}
return SCHEDULER_CBS_ERROR_NOSERVER;
}
40008f68: 81 c3 e0 08 retl
40008f6c: 90 10 3f e7 mov -25, %o0
return SCHEDULER_CBS_OK;
40008f70: 81 c3 e0 08 retl
40008f74: 90 10 20 00 clr %o0
40008f78 <_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 )
40008f78: 03 10 00 47 sethi %hi(0x40011c00), %g1
40008f7c: c2 00 63 c8 ld [ %g1 + 0x3c8 ], %g1 ! 40011fc8 <_Scheduler_CBS_Maximum_servers>
40008f80: 80 a0 40 08 cmp %g1, %o0
40008f84: 08 80 00 1e bleu 40008ffc <_Scheduler_CBS_Set_parameters+0x84>
40008f88: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( params->budget <= 0 ||
40008f8c: c2 02 60 08 ld [ %o1 + 8 ], %g1
40008f90: 80 a0 60 00 cmp %g1, 0
40008f94: 04 80 00 1e ble 4000900c <_Scheduler_CBS_Set_parameters+0x94>
<== ALWAYS TAKEN
40008f98: 01 00 00 00 nop
40008f9c: c2 02 40 00 ld [ %o1 ], %g1
<== NOT EXECUTED
40008fa0: 80 a0 60 00 cmp %g1, 0
40008fa4: 04 80 00 10 ble 40008fe4 <_Scheduler_CBS_Set_parameters+0x6c>
<== ALWAYS TAKEN
40008fa8: 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 )
40008fac: 91 2a 20 05 sll %o0, 5, %o0
<== NOT EXECUTED
40008fb0: 03 10 00 5c sethi %hi(0x40017000), %g1
40008fb4: 82 10 62 f8 or %g1, 0x2f8, %g1 ! 400172f8 <_Scheduler_CBS_Server_list>
40008fb8: 82 00 40 08 add %g1, %o0, %g1
40008fbc: c4 08 60 1c ldub [ %g1 + 0x1c ], %g2
40008fc0: 80 a0 a0 00 cmp %g2, 0
40008fc4: 02 80 00 10 be 40009004 <_Scheduler_CBS_Set_parameters+0x8c>
40008fc8: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_NOSERVER;
_Scheduler_CBS_Server_list[server_id].parameters = *params;
40008fcc: c4 1a 40 00 ldd [ %o1 ], %g2
40008fd0: c4 38 60 08 std %g2, [ %g1 + 8 ]
return SCHEDULER_CBS_OK;
40008fd4: 90 10 20 00 clr %o0
_Scheduler_CBS_Server_list[server_id].parameters = *params;
40008fd8: c4 1a 60 08 ldd [ %o1 + 8 ], %g2
return SCHEDULER_CBS_OK;
40008fdc: 81 c3 e0 08 retl
40008fe0: c4 38 60 10 std %g2, [ %g1 + 0x10 ]
if ( params->budget <= 0 ||
40008fe4: 12 80 00 06 bne 40008ffc <_Scheduler_CBS_Set_parameters+0x84>
40008fe8: 01 00 00 00 nop
40008fec: c2 02 60 04 ld [ %o1 + 4 ], %g1
40008ff0: 80 a0 60 00 cmp %g1, 0
40008ff4: 32 bf ff ef bne,a 40008fb0 <_Scheduler_CBS_Set_parameters+0x38>
<== ALWAYS TAKEN
40008ff8: 91 2a 20 05 sll %o0, 5, %o0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
40008ffc: 81 c3 e0 08 retl
40009000: 90 10 3f ee mov -18, %o0
}
40009004: 81 c3 e0 08 retl
40009008: 90 10 3f e7 mov -25, %o0
if ( params->budget <= 0 ||
4000900c: 12 bf ff fc bne 40008ffc <_Scheduler_CBS_Set_parameters+0x84>
40009010: 01 00 00 00 nop
40009014: c2 02 60 0c ld [ %o1 + 0xc ], %g1
40009018: 80 a0 60 00 cmp %g1, 0
4000901c: 32 bf ff e1 bne,a 40008fa0 <_Scheduler_CBS_Set_parameters+0x28>
<== ALWAYS TAKEN
40009020: c2 02 40 00 ld [ %o1 ], %g1
40009024: 30 bf ff f6 b,a 40008ffc <_Scheduler_CBS_Set_parameters+0x84>
<== NOT EXECUTED
40007e4c <_Scheduler_CBS_Unblock>:
void _Scheduler_CBS_Unblock(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40007e4c: 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;
40007e50: c2 06 a0 50 ld [ %i2 + 0x50 ], %g1
priority = _Scheduler_Node_get_priority( &the_node->Base.Base );
priority = SCHEDULER_PRIORITY_PURIFY( priority );
40007e54: c8 06 a0 34 ld [ %i2 + 0x34 ], %g4
40007e58: 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 ) {
40007e5c: 80 a0 60 00 cmp %g1, 0
40007e60: 02 80 00 1c be 40007ed0 <_Scheduler_CBS_Unblock+0x84>
40007e64: 86 09 3f fe and %g4, -2, %g3
40007e68: 80 a0 a0 00 cmp %g2, 0
40007e6c: 06 80 00 19 bl 40007ed0 <_Scheduler_CBS_Unblock+0x84>
40007e70: 09 10 00 55 sethi %hi(0x40015400), %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 ) {
40007e74: fa 00 60 08 ld [ %g1 + 8 ], %i5
Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot;
40007e78: c8 01 22 20 ld [ %g4 + 0x220 ], %g4
40007e7c: 9a a0 c0 04 subcc %g3, %g4, %o5
if ( deadline * budget_left > budget * deadline_left ) {
40007e80: f6 06 60 8c ld [ %i1 + 0x8c ], %i3
Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot;
40007e84: 98 60 a0 00 subx %g2, 0, %o4
if ( deadline * budget_left > budget * deadline_left ) {
40007e88: f8 00 60 14 ld [ %g1 + 0x14 ], %i4
40007e8c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40007e90: ba 5f 40 0d smul %i5, %o5, %i5
40007e94: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
40007e98: 88 58 80 0c smul %g2, %o4, %g4
40007e9c: 82 58 40 1b smul %g1, %i3, %g1
40007ea0: 88 01 00 1d add %g4, %i5, %g4
40007ea4: 86 50 80 0d umul %g2, %o5, %g3
40007ea8: 85 40 00 00 rd %y, %g2
40007eac: ba 57 00 1b umul %i4, %i3, %i5
40007eb0: b9 40 00 00 rd %y, %i4
40007eb4: 84 01 00 02 add %g4, %g2, %g2
40007eb8: b8 00 40 1c add %g1, %i4, %i4
40007ebc: 80 a0 80 1c cmp %g2, %i4
40007ec0: 38 80 00 0d bgu,a 40007ef4 <_Scheduler_CBS_Unblock+0xa8>
<== NEVER TAKEN
40007ec4: d4 06 a0 54 ld [ %i2 + 0x54 ], %o2
<== NOT EXECUTED
40007ec8: 02 80 00 08 be 40007ee8 <_Scheduler_CBS_Unblock+0x9c>
<== ALWAYS TAKEN
40007ecc: 80 a0 c0 1d cmp %g3, %i5
&queue_context
);
}
}
_Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base );
40007ed0: 94 10 00 1a mov %i2, %o2
40007ed4: 92 10 00 19 mov %i1, %o1
40007ed8: 40 00 17 6a call 4000dc80 <_Scheduler_EDF_Unblock>
40007edc: 90 10 00 18 mov %i0, %o0
}
40007ee0: 81 c7 e0 08 ret
40007ee4: 81 e8 00 00 restore
if ( deadline * budget_left > budget * deadline_left ) {
40007ee8: 08 bf ff fb bleu 40007ed4 <_Scheduler_CBS_Unblock+0x88>
<== NEVER TAKEN
40007eec: 94 10 00 1a mov %i2, %o2
_Scheduler_CBS_Cancel_job(
40007ef0: d4 06 a0 54 ld [ %i2 + 0x54 ], %o2
40007ef4: 92 10 00 19 mov %i1, %o1
40007ef8: 90 10 00 18 mov %i0, %o0
*/
RTEMS_INLINE_ROUTINE void _Thread_queue_Context_clear_priority_updates(
Thread_queue_Context *queue_context
)
{
queue_context->Priority.update_count = 0;
40007efc: c0 27 bf f0 clr [ %fp + -16 ]
40007f00: 7f ff ff c8 call 40007e20 <_Scheduler_CBS_Cancel_job>
40007f04: 96 07 bf dc add %fp, -36, %o3
_Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base );
40007f08: 94 10 00 1a mov %i2, %o2
40007f0c: 92 10 00 19 mov %i1, %o1
40007f10: 40 00 17 5c call 4000dc80 <_Scheduler_EDF_Unblock>
40007f14: 90 10 00 18 mov %i0, %o0
}
40007f18: 81 c7 e0 08 ret
40007f1c: 81 e8 00 00 restore
400079d0 <_Scheduler_EDF_Block>:
void _Scheduler_EDF_Block(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
400079d0: 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 );
400079d4: d0 06 00 00 ld [ %i0 ], %o0
400079d8: 40 00 01 5c call 40007f48 <_RBTree_Extract>
400079dc: 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 ) ) {
400079e0: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2
400079e4: 80 a6 40 02 cmp %i1, %g2
400079e8: 02 80 00 08 be 40007a08 <_Scheduler_EDF_Block+0x38>
400079ec: 01 00 00 00 nop
400079f0: c2 01 a0 24 ld [ %g6 + 0x24 ], %g1
400079f4: 80 a6 40 01 cmp %i1, %g1
400079f8: 02 80 00 04 be 40007a08 <_Scheduler_EDF_Block+0x38>
<== NEVER TAKEN
400079fc: 01 00 00 00 nop
the_thread,
node,
_Scheduler_EDF_Extract_body,
_Scheduler_EDF_Schedule_body
);
}
40007a00: 81 c7 e0 08 ret
40007a04: 81 e8 00 00 restore
Scheduler_EDF_Node *node;
(void) the_thread;
context = _Scheduler_EDF_Get_context( scheduler );
first = _RBTree_Minimum( &context->Ready );
40007a08: 40 00 03 4e call 40008740 <_RBTree_Minimum>
40007a0c: d0 06 00 00 ld [ %i0 ], %o0
node = RTEMS_CONTAINER_OF( first, Scheduler_EDF_Node, Node );
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
40007a10: 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;
40007a14: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40007a18: 80 a6 c0 1d cmp %i3, %i5
40007a1c: 02 bf ff f9 be 40007a00 <_Scheduler_EDF_Block+0x30>
<== NEVER TAKEN
40007a20: b8 10 00 06 mov %g6, %i4
*time = _Timecounter_Sbinuptime();
40007a24: 40 00 11 85 call 4000c038 <_Timecounter_Sbinuptime>
40007a28: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0
40007a2c: d0 3f 20 28 std %o0, [ %i4 + 0x28 ]
const Timestamp_Control *_start,
const Timestamp_Control *_end,
Timestamp_Control *_result
)
{
*_result = *_end - *_start;
40007a30: b2 a2 40 11 subcc %o1, %l1, %i1
*_time += *_add;
40007a34: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4
*_result = *_end - *_start;
40007a38: b0 62 00 10 subx %o0, %l0, %i0
*_time += *_add;
40007a3c: 86 83 40 19 addcc %o5, %i1, %g3
40007a40: 84 43 00 18 addx %o4, %i0, %g2
40007a44: 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;
40007a48: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
40007a4c: f6 21 a0 24 st %i3, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
40007a50: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
40007a54: 81 c7 e0 08 ret
40007a58: 81 e8 00 00 restore
40007c60 <_Scheduler_EDF_Schedule>:
void _Scheduler_EDF_Schedule(
const Scheduler_Control *scheduler,
Thread_Control *the_thread
)
{
40007c60: 9d e3 bf a0 save %sp, -96, %sp
first = _RBTree_Minimum( &context->Ready );
40007c64: 40 00 02 b7 call 40008740 <_RBTree_Minimum>
40007c68: d0 06 00 00 ld [ %i0 ], %o0
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
40007c6c: f6 02 3f c8 ld [ %o0 + -56 ], %i3
Thread_Control *heir = _Thread_Heir;
40007c70: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40007c74: 80 a6 c0 1d cmp %i3, %i5
40007c78: 02 80 00 06 be 40007c90 <_Scheduler_EDF_Schedule+0x30>
<== ALWAYS TAKEN
40007c7c: b8 10 00 06 mov %g6, %i4
40007c80: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1
<== NOT EXECUTED
40007c84: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40007c88: 12 80 00 04 bne 40007c98 <_Scheduler_EDF_Schedule+0x38>
<== NOT EXECUTED
40007c8c: 01 00 00 00 nop
<== NOT EXECUTED
_Scheduler_EDF_Schedule_body( scheduler, the_thread, false );
}
40007c90: 81 c7 e0 08 ret
40007c94: 81 e8 00 00 restore
40007c98: 40 00 10 e8 call 4000c038 <_Timecounter_Sbinuptime>
<== NOT EXECUTED
40007c9c: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0
<== NOT EXECUTED
40007ca0: d0 3f 20 28 std %o0, [ %i4 + 0x28 ]
<== NOT EXECUTED
*_result = *_end - *_start;
40007ca4: b2 a2 40 11 subcc %o1, %l1, %i1
<== NOT EXECUTED
*_time += *_add;
40007ca8: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4
<== NOT EXECUTED
*_result = *_end - *_start;
40007cac: b0 62 00 10 subx %o0, %l0, %i0
<== NOT EXECUTED
*_time += *_add;
40007cb0: 86 83 40 19 addcc %o5, %i1, %g3
<== NOT EXECUTED
40007cb4: 84 43 00 18 addx %o4, %i0, %g2
<== NOT EXECUTED
40007cb8: c4 3f 60 98 std %g2, [ %i5 + 0x98 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40007cbc: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
_Thread_Heir = new_heir;
40007cc0: f6 21 a0 24 st %i3, [ %g6 + 0x24 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40007cc4: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
<== NOT EXECUTED
40007cc8: 81 c7 e0 08 ret
<== NOT EXECUTED
40007ccc: 81 e8 00 00 restore
<== NOT EXECUTED
4000dc80 <_Scheduler_EDF_Unblock>:
void _Scheduler_EDF_Unblock(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
4000dc80: 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 );
4000dc84: fa 06 a0 30 ld [ %i2 + 0x30 ], %i5
4000dc88: f8 06 a0 34 ld [ %i2 + 0x34 ], %i4
return (Scheduler_EDF_Context *) _Scheduler_Get_context( scheduler );
4000dc8c: d0 06 00 00 ld [ %i0 ], %o0
4000dc90: b8 0f 3f fe and %i4, -2, %i4
insert_priority = SCHEDULER_PRIORITY_APPEND( priority );
the_node->priority = priority;
4000dc94: fa 26 a0 48 st %i5, [ %i2 + 0x48 ]
link = _RBTree_Root_reference( the_rbtree );
4000dc98: 84 10 00 08 mov %o0, %g2
4000dc9c: f8 26 a0 4c st %i4, [ %i2 + 0x4c ]
insert_priority = SCHEDULER_PRIORITY_APPEND( priority );
4000dca0: b6 17 20 01 or %i4, 1, %i3
while ( *link != NULL ) {
4000dca4: c2 00 80 00 ld [ %g2 ], %g1
_RBTree_Insert_inline(
4000dca8: 88 06 a0 38 add %i2, 0x38, %g4
4000dcac: 80 a0 60 00 cmp %g1, 0
4000dcb0: 02 80 00 12 be 4000dcf8 <_Scheduler_EDF_Unblock+0x78>
4000dcb4: 86 10 20 00 clr %g3
if ( ( *less )( key, parent ) ) {
4000dcb8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000dcbc: 80 a0 80 1d cmp %g2, %i5
4000dcc0: 0a 80 00 09 bcs 4000dce4 <_Scheduler_EDF_Unblock+0x64>
4000dcc4: 84 00 60 04 add %g1, 4, %g2
4000dcc8: 12 80 00 1e bne 4000dd40 <_Scheduler_EDF_Unblock+0xc0>
4000dccc: 84 10 00 01 mov %g1, %g2
4000dcd0: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4000dcd4: 80 a0 80 1b cmp %g2, %i3
4000dcd8: 1a 80 00 1a bcc 4000dd40 <_Scheduler_EDF_Unblock+0xc0>
4000dcdc: 84 10 00 01 mov %g1, %g2
return &RB_RIGHT( the_node, Node );
4000dce0: 84 00 60 04 add %g1, 4, %g2
{
4000dce4: 86 10 00 01 mov %g1, %g3
while ( *link != NULL ) {
4000dce8: c2 00 80 00 ld [ %g2 ], %g1
4000dcec: 80 a0 60 00 cmp %g1, 0
4000dcf0: 32 bf ff f3 bne,a 4000dcbc <_Scheduler_EDF_Unblock+0x3c>
4000dcf4: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
RB_SET( child, parent, Node );
4000dcf8: c6 26 a0 40 st %g3, [ %i2 + 0x40 ]
4000dcfc: 82 10 20 01 mov 1, %g1
4000dd00: c0 26 a0 3c clr [ %i2 + 0x3c ]
_RBTree_Insert_color( the_rbtree, the_node );
4000dd04: 92 10 00 04 mov %g4, %o1
RB_SET( child, parent, Node );
4000dd08: c2 26 a0 44 st %g1, [ %i2 + 0x44 ]
4000dd0c: c0 26 a0 38 clr [ %i2 + 0x38 ]
_RBTree_Insert_color( the_rbtree, the_node );
4000dd10: 7f ff e9 f0 call 400084d0 <_RBTree_Insert_color>
4000dd14: c8 20 80 00 st %g4, [ %g2 ]
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
4000dd18: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3
return _Priority_Get_priority( &scheduler_node->Wait.Priority );
4000dd1c: c2 06 e0 38 ld [ %i3 + 0x38 ], %g1
4000dd20: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4000dd24: 80 a0 80 1d cmp %g2, %i5
4000dd28: 18 80 00 0b bgu 4000dd54 <_Scheduler_EDF_Unblock+0xd4>
4000dd2c: b4 10 00 06 mov %g6, %i2
4000dd30: 22 80 00 06 be,a 4000dd48 <_Scheduler_EDF_Unblock+0xc8>
4000dd34: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
_Scheduler_Update_heir(
the_thread,
priority == ( SCHEDULER_EDF_PRIO_MSB | PRIORITY_PSEUDO_ISR )
);
}
}
4000dd38: 81 c7 e0 08 ret
4000dd3c: 81 e8 00 00 restore
{
4000dd40: 10 bf ff ea b 4000dce8 <_Scheduler_EDF_Unblock+0x68>
4000dd44: 86 10 00 01 mov %g1, %g3
if ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
4000dd48: 80 a0 40 1c cmp %g1, %i4
4000dd4c: 08 80 00 19 bleu 4000ddb0 <_Scheduler_EDF_Unblock+0x130>
4000dd50: 01 00 00 00 nop
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4000dd54: 80 a6 c0 19 cmp %i3, %i1
4000dd58: 02 bf ff f8 be 4000dd38 <_Scheduler_EDF_Unblock+0xb8>
<== NEVER TAKEN
4000dd5c: 03 20 00 00 sethi %hi(0x80000000), %g1
_Scheduler_Update_heir(
4000dd60: ba 1f 40 01 xor %i5, %g1, %i5
4000dd64: 80 97 40 1c orcc %i5, %i4, %g0
4000dd68: 02 80 00 06 be 4000dd80 <_Scheduler_EDF_Unblock+0x100>
<== NEVER TAKEN
4000dd6c: 01 00 00 00 nop
4000dd70: c2 0e e0 89 ldub [ %i3 + 0x89 ], %g1
4000dd74: 80 a0 60 00 cmp %g1, 0
4000dd78: 02 80 00 0e be 4000ddb0 <_Scheduler_EDF_Unblock+0x130>
4000dd7c: 01 00 00 00 nop
4000dd80: 7f ff f8 ae call 4000c038 <_Timecounter_Sbinuptime>
4000dd84: e0 1e a0 28 ldd [ %i2 + 0x28 ], %l0
4000dd88: d0 3e a0 28 std %o0, [ %i2 + 0x28 ]
*_result = *_end - *_start;
4000dd8c: ba a2 40 11 subcc %o1, %l1, %i5
*_time += *_add;
4000dd90: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4
*_result = *_end - *_start;
4000dd94: b8 62 00 10 subx %o0, %l0, %i4
*_time += *_add;
4000dd98: 86 83 40 1d addcc %o5, %i5, %g3
4000dd9c: 84 43 00 1c addx %o4, %i4, %g2
4000dda0: c4 3e e0 98 std %g2, [ %i3 + 0x98 ]
_Thread_Dispatch_necessary = true;
4000dda4: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
4000dda8: f2 21 a0 24 st %i1, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
4000ddac: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
}
4000ddb0: 81 c7 e0 08 ret
4000ddb4: 81 e8 00 00 restore
40007bc0 <_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 );
40007bc0: 95 32 a0 01 srl %o2, 1, %o2
<== NOT EXECUTED
40007bc4: 83 2a 60 1f sll %o1, 0x1f, %g1
<== NOT EXECUTED
40007bc8: 91 2a 60 01 sll %o1, 1, %o0
<== NOT EXECUTED
}
40007bcc: 92 10 40 0a or %g1, %o2, %o1
<== NOT EXECUTED
40007bd0: 81 c3 e0 08 retl
<== NOT EXECUTED
40007bd4: 91 32 20 02 srl %o0, 2, %o0
<== NOT EXECUTED
40007a5c <_Scheduler_EDF_Update_priority>:
void _Scheduler_EDF_Update_priority(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40007a5c: 9d e3 bf a0 save %sp, -96, %sp
Scheduler_EDF_Context *context;
Scheduler_EDF_Node *the_node;
Priority_Control priority;
Priority_Control insert_priority;
if ( !_Thread_Is_ready( the_thread ) ) {
40007a60: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
40007a64: 80 a0 60 00 cmp %g1, 0
40007a68: 12 80 00 4d bne 40007b9c <_Scheduler_EDF_Update_priority+0x140>
40007a6c: 01 00 00 00 nop
/* Nothing to do */
return;
}
the_node = _Scheduler_EDF_Node_downcast( node );
insert_priority = _Scheduler_Node_get_priority( &the_node->Base );
40007a70: fa 06 a0 30 ld [ %i2 + 0x30 ], %i5
40007a74: f8 06 a0 34 ld [ %i2 + 0x34 ], %i4
priority = SCHEDULER_PRIORITY_PURIFY( insert_priority );
if ( priority == the_node->priority ) {
40007a78: c4 06 a0 48 ld [ %i2 + 0x48 ], %g2
40007a7c: 80 a0 80 1d cmp %g2, %i5
40007a80: 02 80 00 34 be 40007b50 <_Scheduler_EDF_Update_priority+0xf4>
40007a84: 82 0f 3f fe and %i4, -2, %g1
/* Nothing to do */
return;
}
the_node->priority = priority;
40007a88: c2 26 a0 4c st %g1, [ %i2 + 0x4c ]
_RBTree_Extract( &context->Ready, &node->Node );
40007a8c: b6 06 a0 38 add %i2, 0x38, %i3
40007a90: fa 26 a0 48 st %i5, [ %i2 + 0x48 ]
40007a94: 92 10 00 1b mov %i3, %o1
40007a98: f2 06 00 00 ld [ %i0 ], %i1
40007a9c: 40 00 01 2b call 40007f48 <_RBTree_Extract>
40007aa0: 90 10 00 19 mov %i1, %o0
{
RBTree_Node **link;
RBTree_Node *parent;
bool is_new_minimum;
link = _RBTree_Root_reference( the_rbtree );
40007aa4: 84 10 00 19 mov %i1, %g2
parent = NULL;
is_new_minimum = true;
while ( *link != NULL ) {
40007aa8: c2 00 80 00 ld [ %g2 ], %g1
40007aac: 80 a0 60 00 cmp %g1, 0
40007ab0: 02 80 00 12 be 40007af8 <_Scheduler_EDF_Update_priority+0x9c>
<== NEVER TAKEN
40007ab4: 86 10 20 00 clr %g3
parent = *link;
if ( ( *less )( key, parent ) ) {
40007ab8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
40007abc: 80 a0 80 1d cmp %g2, %i5
40007ac0: 0a 80 00 09 bcs 40007ae4 <_Scheduler_EDF_Update_priority+0x88>
40007ac4: 84 00 60 04 add %g1, 4, %g2
40007ac8: 12 80 00 28 bne 40007b68 <_Scheduler_EDF_Update_priority+0x10c>
40007acc: 84 10 00 01 mov %g1, %g2
40007ad0: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
40007ad4: 80 a0 80 1c cmp %g2, %i4
40007ad8: 1a 80 00 24 bcc 40007b68 <_Scheduler_EDF_Update_priority+0x10c>
40007adc: 84 10 00 01 mov %g1, %g2
return &RB_RIGHT( the_node, Node );
40007ae0: 84 00 60 04 add %g1, 4, %g2
{
40007ae4: 86 10 00 01 mov %g1, %g3
while ( *link != NULL ) {
40007ae8: c2 00 80 00 ld [ %g2 ], %g1
40007aec: 80 a0 60 00 cmp %g1, 0
40007af0: 32 bf ff f3 bne,a 40007abc <_Scheduler_EDF_Update_priority+0x60>
40007af4: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
RB_SET( child, parent, Node );
40007af8: c6 26 a0 40 st %g3, [ %i2 + 0x40 ]
40007afc: a0 10 20 01 mov 1, %l0
40007b00: 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 );
40007b04: 92 10 00 1b mov %i3, %o1
RB_SET( child, parent, Node );
40007b08: c0 26 a0 38 clr [ %i2 + 0x38 ]
_RBTree_Insert_color( the_rbtree, the_node );
40007b0c: 90 10 00 19 mov %i1, %o0
RB_SET( child, parent, Node );
40007b10: e0 26 a0 44 st %l0, [ %i2 + 0x44 ]
_RBTree_Insert_color( the_rbtree, the_node );
40007b14: 40 00 02 6f call 400084d0 <_RBTree_Insert_color>
40007b18: f6 20 80 00 st %i3, [ %g2 ]
first = _RBTree_Minimum( &context->Ready );
40007b1c: 40 00 03 09 call 40008740 <_RBTree_Minimum>
40007b20: d0 06 00 00 ld [ %i0 ], %o0
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
40007b24: f6 02 3f c8 ld [ %o0 + -56 ], %i3
Thread_Control *heir = _Thread_Heir;
40007b28: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40007b2c: 80 a6 c0 1d cmp %i3, %i5
40007b30: 02 80 00 06 be 40007b48 <_Scheduler_EDF_Update_priority+0xec>
40007b34: b8 10 00 06 mov %g6, %i4
40007b38: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1
40007b3c: 80 a0 60 00 cmp %g1, 0
40007b40: 12 80 00 0c bne 40007b70 <_Scheduler_EDF_Update_priority+0x114>
<== ALWAYS TAKEN
40007b44: 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 );
}
40007b48: 81 c7 e0 08 ret
40007b4c: 81 e8 00 00 restore
if ( priority == the_node->priority ) {
40007b50: c4 06 a0 4c ld [ %i2 + 0x4c ], %g2
40007b54: 80 a0 80 01 cmp %g2, %g1
40007b58: 32 bf ff cd bne,a 40007a8c <_Scheduler_EDF_Update_priority+0x30>
<== ALWAYS TAKEN
40007b5c: c2 26 a0 4c st %g1, [ %i2 + 0x4c ]
}
40007b60: 81 c7 e0 08 ret
<== NOT EXECUTED
40007b64: 81 e8 00 00 restore
<== NOT EXECUTED
{
40007b68: 10 bf ff e0 b 40007ae8 <_Scheduler_EDF_Update_priority+0x8c>
40007b6c: 86 10 00 01 mov %g1, %g3
40007b70: 40 00 11 32 call 4000c038 <_Timecounter_Sbinuptime>
40007b74: f0 19 a0 28 ldd [ %g6 + 0x28 ], %i0
40007b78: d0 3f 20 28 std %o0, [ %i4 + 0x28 ]
*_result = *_end - *_start;
40007b7c: 9a a2 40 19 subcc %o1, %i1, %o5
40007b80: 98 62 00 18 subx %o0, %i0, %o4
*_time += *_add;
40007b84: f0 1f 60 98 ldd [ %i5 + 0x98 ], %i0
40007b88: 86 86 40 0d addcc %i1, %o5, %g3
40007b8c: 84 46 00 0c addx %i0, %o4, %g2
40007b90: c4 3f 60 98 std %g2, [ %i5 + 0x98 ]
_Thread_Heir = new_heir;
40007b94: f6 21 a0 24 st %i3, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
40007b98: e0 29 a0 1c stb %l0, [ %g6 + 0x1c ]
}
40007b9c: 81 c7 e0 08 ret
40007ba0: 81 e8 00 00 restore
40007cd0 <_Scheduler_EDF_Yield>:
void _Scheduler_EDF_Yield(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40007cd0: 9d e3 bf a0 save %sp, -96, %sp
_RBTree_Extract( &context->Ready, &node->Node );
40007cd4: f8 06 00 00 ld [ %i0 ], %i4
40007cd8: 90 10 00 1c mov %i4, %o0
40007cdc: ba 06 a0 38 add %i2, 0x38, %i5
40007ce0: 40 00 00 9a call 40007f48 <_RBTree_Extract>
40007ce4: 92 10 00 1d mov %i5, %o1
link = _RBTree_Root_reference( the_rbtree );
40007ce8: 84 10 00 1c mov %i4, %g2
while ( *link != NULL ) {
40007cec: c2 00 80 00 ld [ %g2 ], %g1
context = _Scheduler_EDF_Get_context( scheduler );
the_node = _Scheduler_EDF_Node_downcast( node );
_Scheduler_EDF_Extract( context, the_node );
_Scheduler_EDF_Enqueue( context, the_node, the_node->priority );
40007cf0: c8 06 a0 48 ld [ %i2 + 0x48 ], %g4
40007cf4: f6 06 a0 4c ld [ %i2 + 0x4c ], %i3
40007cf8: 80 a0 60 00 cmp %g1, 0
40007cfc: 02 80 00 12 be 40007d44 <_Scheduler_EDF_Yield+0x74>
<== NEVER TAKEN
40007d00: 86 10 20 00 clr %g3
if ( ( *less )( key, parent ) ) {
40007d04: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
40007d08: 80 a0 80 04 cmp %g2, %g4
40007d0c: 0a 80 00 09 bcs 40007d30 <_Scheduler_EDF_Yield+0x60>
<== NEVER TAKEN
40007d10: 84 00 60 04 add %g1, 4, %g2
40007d14: 12 80 00 29 bne 40007db8 <_Scheduler_EDF_Yield+0xe8>
<== NEVER TAKEN
40007d18: 84 10 00 01 mov %g1, %g2
40007d1c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
40007d20: 80 a0 80 1b cmp %g2, %i3
40007d24: 1a 80 00 25 bcc 40007db8 <_Scheduler_EDF_Yield+0xe8>
40007d28: 84 10 00 01 mov %g1, %g2
return &RB_RIGHT( the_node, Node );
40007d2c: 84 00 60 04 add %g1, 4, %g2
{
40007d30: 86 10 00 01 mov %g1, %g3
while ( *link != NULL ) {
40007d34: c2 00 80 00 ld [ %g2 ], %g1
40007d38: 80 a0 60 00 cmp %g1, 0
40007d3c: 32 bf ff f3 bne,a 40007d08 <_Scheduler_EDF_Yield+0x38>
40007d40: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
RB_SET( child, parent, Node );
40007d44: c6 26 a0 40 st %g3, [ %i2 + 0x40 ]
40007d48: b6 10 20 01 mov 1, %i3
40007d4c: c0 26 a0 3c clr [ %i2 + 0x3c ]
_RBTree_Insert_color( the_rbtree, the_node );
40007d50: 92 10 00 1d mov %i5, %o1
RB_SET( child, parent, Node );
40007d54: c0 26 a0 38 clr [ %i2 + 0x38 ]
_RBTree_Insert_color( the_rbtree, the_node );
40007d58: 90 10 00 1c mov %i4, %o0
RB_SET( child, parent, Node );
40007d5c: f6 26 a0 44 st %i3, [ %i2 + 0x44 ]
_RBTree_Insert_color( the_rbtree, the_node );
40007d60: 40 00 01 dc call 400084d0 <_RBTree_Insert_color>
40007d64: fa 20 80 00 st %i5, [ %g2 ]
first = _RBTree_Minimum( &context->Ready );
40007d68: 40 00 02 76 call 40008740 <_RBTree_Minimum>
40007d6c: d0 06 00 00 ld [ %i0 ], %o0
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
40007d70: f4 02 3f c8 ld [ %o0 + -56 ], %i2
Thread_Control *heir = _Thread_Heir;
40007d74: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40007d78: 80 a6 80 1d cmp %i2, %i5
40007d7c: 02 80 00 0d be 40007db0 <_Scheduler_EDF_Yield+0xe0>
<== NEVER TAKEN
40007d80: b8 10 00 06 mov %g6, %i4
40007d84: 40 00 10 ad call 4000c038 <_Timecounter_Sbinuptime>
40007d88: f0 19 a0 28 ldd [ %g6 + 0x28 ], %i0
40007d8c: d0 3f 20 28 std %o0, [ %i4 + 0x28 ]
*_result = *_end - *_start;
40007d90: 9a a2 40 19 subcc %o1, %i1, %o5
40007d94: 98 62 00 18 subx %o0, %i0, %o4
*_time += *_add;
40007d98: f0 1f 60 98 ldd [ %i5 + 0x98 ], %i0
40007d9c: 86 86 40 0d addcc %i1, %o5, %g3
40007da0: 84 46 00 0c addx %i0, %o4, %g2
40007da4: c4 3f 60 98 std %g2, [ %i5 + 0x98 ]
_Thread_Heir = new_heir;
40007da8: f4 21 a0 24 st %i2, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
40007dac: f6 29 a0 1c stb %i3, [ %g6 + 0x1c ]
_Scheduler_EDF_Schedule_body( scheduler, the_thread, true );
}
40007db0: 81 c7 e0 08 ret
40007db4: 81 e8 00 00 restore
{
40007db8: 10 bf ff df b 40007d34 <_Scheduler_EDF_Yield+0x64>
40007dbc: 86 10 00 01 mov %g1, %g3
40013d60 <_Scheduler_Set_affinity>:
bool _Scheduler_Set_affinity(
Thread_Control *the_thread,
size_t cpusetsize,
const cpu_set_t *cpuset
)
{
40013d60: 9d e3 bf 98 save %sp, -104, %sp
Processor_mask *dst,
size_t src_size,
const cpu_set_t *src
)
{
return _Processor_mask_Copy(
40013d64: 92 10 20 04 mov 4, %o1
40013d68: 96 10 00 19 mov %i1, %o3
40013d6c: 94 10 00 1a mov %i2, %o2
40013d70: 90 07 bf fc add %fp, -4, %o0
40013d74: 40 00 11 ad call 40018428 <_Processor_mask_Copy>
40013d78: 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 ) ) {
40013d7c: 80 a2 20 01 cmp %o0, 1
40013d80: 38 80 00 09 bgu,a 40013da4 <_Scheduler_Set_affinity+0x44>
<== NEVER TAKEN
40013d84: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
BIT_AND2( CPU_MAXIMUM_PROCESSORS, a, b, c );
40013d88: 03 10 01 85 sethi %hi(0x40061400), %g1
40013d8c: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 400615d0 <_Processor_mask_The_one_and_only>
return BIT_SUBSET( CPU_MAXIMUM_PROCESSORS, big, small );
40013d90: c2 07 bf fc ld [ %fp + -4 ], %g1
40013d94: 82 28 80 01 andn %g2, %g1, %g1
40013d98: 80 a0 00 01 cmp %g0, %g1
40013d9c: b0 60 3f ff subx %g0, -1, %i0
);
#endif
_Scheduler_Release_critical( scheduler, &lock_context );
return ok;
}
40013da0: b0 0e 20 01 and %i0, 1, %i0
40013da4: 81 c7 e0 08 ret
40013da8: 81 e8 00 00 restore
400074f8 <_Scheduler_default_Tick>:
void _Scheduler_default_Tick(
const Scheduler_Control *scheduler,
Thread_Control *executing
)
{
400074f8: 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 )
400074fc: c2 0e 60 89 ldub [ %i1 + 0x89 ], %g1
40007500: 80 a0 60 00 cmp %g1, 0
40007504: 02 80 00 24 be 40007594 <_Scheduler_default_Tick+0x9c>
40007508: 01 00 00 00 nop
return;
if ( !_States_Is_ready( executing->current_state ) )
4000750c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
40007510: 80 a0 60 00 cmp %g1, 0
40007514: 12 80 00 20 bne 40007594 <_Scheduler_default_Tick+0x9c>
40007518: 01 00 00 00 nop
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
4000751c: c2 06 60 90 ld [ %i1 + 0x90 ], %g1
40007520: 80 a0 60 01 cmp %g1, 1
40007524: 0a 80 00 0e bcs 4000755c <_Scheduler_default_Tick+0x64>
40007528: 80 a0 60 02 cmp %g1, 2
4000752c: 08 80 00 0e bleu 40007564 <_Scheduler_default_Tick+0x6c>
40007530: 80 a0 60 03 cmp %g1, 3
40007534: 12 80 00 18 bne 40007594 <_Scheduler_default_Tick+0x9c>
<== NEVER TAKEN
40007538: 01 00 00 00 nop
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
4000753c: c2 06 60 8c ld [ %i1 + 0x8c ], %g1
40007540: 82 00 7f ff add %g1, -1, %g1
40007544: 80 a0 60 00 cmp %g1, 0
40007548: 12 80 00 05 bne 4000755c <_Scheduler_default_Tick+0x64>
4000754c: c2 26 60 8c st %g1, [ %i1 + 0x8c ]
(*executing->budget_callout)( executing );
40007550: c2 06 60 94 ld [ %i1 + 0x94 ], %g1
40007554: 9f c0 40 00 call %g1
40007558: 90 10 00 19 mov %i1, %o0
break;
#endif
}
}
4000755c: 81 c7 e0 08 ret
40007560: 81 e8 00 00 restore
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
40007564: c2 06 60 8c ld [ %i1 + 0x8c ], %g1
40007568: 82 00 7f ff add %g1, -1, %g1
4000756c: 80 a0 60 00 cmp %g1, 0
40007570: 14 bf ff fb bg 4000755c <_Scheduler_default_Tick+0x64>
40007574: c2 26 60 8c st %g1, [ %i1 + 0x8c ]
_Thread_Yield( executing );
40007578: 40 00 03 e5 call 4000850c <_Thread_Yield>
4000757c: 90 10 00 19 mov %i1, %o0
executing->cpu_time_budget =
40007580: 03 10 00 5d sethi %hi(0x40017400), %g1
40007584: c2 00 62 7c ld [ %g1 + 0x27c ], %g1 ! 4001767c <_Watchdog_Ticks_per_timeslice>
40007588: c2 26 60 8c st %g1, [ %i1 + 0x8c ]
4000758c: 81 c7 e0 08 ret
40007590: 81 e8 00 00 restore
40007594: 81 c7 e0 08 ret
40007598: 81 e8 00 00 restore
40007970 <_Scheduler_priority_Schedule>:
void _Scheduler_priority_Schedule(
const Scheduler_Control *scheduler,
Thread_Control *the_thread
)
{
40007970: 9d e3 bf a0 save %sp, -96, %sp
return (Scheduler_priority_Context *) _Scheduler_Get_context( scheduler );
40007974: f8 06 00 00 ld [ %i0 ], %i4
bit_number = (unsigned int) __builtin_clz( value )
40007978: 40 00 1b 81 call 4000e77c <__clzsi2>
4000797c: d0 17 00 00 lduh [ %i4 ], %o0
40007980: ba 02 3f f0 add %o0, -16, %i5
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
40007984: 83 2f 60 01 sll %i5, 1, %g1
return (_Priority_Bits_index( major ) << 4) +
40007988: bb 2f 60 04 sll %i5, 4, %i5
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
4000798c: 82 07 00 01 add %i4, %g1, %g1
bit_number = (unsigned int) __builtin_clz( value )
40007990: 40 00 1b 7b call 4000e77c <__clzsi2>
40007994: d0 10 60 02 lduh [ %g1 + 2 ], %o0
Chain_Node *first = _Chain_First( &ready_queues[ index ] );
40007998: 90 02 00 1d add %o0, %i5, %o0
4000799c: 90 02 3f f0 add %o0, -16, %o0
return _Chain_Immutable_head( the_chain )->next;
400079a0: bb 2a 20 01 sll %o0, 1, %i5
Thread_Control *heir = _Thread_Heir;
400079a4: f6 01 a0 24 ld [ %g6 + 0x24 ], %i3
400079a8: 90 07 40 08 add %i5, %o0, %o0
400079ac: 91 2a 20 02 sll %o0, 2, %o0
400079b0: b8 07 00 08 add %i4, %o0, %i4
400079b4: fa 07 20 24 ld [ %i4 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
400079b8: 80 a7 40 1b cmp %i5, %i3
400079bc: 02 80 00 06 be 400079d4 <_Scheduler_priority_Schedule+0x64>
400079c0: b4 10 00 06 mov %g6, %i2
400079c4: c2 0e e0 89 ldub [ %i3 + 0x89 ], %g1
400079c8: 80 a0 60 00 cmp %g1, 0
400079cc: 12 80 00 04 bne 400079dc <_Scheduler_priority_Schedule+0x6c>
<== ALWAYS TAKEN
400079d0: 01 00 00 00 nop
_Scheduler_priority_Schedule_body( scheduler, the_thread, false );
}
400079d4: 81 c7 e0 08 ret
400079d8: 81 e8 00 00 restore
400079dc: 40 00 0c a7 call 4000ac78 <_Timecounter_Sbinuptime>
400079e0: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0
400079e4: d0 3e a0 28 std %o0, [ %i2 + 0x28 ]
*_result = *_end - *_start;
400079e8: b2 a2 40 11 subcc %o1, %l1, %i1
*_time += *_add;
400079ec: d8 1e e0 98 ldd [ %i3 + 0x98 ], %o4
*_result = *_end - *_start;
400079f0: b0 62 00 10 subx %o0, %l0, %i0
*_time += *_add;
400079f4: 86 83 40 19 addcc %o5, %i1, %g3
400079f8: 84 43 00 18 addx %o4, %i0, %g2
400079fc: c4 3e e0 98 std %g2, [ %i3 + 0x98 ]
_Thread_Dispatch_necessary = true;
40007a00: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
40007a04: fa 21 a0 24 st %i5, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
40007a08: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
40007a0c: 81 c7 e0 08 ret
40007a10: 81 e8 00 00 restore
40007a14 <_Scheduler_priority_Unblock>:
void _Scheduler_priority_Unblock (
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40007a14: 9d e3 bf a0 save %sp, -96, %sp
unsigned int priority;
unsigned int unmapped_priority;
context = _Scheduler_priority_Get_context( scheduler );
the_node = _Scheduler_priority_Node_downcast( node );
priority = (unsigned int ) _Scheduler_Node_get_priority( &the_node->Base );
40007a18: f6 06 a0 34 ld [ %i2 + 0x34 ], %i3
unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority );
if ( unmapped_priority != the_node->Ready_queue.current_priority ) {
40007a1c: c2 06 a0 38 ld [ %i2 + 0x38 ], %g1
unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority );
40007a20: 87 36 e0 01 srl %i3, 1, %g3
if ( unmapped_priority != the_node->Ready_queue.current_priority ) {
40007a24: 80 a0 40 03 cmp %g1, %g3
40007a28: 02 80 00 4a be 40007b50 <_Scheduler_priority_Unblock+0x13c>
40007a2c: fa 06 00 00 ld [ %i0 ], %i5
ready_queue->ready_chain = &ready_queues[ new_priority ];
40007a30: b9 28 e0 01 sll %g3, 1, %i4
40007a34: b8 07 00 03 add %i4, %g3, %i4
40007a38: b9 2f 20 02 sll %i4, 2, %i4
_Scheduler_priority_Ready_queue_update(
40007a3c: 84 07 60 24 add %i5, 0x24, %g2
40007a40: 84 00 80 1c add %g2, %i4, %g2
return the_priority % 16;
40007a44: b8 08 e0 0f and %g3, 0xf, %i4
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
40007a48: 09 00 00 20 sethi %hi(0x8000), %g4
return the_priority / 16;
40007a4c: 83 36 e0 05 srl %i3, 5, %g1
ready_queue->current_priority = new_priority;
40007a50: c6 26 a0 38 st %g3, [ %i2 + 0x38 ]
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
40007a54: b1 31 00 01 srl %g4, %g1, %i0
40007a58: 87 31 00 1c srl %g4, %i4, %g3
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
40007a5c: 82 00 60 01 inc %g1
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
40007a60: 9e 38 00 18 xnor %g0, %i0, %o7
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
40007a64: 83 28 60 01 sll %g1, 1, %g1
bit_map_info->block_minor = (Priority_bit_map_Word) ~mask;
40007a68: b8 38 00 03 xnor %g0, %g3, %i4
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
40007a6c: 82 07 40 01 add %i5, %g1, %g1
ready_queue->ready_chain = &ready_queues[ new_priority ];
40007a70: c4 26 a0 3c st %g2, [ %i2 + 0x3c ]
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
40007a74: 88 10 00 03 mov %g3, %g4
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
40007a78: c2 26 a0 40 st %g1, [ %i2 + 0x40 ]
bit_map_info->ready_major = mask;
40007a7c: f0 36 a0 44 sth %i0, [ %i2 + 0x44 ]
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
40007a80: de 36 a0 48 sth %o7, [ %i2 + 0x48 ]
bit_map_info->ready_minor = mask;
40007a84: c6 36 a0 46 sth %g3, [ %i2 + 0x46 ]
bit_map_info->block_minor = (Priority_bit_map_Word) ~mask;
40007a88: f8 36 a0 4a sth %i4, [ %i2 + 0x4a ]
return &the_chain->Tail.Node;
40007a8c: b8 00 a0 04 add %g2, 4, %i4
old_last = tail->previous;
40007a90: c6 00 a0 08 ld [ %g2 + 8 ], %g3
the_node->next = tail;
40007a94: f8 26 40 00 st %i4, [ %i1 ]
tail->previous = the_node;
40007a98: f2 20 a0 08 st %i1, [ %g2 + 8 ]
old_last->next = the_node;
40007a9c: f2 20 c0 00 st %i1, [ %g3 ]
*bit_map_info->minor |= bit_map_info->ready_minor;
40007aa0: c4 10 40 00 lduh [ %g1 ], %g2
the_node->previous = old_last;
40007aa4: c6 26 60 04 st %g3, [ %i1 + 4 ]
40007aa8: 84 10 80 04 or %g2, %g4, %g2
40007aac: 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 ) ) {
40007ab0: f8 01 a0 24 ld [ %g6 + 0x24 ], %i4
bit_map->major_bit_map |= bit_map_info->ready_major;
40007ab4: c4 16 a0 44 lduh [ %i2 + 0x44 ], %g2
40007ab8: c2 17 40 00 lduh [ %i5 ], %g1
40007abc: 82 10 40 02 or %g1, %g2, %g1
return _Priority_Get_priority( &scheduler_node->Wait.Priority );
40007ac0: c4 07 20 38 ld [ %i4 + 0x38 ], %g2
40007ac4: c2 37 40 00 sth %g1, [ %i5 ]
40007ac8: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1
40007acc: 80 a0 60 00 cmp %g1, 0
40007ad0: 18 80 00 09 bgu 40007af4 <_Scheduler_priority_Unblock+0xe0>
<== NEVER TAKEN
40007ad4: b0 10 00 06 mov %g6, %i0
40007ad8: 22 80 00 04 be,a 40007ae8 <_Scheduler_priority_Unblock+0xd4>
<== ALWAYS TAKEN
40007adc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1
_Scheduler_Update_heir( the_thread, priority == PRIORITY_PSEUDO_ISR );
}
}
40007ae0: 81 c7 e0 08 ret
<== NOT EXECUTED
40007ae4: 81 e8 00 00 restore
<== NOT EXECUTED
if ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
40007ae8: 80 a0 40 1b cmp %g1, %i3
40007aec: 08 80 00 17 bleu 40007b48 <_Scheduler_priority_Unblock+0x134>
40007af0: 01 00 00 00 nop
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40007af4: 80 a7 00 19 cmp %i4, %i1
40007af8: 02 bf ff fa be 40007ae0 <_Scheduler_priority_Unblock+0xcc>
<== NEVER TAKEN
40007afc: 80 a6 e0 00 cmp %i3, 0
40007b00: 02 80 00 06 be 40007b18 <_Scheduler_priority_Unblock+0x104>
40007b04: 01 00 00 00 nop
40007b08: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1
40007b0c: 80 a0 60 00 cmp %g1, 0
40007b10: 02 80 00 0e be 40007b48 <_Scheduler_priority_Unblock+0x134>
40007b14: 01 00 00 00 nop
40007b18: 40 00 0c 58 call 4000ac78 <_Timecounter_Sbinuptime>
40007b1c: e0 1e 20 28 ldd [ %i0 + 0x28 ], %l0
40007b20: d0 3e 20 28 std %o0, [ %i0 + 0x28 ]
*_result = *_end - *_start;
40007b24: b6 a2 40 11 subcc %o1, %l1, %i3
*_time += *_add;
40007b28: d8 1f 20 98 ldd [ %i4 + 0x98 ], %o4
*_result = *_end - *_start;
40007b2c: b4 62 00 10 subx %o0, %l0, %i2
*_time += *_add;
40007b30: 86 83 40 1b addcc %o5, %i3, %g3
40007b34: 84 43 00 1a addx %o4, %i2, %g2
40007b38: c4 3f 20 98 std %g2, [ %i4 + 0x98 ]
_Thread_Dispatch_necessary = true;
40007b3c: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
40007b40: f2 21 a0 24 st %i1, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
40007b44: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
}
40007b48: 81 c7 e0 08 ret
40007b4c: 81 e8 00 00 restore
40007b50: c4 06 a0 3c ld [ %i2 + 0x3c ], %g2
40007b54: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1
40007b58: 10 bf ff cd b 40007a8c <_Scheduler_priority_Unblock+0x78>
40007b5c: c8 16 a0 46 lduh [ %i2 + 0x46 ], %g4
40007944 <_Scheduler_simple_Block>:
void _Scheduler_simple_Block(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40007944: 9d e3 bf a0 save %sp, -96, %sp
previous = the_node->previous;
40007948: c2 06 60 04 ld [ %i1 + 4 ], %g1
next = the_node->next;
4000794c: c4 06 40 00 ld [ %i1 ], %g2
next->previous = previous;
40007950: c2 20 a0 04 st %g1, [ %g2 + 4 ]
return ( the_thread == _Thread_Executing );
40007954: ba 10 00 06 mov %g6, %i5
previous->next = next;
40007958: 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 ) ) {
4000795c: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1
40007960: 80 a6 40 01 cmp %i1, %g1
40007964: 02 80 00 07 be 40007980 <_Scheduler_simple_Block+0x3c>
40007968: f8 01 a0 24 ld [ %g6 + 0x24 ], %i4
4000796c: 80 a6 40 1c cmp %i1, %i4
40007970: 22 80 00 05 be,a 40007984 <_Scheduler_simple_Block+0x40>
<== NEVER TAKEN
40007974: c2 06 00 00 ld [ %i0 ], %g1
<== NOT EXECUTED
the_thread,
node,
_Scheduler_simple_Extract,
_Scheduler_simple_Schedule_body
);
}
40007978: 81 c7 e0 08 ret
4000797c: 81 e8 00 00 restore
return _Chain_Immutable_head( the_chain )->next;
40007980: c2 06 00 00 ld [ %i0 ], %g1
40007984: f6 00 40 00 ld [ %g1 ], %i3
bool force_dispatch
)
{
Thread_Control *heir = _Thread_Heir;
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40007988: 80 a6 c0 1c cmp %i3, %i4
4000798c: 02 80 00 0e be 400079c4 <_Scheduler_simple_Block+0x80>
<== NEVER TAKEN
40007990: 01 00 00 00 nop
*time = _Timecounter_Sbinuptime();
40007994: 40 00 0f 29 call 4000b638 <_Timecounter_Sbinuptime>
40007998: e0 1f 60 28 ldd [ %i5 + 0x28 ], %l0
4000799c: d0 3f 60 28 std %o0, [ %i5 + 0x28 ]
const Timestamp_Control *_start,
const Timestamp_Control *_end,
Timestamp_Control *_result
)
{
*_result = *_end - *_start;
400079a0: b2 a2 40 11 subcc %o1, %l1, %i1
*_time += *_add;
400079a4: d8 1f 20 98 ldd [ %i4 + 0x98 ], %o4
*_result = *_end - *_start;
400079a8: b0 62 00 10 subx %o0, %l0, %i0
*_time += *_add;
400079ac: 86 83 40 19 addcc %o5, %i1, %g3
400079b0: 84 43 00 18 addx %o4, %i0, %g2
400079b4: 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;
400079b8: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
400079bc: f6 21 a0 24 st %i3, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
400079c0: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
400079c4: 81 c7 e0 08 ret
400079c8: 81 e8 00 00 restore
40007adc <_Scheduler_simple_Schedule>:
void _Scheduler_simple_Schedule(
const Scheduler_Control *scheduler,
Thread_Control *the_thread
)
{
40007adc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
40007ae0: c2 06 00 00 ld [ %i0 ], %g1
<== NOT EXECUTED
40007ae4: f6 00 40 00 ld [ %g1 ], %i3
<== NOT EXECUTED
Thread_Control *heir = _Thread_Heir;
40007ae8: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
<== NOT EXECUTED
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40007aec: 80 a6 c0 1d cmp %i3, %i5
<== NOT EXECUTED
40007af0: 02 80 00 06 be 40007b08 <_Scheduler_simple_Schedule+0x2c>
<== NOT EXECUTED
40007af4: b8 10 00 06 mov %g6, %i4
<== NOT EXECUTED
40007af8: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1
<== NOT EXECUTED
40007afc: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40007b00: 12 80 00 04 bne 40007b10 <_Scheduler_simple_Schedule+0x34>
<== NOT EXECUTED
40007b04: 01 00 00 00 nop
<== NOT EXECUTED
_Scheduler_simple_Schedule_body( scheduler, the_thread, false );
}
40007b08: 81 c7 e0 08 ret
<== NOT EXECUTED
40007b0c: 81 e8 00 00 restore
<== NOT EXECUTED
40007b10: 40 00 0e ca call 4000b638 <_Timecounter_Sbinuptime>
<== NOT EXECUTED
40007b14: e0 19 a0 28 ldd [ %g6 + 0x28 ], %l0
<== NOT EXECUTED
40007b18: d0 3f 20 28 std %o0, [ %i4 + 0x28 ]
<== NOT EXECUTED
*_result = *_end - *_start;
40007b1c: b2 a2 40 11 subcc %o1, %l1, %i1
<== NOT EXECUTED
*_time += *_add;
40007b20: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4
<== NOT EXECUTED
*_result = *_end - *_start;
40007b24: b0 62 00 10 subx %o0, %l0, %i0
<== NOT EXECUTED
*_time += *_add;
40007b28: 86 83 40 19 addcc %o5, %i1, %g3
<== NOT EXECUTED
40007b2c: 84 43 00 18 addx %o4, %i0, %g2
<== NOT EXECUTED
40007b30: c4 3f 60 98 std %g2, [ %i5 + 0x98 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40007b34: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
_Thread_Heir = new_heir;
40007b38: f6 21 a0 24 st %i3, [ %g6 + 0x24 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40007b3c: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
<== NOT EXECUTED
40007b40: 81 c7 e0 08 ret
<== NOT EXECUTED
40007b44: 81 e8 00 00 restore
<== NOT EXECUTED
40007b48 <_Scheduler_simple_Unblock>:
void _Scheduler_simple_Unblock(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40007b48: 9d e3 bf a0 save %sp, -96, %sp
40007b4c: c6 06 00 00 ld [ %i0 ], %g3
40007b50: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
40007b54: f8 00 60 1c ld [ %g1 + 0x1c ], %i4
40007b58: c2 00 c0 00 ld [ %g3 ], %g1
return &the_chain->Tail.Node;
40007b5c: 86 00 e0 04 add %g3, 4, %g3
while ( next != tail && !( *order )( left, next ) ) {
40007b60: 80 a0 c0 01 cmp %g3, %g1
40007b64: 02 80 00 18 be 40007bc4 <_Scheduler_simple_Unblock+0x7c>
40007b68: b6 17 20 01 or %i4, 1, %i3
40007b6c: c4 00 60 38 ld [ %g1 + 0x38 ], %g2
40007b70: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
40007b74: 80 a1 20 00 cmp %g4, 0
40007b78: 12 80 00 12 bne 40007bc0 <_Scheduler_simple_Unblock+0x78>
<== NEVER TAKEN
40007b7c: ba 10 20 00 clr %i5
40007b80: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
40007b84: 80 a0 80 1b cmp %g2, %i3
40007b88: 3a 80 00 0f bcc,a 40007bc4 <_Scheduler_simple_Unblock+0x7c>
40007b8c: 86 10 00 01 mov %g1, %g3
next = _Chain_Next( next );
40007b90: c2 00 40 00 ld [ %g1 ], %g1
while ( next != tail && !( *order )( left, next ) ) {
40007b94: 80 a0 c0 01 cmp %g3, %g1
40007b98: 22 80 00 0c be,a 40007bc8 <_Scheduler_simple_Unblock+0x80>
40007b9c: c2 00 e0 04 ld [ %g3 + 4 ], %g1
40007ba0: c4 00 60 38 ld [ %g1 + 0x38 ], %g2
40007ba4: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
40007ba8: 80 a7 40 04 cmp %i5, %g4
40007bac: 12 80 00 05 bne 40007bc0 <_Scheduler_simple_Unblock+0x78>
<== NEVER TAKEN
40007bb0: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
40007bb4: 80 a6 c0 02 cmp %i3, %g2
40007bb8: 38 bf ff f7 bgu,a 40007b94 <_Scheduler_simple_Unblock+0x4c>
40007bbc: c2 00 40 00 ld [ %g1 ], %g1
40007bc0: 86 10 00 01 mov %g1, %g3
_Chain_Insert_unprotected( _Chain_Previous( next ), to_insert );
40007bc4: c2 00 e0 04 ld [ %g3 + 4 ], %g1
the_node->previous = after_node;
40007bc8: c2 26 60 04 st %g1, [ %i1 + 4 ]
before_node = after_node->next;
40007bcc: c4 00 40 00 ld [ %g1 ], %g2
after_node->next = the_node;
40007bd0: f2 20 40 00 st %i1, [ %g1 ]
the_node->next = before_node;
40007bd4: 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 ) ) {
40007bd8: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
40007bdc: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
before_node->previous = the_node;
40007be0: f2 20 a0 04 st %i1, [ %g2 + 4 ]
40007be4: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
40007be8: 80 a0 a0 00 cmp %g2, 0
40007bec: 18 80 00 09 bgu 40007c10 <_Scheduler_simple_Unblock+0xc8>
<== NEVER TAKEN
40007bf0: b6 10 00 06 mov %g6, %i3
40007bf4: 22 80 00 04 be,a 40007c04 <_Scheduler_simple_Unblock+0xbc>
<== ALWAYS TAKEN
40007bf8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
_Scheduler_Update_heir(
the_thread,
priority == PRIORITY_PSEUDO_ISR
);
}
}
40007bfc: 81 c7 e0 08 ret
<== NOT EXECUTED
40007c00: 81 e8 00 00 restore
<== NOT EXECUTED
if ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
40007c04: 80 a0 40 1c cmp %g1, %i4
40007c08: 08 80 00 17 bleu 40007c64 <_Scheduler_simple_Unblock+0x11c>
40007c0c: 01 00 00 00 nop
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40007c10: 80 a7 40 19 cmp %i5, %i1
40007c14: 02 bf ff fa be 40007bfc <_Scheduler_simple_Unblock+0xb4>
<== NEVER TAKEN
40007c18: 80 a7 20 00 cmp %i4, 0
40007c1c: 02 80 00 06 be 40007c34 <_Scheduler_simple_Unblock+0xec>
40007c20: 01 00 00 00 nop
40007c24: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1
40007c28: 80 a0 60 00 cmp %g1, 0
40007c2c: 02 80 00 0e be 40007c64 <_Scheduler_simple_Unblock+0x11c>
40007c30: 01 00 00 00 nop
40007c34: 40 00 0e 81 call 4000b638 <_Timecounter_Sbinuptime>
40007c38: e0 1e e0 28 ldd [ %i3 + 0x28 ], %l0
40007c3c: d0 3e e0 28 std %o0, [ %i3 + 0x28 ]
*_result = *_end - *_start;
40007c40: b6 a2 40 11 subcc %o1, %l1, %i3
*_time += *_add;
40007c44: d8 1f 60 98 ldd [ %i5 + 0x98 ], %o4
*_result = *_end - *_start;
40007c48: b4 62 00 10 subx %o0, %l0, %i2
*_time += *_add;
40007c4c: 86 83 40 1b addcc %o5, %i3, %g3
40007c50: 84 43 00 1a addx %o4, %i2, %g2
40007c54: c4 3f 60 98 std %g2, [ %i5 + 0x98 ]
_Thread_Dispatch_necessary = true;
40007c58: 84 10 20 01 mov 1, %g2
_Thread_Heir = new_heir;
40007c5c: f2 21 a0 24 st %i1, [ %g6 + 0x24 ]
_Thread_Dispatch_necessary = true;
40007c60: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
}
40007c64: 81 c7 e0 08 ret
40007c68: 81 e8 00 00 restore
400079cc <_Scheduler_simple_Update_priority>:
void _Scheduler_simple_Update_priority(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
400079cc: 9d e3 bf a0 save %sp, -96, %sp
Scheduler_simple_Context *context;
unsigned int new_priority;
if ( !_Thread_Is_ready( the_thread ) ) {
400079d0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
400079d4: 80 a0 60 00 cmp %g1, 0
400079d8: 22 80 00 04 be,a 400079e8 <_Scheduler_simple_Update_priority+0x1c>
<== ALWAYS TAKEN
400079dc: 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 );
}
400079e0: 81 c7 e0 08 ret
400079e4: 81 e8 00 00 restore
next = the_node->next;
400079e8: c4 06 40 00 ld [ %i1 ], %g2
400079ec: f8 06 00 00 ld [ %i0 ], %i4
new_priority = (unsigned int ) _Scheduler_Node_get_priority( node );
400079f0: f6 06 a0 34 ld [ %i2 + 0x34 ], %i3
next->previous = previous;
400079f4: c2 20 a0 04 st %g1, [ %g2 + 4 ]
return &the_chain->Tail.Node;
400079f8: 88 07 20 04 add %i4, 4, %g4
previous->next = next;
400079fc: c4 20 40 00 st %g2, [ %g1 ]
return _Chain_Immutable_head( the_chain )->next;
40007a00: c2 07 00 00 ld [ %i4 ], %g1
)
{
const Chain_Node *tail = _Chain_Immutable_tail( the_chain );
Chain_Node *next = _Chain_First( the_chain );
while ( next != tail && !( *order )( left, next ) ) {
40007a04: 80 a1 00 01 cmp %g4, %g1
40007a08: 22 80 00 19 be,a 40007a6c <_Scheduler_simple_Update_priority+0xa0>
<== NEVER TAKEN
40007a0c: c2 01 20 04 ld [ %g4 + 4 ], %g1
<== NOT EXECUTED
return _Priority_Get_priority( &scheduler_node->Wait.Priority );
40007a10: c4 00 60 38 ld [ %g1 + 0x38 ], %g2
40007a14: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
40007a18: 80 a0 e0 00 cmp %g3, 0
40007a1c: 12 80 00 12 bne 40007a64 <_Scheduler_simple_Update_priority+0x98>
<== NEVER TAKEN
40007a20: ba 10 20 00 clr %i5
40007a24: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
40007a28: 80 a0 80 1b cmp %g2, %i3
40007a2c: 3a 80 00 0f bcc,a 40007a68 <_Scheduler_simple_Update_priority+0x9c>
40007a30: 88 10 00 01 mov %g1, %g4
next = _Chain_Next( next );
40007a34: c2 00 40 00 ld [ %g1 ], %g1
while ( next != tail && !( *order )( left, next ) ) {
40007a38: 80 a1 00 01 cmp %g4, %g1
40007a3c: 22 80 00 0c be,a 40007a6c <_Scheduler_simple_Update_priority+0xa0>
40007a40: c2 01 20 04 ld [ %g4 + 4 ], %g1
40007a44: c4 00 60 38 ld [ %g1 + 0x38 ], %g2
40007a48: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
40007a4c: 80 a7 40 03 cmp %i5, %g3
40007a50: 12 80 00 05 bne 40007a64 <_Scheduler_simple_Update_priority+0x98>
<== NEVER TAKEN
40007a54: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
40007a58: 80 a6 c0 02 cmp %i3, %g2
40007a5c: 38 bf ff f7 bgu,a 40007a38 <_Scheduler_simple_Update_priority+0x6c>
40007a60: c2 00 40 00 ld [ %g1 ], %g1
40007a64: 88 10 00 01 mov %g1, %g4
}
_Chain_Insert_unprotected( _Chain_Previous( next ), to_insert );
40007a68: c2 01 20 04 ld [ %g4 + 4 ], %g1
the_node->previous = after_node;
40007a6c: c2 26 60 04 st %g1, [ %i1 + 4 ]
before_node = after_node->next;
40007a70: c4 00 40 00 ld [ %g1 ], %g2
after_node->next = the_node;
40007a74: f2 20 40 00 st %i1, [ %g1 ]
the_node->next = before_node;
40007a78: c4 26 40 00 st %g2, [ %i1 ]
before_node->previous = the_node;
40007a7c: f2 20 a0 04 st %i1, [ %g2 + 4 ]
return _Chain_Immutable_head( the_chain )->next;
40007a80: f8 07 00 00 ld [ %i4 ], %i4
Thread_Control *heir = _Thread_Heir;
40007a84: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40007a88: 80 a7 00 1d cmp %i4, %i5
40007a8c: 02 bf ff d5 be 400079e0 <_Scheduler_simple_Update_priority+0x14>
40007a90: b6 10 00 06 mov %g6, %i3
40007a94: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1
40007a98: 80 a0 60 00 cmp %g1, 0
40007a9c: 02 80 00 0e be 40007ad4 <_Scheduler_simple_Update_priority+0x108>
<== ALWAYS TAKEN
40007aa0: 01 00 00 00 nop
40007aa4: 40 00 0e e5 call 4000b638 <_Timecounter_Sbinuptime>
<== NOT EXECUTED
40007aa8: f0 19 a0 28 ldd [ %g6 + 0x28 ], %i0
<== NOT EXECUTED
40007aac: d0 3e e0 28 std %o0, [ %i3 + 0x28 ]
<== NOT EXECUTED
*_result = *_end - *_start;
40007ab0: b6 a2 40 19 subcc %o1, %i1, %i3
<== NOT EXECUTED
40007ab4: b4 62 00 18 subx %o0, %i0, %i2
<== NOT EXECUTED
*_time += *_add;
40007ab8: f0 1f 60 98 ldd [ %i5 + 0x98 ], %i0
<== NOT EXECUTED
40007abc: 86 86 40 1b addcc %i1, %i3, %g3
<== NOT EXECUTED
40007ac0: 84 46 00 1a addx %i0, %i2, %g2
<== NOT EXECUTED
40007ac4: c4 3f 60 98 std %g2, [ %i5 + 0x98 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40007ac8: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
_Thread_Heir = new_heir;
40007acc: f8 21 a0 24 st %i4, [ %g6 + 0x24 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40007ad0: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
<== NOT EXECUTED
}
40007ad4: 81 c7 e0 08 ret
40007ad8: 81 e8 00 00 restore
40007c6c <_Scheduler_simple_Yield>:
void _Scheduler_simple_Yield(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40007c6c: 9d e3 bf a0 save %sp, -96, %sp
next = the_node->next;
40007c70: c4 06 40 00 ld [ %i1 ], %g2
previous = the_node->previous;
40007c74: c2 06 60 04 ld [ %i1 + 4 ], %g1
40007c78: f8 06 00 00 ld [ %i0 ], %i4
next->previous = previous;
40007c7c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
return &the_chain->Tail.Node;
40007c80: 88 07 20 04 add %i4, 4, %g4
previous->next = next;
40007c84: c4 20 40 00 st %g2, [ %g1 ]
40007c88: 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 );
40007c8c: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
return _Chain_Immutable_head( the_chain )->next;
40007c90: c2 07 00 00 ld [ %i4 ], %g1
while ( next != tail && !( *order )( left, next ) ) {
40007c94: 80 a1 00 01 cmp %g4, %g1
40007c98: 02 80 00 18 be 40007cf8 <_Scheduler_simple_Yield+0x8c>
<== NEVER TAKEN
40007c9c: b6 10 a0 01 or %g2, 1, %i3
40007ca0: c4 00 60 38 ld [ %g1 + 0x38 ], %g2
40007ca4: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
40007ca8: 80 a0 e0 00 cmp %g3, 0
40007cac: 12 80 00 12 bne 40007cf4 <_Scheduler_simple_Yield+0x88>
<== NEVER TAKEN
40007cb0: ba 10 20 00 clr %i5
40007cb4: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
40007cb8: 80 a0 80 1b cmp %g2, %i3
40007cbc: 3a 80 00 0f bcc,a 40007cf8 <_Scheduler_simple_Yield+0x8c>
40007cc0: 88 10 00 01 mov %g1, %g4
next = _Chain_Next( next );
40007cc4: c2 00 40 00 ld [ %g1 ], %g1
while ( next != tail && !( *order )( left, next ) ) {
40007cc8: 80 a1 00 01 cmp %g4, %g1
40007ccc: 22 80 00 0c be,a 40007cfc <_Scheduler_simple_Yield+0x90>
<== NEVER TAKEN
40007cd0: c2 01 20 04 ld [ %g4 + 4 ], %g1
<== NOT EXECUTED
40007cd4: c4 00 60 38 ld [ %g1 + 0x38 ], %g2
40007cd8: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
40007cdc: 80 a7 40 03 cmp %i5, %g3
40007ce0: 12 80 00 05 bne 40007cf4 <_Scheduler_simple_Yield+0x88>
<== NEVER TAKEN
40007ce4: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
40007ce8: 80 a6 c0 02 cmp %i3, %g2
40007cec: 38 bf ff f7 bgu,a 40007cc8 <_Scheduler_simple_Yield+0x5c>
40007cf0: c2 00 40 00 ld [ %g1 ], %g1
40007cf4: 88 10 00 01 mov %g1, %g4
_Chain_Insert_unprotected( _Chain_Previous( next ), to_insert );
40007cf8: c2 01 20 04 ld [ %g4 + 4 ], %g1
the_node->previous = after_node;
40007cfc: c2 26 60 04 st %g1, [ %i1 + 4 ]
before_node = after_node->next;
40007d00: c4 00 40 00 ld [ %g1 ], %g2
after_node->next = the_node;
40007d04: f2 20 40 00 st %i1, [ %g1 ]
the_node->next = before_node;
40007d08: c4 26 40 00 st %g2, [ %i1 ]
before_node->previous = the_node;
40007d0c: f2 20 a0 04 st %i1, [ %g2 + 4 ]
return _Chain_Immutable_head( the_chain )->next;
40007d10: f8 07 00 00 ld [ %i4 ], %i4
Thread_Control *heir = _Thread_Heir;
40007d14: fa 01 a0 24 ld [ %g6 + 0x24 ], %i5
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40007d18: 80 a7 00 1d cmp %i4, %i5
40007d1c: 02 80 00 06 be 40007d34 <_Scheduler_simple_Yield+0xc8>
40007d20: b6 10 00 06 mov %g6, %i3
40007d24: c2 0f 60 89 ldub [ %i5 + 0x89 ], %g1
40007d28: 80 a0 60 00 cmp %g1, 0
40007d2c: 12 80 00 04 bne 40007d3c <_Scheduler_simple_Yield+0xd0>
<== NEVER TAKEN
40007d30: 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 );
}
40007d34: 81 c7 e0 08 ret
40007d38: 81 e8 00 00 restore
40007d3c: 40 00 0e 3f call 4000b638 <_Timecounter_Sbinuptime>
<== NOT EXECUTED
40007d40: f0 19 a0 28 ldd [ %g6 + 0x28 ], %i0
<== NOT EXECUTED
40007d44: d0 3e e0 28 std %o0, [ %i3 + 0x28 ]
<== NOT EXECUTED
*_result = *_end - *_start;
40007d48: b6 a2 40 19 subcc %o1, %i1, %i3
<== NOT EXECUTED
40007d4c: b4 62 00 18 subx %o0, %i0, %i2
<== NOT EXECUTED
*_time += *_add;
40007d50: f0 1f 60 98 ldd [ %i5 + 0x98 ], %i0
<== NOT EXECUTED
40007d54: 86 86 40 1b addcc %i1, %i3, %g3
<== NOT EXECUTED
40007d58: 84 46 00 1a addx %i0, %i2, %g2
<== NOT EXECUTED
40007d5c: c4 3f 60 98 std %g2, [ %i5 + 0x98 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40007d60: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
_Thread_Heir = new_heir;
40007d64: f8 21 a0 24 st %i4, [ %g6 + 0x24 ]
<== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40007d68: c4 29 a0 1c stb %g2, [ %g6 + 0x1c ]
<== NOT EXECUTED
40007d6c: 81 c7 e0 08 ret
<== NOT EXECUTED
40007d70: 81 e8 00 00 restore
<== NOT EXECUTED
4000af78 <_TLS_Get_allocation_size>:
/*
* 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;
4000af78: 11 00 00 00 sethi %hi(0), %o0
4000af7c: 90 12 20 00 mov %o0, %o0 ! 0 <PROM_START>
uintptr_t allocation_size;
uintptr_t alignment;
size = _TLS_Get_size();
if ( size == 0 ) {
4000af80: 80 a2 20 00 cmp %o0, 0
4000af84: 02 80 00 16 be 4000afdc <_TLS_Get_allocation_size+0x64>
4000af88: 05 10 00 6f sethi %hi(0x4001bc00), %g2
return 0;
}
allocation_size = _TLS_Allocation_size;
4000af8c: c2 00 a1 9c ld [ %g2 + 0x19c ], %g1 ! 4001bd9c <_TLS_Allocation_size>
if ( allocation_size == 0 ) {
4000af90: 80 a0 60 00 cmp %g1, 0
4000af94: 32 80 00 12 bne,a 4000afdc <_TLS_Get_allocation_size+0x64>
4000af98: 90 10 00 01 mov %g1, %o0
*/
static inline uintptr_t _TLS_Heap_align_up( uintptr_t val )
{
uintptr_t msk = CPU_HEAP_ALIGNMENT - 1;
return (val + msk) & ~msk;
4000af9c: 90 02 20 07 add %o0, 7, %o0
4000afa0: 03 00 00 00 sethi %hi(0), %g1
4000afa4: 82 10 60 01 or %g1, 1, %g1 ! 1 <_TLS_Alignment>
4000afa8: 82 00 60 07 add %g1, 7, %g1
4000afac: 82 08 7f f8 and %g1, -8, %g1
/*
* The stack allocator does not support aligned allocations. Allocate
* enough to do the alignment manually.
*/
if ( alignment > CPU_HEAP_ALIGNMENT ) {
4000afb0: 80 a0 60 08 cmp %g1, 8
4000afb4: 08 80 00 04 bleu 4000afc4 <_TLS_Get_allocation_size+0x4c>
4000afb8: 86 0a 3f f8 and %o0, -8, %g3
allocation_size += alignment;
4000afbc: 86 00 c0 01 add %g3, %g1, %g3
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;
4000afc0: 80 a0 60 08 cmp %g1, 8
4000afc4: 2a 80 00 08 bcs,a 4000afe4 <_TLS_Get_allocation_size+0x6c>
<== NEVER TAKEN
4000afc8: 82 10 20 08 mov 8, %g1
<== NOT EXECUTED
}
allocation_size += _TLS_Get_thread_control_block_area_size( alignment );
#ifndef __i386__
allocation_size += sizeof(TLS_Dynamic_thread_vector);
4000afcc: 90 00 60 08 add %g1, 8, %o0
4000afd0: 90 02 00 03 add %o0, %g3, %o0
#endif
_TLS_Allocation_size = allocation_size;
4000afd4: 81 c3 e0 08 retl
4000afd8: d0 20 a1 9c st %o0, [ %g2 + 0x19c ]
}
return allocation_size;
}
4000afdc: 81 c3 e0 08 retl
4000afe0: 01 00 00 00 nop
allocation_size += sizeof(TLS_Dynamic_thread_vector);
4000afe4: 90 00 60 08 add %g1, 8, %o0
<== NOT EXECUTED
4000afe8: 90 02 00 03 add %o0, %g3, %o0
<== NOT EXECUTED
_TLS_Allocation_size = allocation_size;
4000afec: 81 c3 e0 08 retl
<== NOT EXECUTED
4000aff0: d0 20 a1 9c st %o0, [ %g2 + 0x19c ]
<== NOT EXECUTED
40009898 <_Terminate>:
void _Terminate(
Internal_errors_Source the_source,
Internal_errors_t the_error
)
{
40009898: 9d e3 bf 98 save %sp, -104, %sp
_User_extensions_Iterate(
4000989c: 94 10 20 00 clr %o2
400098a0: 90 07 bf f8 add %fp, -8, %o0
User_extensions_Fatal_context ctx = { source, error };
400098a4: f0 27 bf f8 st %i0, [ %fp + -8 ]
_User_extensions_Iterate(
400098a8: 13 10 00 25 sethi %hi(0x40009400), %o1
User_extensions_Fatal_context ctx = { source, error };
400098ac: f2 27 bf fc st %i1, [ %fp + -4 ]
_User_extensions_Iterate(
400098b0: 7f ff ff 7a call 40009698 <_User_extensions_Iterate>
400098b4: 92 12 62 48 or %o1, 0x248, %o1
_User_extensions_Fatal( the_source, the_error );
_Internal_errors_What_happened.the_source = the_source;
400098b8: 03 10 00 7a sethi %hi(0x4001e800), %g1
400098bc: 84 10 63 9c or %g1, 0x39c, %g2 ! 4001eb9c <_Internal_errors_What_happened>
400098c0: f0 20 63 9c st %i0, [ %g1 + 0x39c ]
_System_state_Current = state;
400098c4: 03 10 00 7a sethi %hi(0x4001e800), %g1
_Internal_errors_What_happened.the_error = the_error;
400098c8: f2 20 a0 04 st %i1, [ %g2 + 4 ]
400098cc: 84 10 20 03 mov 3, %g2
_System_state_Set( SYSTEM_STATE_TERMINATED );
_SMP_Request_shutdown();
_CPU_Fatal_halt( the_source, the_error );
400098d0: 92 10 00 19 mov %i1, %o1
400098d4: 90 10 00 18 mov %i0, %o0
400098d8: 40 00 16 05 call 4000f0ec <_CPU_Fatal_halt>
400098dc: c4 20 63 a4 st %g2, [ %g1 + 0x3a4 ]
400098e0: 01 00 00 00 nop
<== NOT EXECUTED
4000a41c <_Thread_Allocate_unlimited>:
}
}
}
Objects_Control *_Thread_Allocate_unlimited( Objects_Information *information )
{
4000a41c: 9d e3 bf a0 save %sp, -96, %sp
return _Chain_Immutable_head( the_chain )->next;
4000a420: f8 06 20 18 ld [ %i0 + 0x18 ], %i4
return &the_chain->Tail.Node;
4000a424: 82 06 20 1c add %i0, 0x1c, %g1
4000a428: ba 10 00 18 mov %i0, %i5
if ( !_Chain_Is_empty(the_chain))
4000a42c: 80 a7 00 01 cmp %i4, %g1
4000a430: 12 80 00 36 bne 4000a508 <_Thread_Allocate_unlimited+0xec>
4000a434: b4 06 20 18 add %i0, 0x18, %i2
block = _Objects_Extend_information( &information->Objects );
4000a438: 7f ff fc ec call 400097e8 <_Objects_Extend_information>
4000a43c: 90 10 00 18 mov %i0, %o0
if ( block > 0 ) {
4000a440: 91 2a 20 10 sll %o0, 0x10, %o0
4000a444: b7 32 20 10 srl %o0, 0x10, %i3
4000a448: 80 a6 e0 00 cmp %i3, 0
4000a44c: 32 80 00 22 bne,a 4000a4d4 <_Thread_Allocate_unlimited+0xb8>
<== ALWAYS TAKEN
4000a450: d4 16 20 12 lduh [ %i0 + 0x12 ], %o2
return _Chain_Immutable_head( the_chain )->next;
4000a454: f0 07 60 18 ld [ %i5 + 0x18 ], %i0
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
4000a458: 80 a7 00 18 cmp %i4, %i0
4000a45c: 02 80 00 30 be 4000a51c <_Thread_Allocate_unlimited+0x100>
<== NEVER TAKEN
4000a460: 01 00 00 00 nop
new_first = old_first->next;
4000a464: c2 06 00 00 ld [ %i0 ], %g1
head->next = new_first;
4000a468: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
new_first->previous = head;
4000a46c: f4 20 60 04 st %i2, [ %g1 + 4 ]
4000a470: c2 06 20 08 ld [ %i0 + 8 ], %g1
_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 ) {
4000a474: c4 17 60 12 lduh [ %i5 + 0x12 ], %g2
block = _Objects_Get_index( the_object->id ) - OBJECTS_INDEX_MINIMUM;
4000a478: 82 00 7f ff add %g1, -1, %g1
if ( block > objects_per_block ) {
4000a47c: 83 28 60 10 sll %g1, 0x10, %g1
4000a480: 83 30 60 10 srl %g1, 0x10, %g1
4000a484: 80 a0 80 01 cmp %g2, %g1
4000a488: 1a 80 00 11 bcc 4000a4cc <_Thread_Allocate_unlimited+0xb0>
4000a48c: 01 00 00 00 nop
block /= objects_per_block;
information->inactive_per_block[ block ]--;
4000a490: c8 07 60 24 ld [ %i5 + 0x24 ], %g4
4000a494: 81 80 20 00 wr %g0, %y
4000a498: 01 00 00 00 nop
4000a49c: 01 00 00 00 nop
4000a4a0: 01 00 00 00 nop
4000a4a4: 86 70 40 02 udiv %g1, %g2, %g3
4000a4a8: 83 28 e0 01 sll %g3, 1, %g1
4000a4ac: c4 11 00 01 lduh [ %g4 + %g1 ], %g2
4000a4b0: 84 00 bf ff add %g2, -1, %g2
4000a4b4: c4 31 00 01 sth %g2, [ %g4 + %g1 ]
information->inactive--;
4000a4b8: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1
4000a4bc: 82 00 7f ff add %g1, -1, %g1
4000a4c0: c2 37 60 10 sth %g1, [ %i5 + 0x10 ]
return _Objects_Allocate_with_extend(
4000a4c4: 81 c7 e0 08 ret
4000a4c8: 81 e8 00 00 restore
information,
_Thread_Extend_information
);
}
4000a4cc: 81 c7 e0 08 ret
4000a4d0: 81 e8 00 00 restore
new_heads = _Freechain_Extend(
4000a4d4: 96 10 20 48 mov 0x48, %o3
4000a4d8: 90 06 20 30 add %i0, 0x30, %o0
4000a4dc: 13 10 00 31 sethi %hi(0x4000c400), %o1
4000a4e0: 40 00 29 d4 call 40014c30 <_Freechain_Extend>
4000a4e4: 92 12 61 cc or %o1, 0x1cc, %o1 ! 4000c5cc <_Workspace_Allocate>
if ( new_heads == NULL ) {
4000a4e8: 80 a2 20 00 cmp %o0, 0
4000a4ec: 32 bf ff db bne,a 4000a458 <_Thread_Allocate_unlimited+0x3c>
<== ALWAYS TAKEN
4000a4f0: f0 07 60 18 ld [ %i5 + 0x18 ], %i0
_Objects_Free_objects_block( &information->Objects, block );
4000a4f4: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4000a4f8: 7f ff fd 8a call 40009b20 <_Objects_Free_objects_block>
<== NOT EXECUTED
4000a4fc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000a500: 10 bf ff d6 b 4000a458 <_Thread_Allocate_unlimited+0x3c>
<== NOT EXECUTED
4000a504: f0 07 60 18 ld [ %i5 + 0x18 ], %i0
<== NOT EXECUTED
new_first = old_first->next;
4000a508: c2 07 00 00 ld [ %i4 ], %g1
head->next = new_first;
4000a50c: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
new_first->previous = head;
4000a510: b0 10 00 1c mov %i4, %i0
4000a514: 10 bf ff d7 b 4000a470 <_Thread_Allocate_unlimited+0x54>
4000a518: f4 20 60 04 st %i2, [ %g1 + 4 ]
return NULL;
4000a51c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a520: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
4000abd0 <_Thread_Cancel>:
void _Thread_Cancel(
Thread_Control *the_thread,
Thread_Control *executing,
void *exit_value
)
{
4000abd0: 9d e3 bf 98 save %sp, -104, %sp
4000abd4: ba 10 00 18 mov %i0, %i5
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000abd8: 91 d0 20 09 ta 9
return psr;
4000abdc: b8 10 00 01 mov %g1, %i4
previous = the_thread->Life.state;
4000abe0: c4 06 21 70 ld [ %i0 + 0x170 ], %g2
state |= set;
4000abe4: 86 10 a0 04 or %g2, 4, %g3
the_thread->Life.exit_value = exit_value;
4000abe8: f4 26 21 78 st %i2, [ %i0 + 0x178 ]
if (
4000abec: 80 88 a0 09 btst 9, %g2
4000abf0: 02 80 00 1e be 4000ac68 <_Thread_Cancel+0x98>
4000abf4: c6 26 21 70 st %g3, [ %i0 + 0x170 ]
disable_level = cpu_self->thread_dispatch_disable_level;
4000abf8: c4 01 a0 18 ld [ %g6 + 0x18 ], %g2
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000abfc: 84 00 a0 01 inc %g2
4000ac00: c4 21 a0 18 st %g2, [ %g6 + 0x18 ]
);
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
priority = _Thread_Get_priority( executing );
if ( _States_Is_dormant( the_thread->current_state ) ) {
4000ac04: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000ac08: 80 a0 60 00 cmp %g1, 0
4000ac0c: 06 80 00 36 bl 4000ace4 <_Thread_Cancel+0x114>
<== NEVER TAKEN
4000ac10: b0 10 00 06 mov %g6, %i0
pending_requests = the_thread->Life.pending_life_change_requests;
4000ac14: c2 07 61 74 ld [ %i5 + 0x174 ], %g1
return _Priority_Get_priority( &scheduler_node->Wait.Priority );
4000ac18: c4 06 60 38 ld [ %i1 + 0x38 ], %g2
4000ac1c: f4 18 a0 18 ldd [ %g2 + 0x18 ], %i2
the_thread->Life.pending_life_change_requests = pending_requests + 1;
4000ac20: 84 00 60 01 add %g1, 1, %g2
if ( pending_requests == 0 ) {
4000ac24: 80 a0 60 00 cmp %g1, 0
4000ac28: 02 80 00 36 be 4000ad00 <_Thread_Cancel+0x130>
<== ALWAYS TAKEN
4000ac2c: c4 27 61 74 st %g2, [ %i5 + 0x174 ]
_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 );
4000ac30: 13 00 00 20 sethi %hi(0x8000), %o1
<== NOT EXECUTED
4000ac34: 40 00 20 a2 call 40012ebc <_Thread_Clear_state_locked>
4000ac38: 90 10 00 1d mov %i5, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000ac3c: 82 10 00 1c mov %i4, %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ac40: 91 d0 20 0a ta 0xa
4000ac44: 01 00 00 00 nop
_Thread_State_release( the_thread, &lock_context );
_Thread_Raise_real_priority( the_thread, priority );
4000ac48: 90 10 00 1d mov %i5, %o0
4000ac4c: 92 10 00 1a mov %i2, %o1
4000ac50: 7f ff fe dc call 4000a7c0 <_Thread_Raise_real_priority>
4000ac54: 94 10 00 1b mov %i3, %o2
_Thread_Remove_life_change_request( the_thread );
4000ac58: 7f ff fe c5 call 4000a76c <_Thread_Remove_life_change_request>
4000ac5c: 90 10 00 1d mov %i5, %o0
}
_Thread_Dispatch_enable( cpu_self );
4000ac60: 7f ff fe 6e call 4000a618 <_Thread_Dispatch_enable>
4000ac64: 81 e8 00 00 restore
4000ac68: 7f ff fe fa call 4000a850 <_Thread_Change_life_locked.part.36>
4000ac6c: 90 10 00 18 mov %i0, %o0
disable_level = cpu_self->thread_dispatch_disable_level;
4000ac70: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000ac74: 82 00 60 01 inc %g1
4000ac78: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000ac7c: b0 10 00 06 mov %g6, %i0
4000ac80: c4 06 60 38 ld [ %i1 + 0x38 ], %g2
if ( _States_Is_dormant( the_thread->current_state ) ) {
4000ac84: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000ac88: 80 a0 60 00 cmp %g1, 0
4000ac8c: 06 80 00 16 bl 4000ace4 <_Thread_Cancel+0x114>
4000ac90: f4 18 a0 18 ldd [ %g2 + 0x18 ], %i2
pending_requests = the_thread->Life.pending_life_change_requests;
4000ac94: c2 07 61 74 ld [ %i5 + 0x174 ], %g1
the_thread->Life.pending_life_change_requests = pending_requests + 1;
4000ac98: 84 00 60 01 add %g1, 1, %g2
if ( pending_requests == 0 ) {
4000ac9c: 80 a0 60 00 cmp %g1, 0
4000aca0: 12 80 00 05 bne 4000acb4 <_Thread_Cancel+0xe4>
<== NEVER TAKEN
4000aca4: c4 27 61 74 st %g2, [ %i5 + 0x174 ]
_Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING );
4000aca8: 13 00 00 80 sethi %hi(0x20000), %o1
4000acac: 40 00 00 5e call 4000ae24 <_Thread_Set_state_locked>
4000acb0: 90 10 00 1d mov %i5, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000acb4: 82 10 00 1c mov %i4, %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000acb8: 91 d0 20 0a ta 0xa
4000acbc: 01 00 00 00 nop
_Thread_queue_Extract_with_proxy( the_thread );
4000acc0: 40 00 01 e1 call 4000b444 <_Thread_queue_Extract_with_proxy>
4000acc4: 90 10 00 1d mov %i5, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000acc8: 91 d0 20 09 ta 9
return psr;
4000accc: c2 27 bf fc st %g1, [ %fp + -4 ]
4000acd0: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
4000acd4: 40 00 04 b3 call 4000bfa0 <_Watchdog_Remove>
4000acd8: 92 07 60 68 add %i5, 0x68, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000acdc: 10 bf ff d9 b 4000ac40 <_Thread_Cancel+0x70>
4000ace0: c2 07 bf fc ld [ %fp + -4 ], %g1
4000ace4: 82 10 00 1c mov %i4, %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ace8: 91 d0 20 0a ta 0xa
4000acec: 01 00 00 00 nop
_Thread_Make_zombie( the_thread );
4000acf0: 7f ff fe f0 call 4000a8b0 <_Thread_Make_zombie>
4000acf4: 90 10 00 1d mov %i5, %o0
_Thread_Dispatch_enable( cpu_self );
4000acf8: 7f ff fe 48 call 4000a618 <_Thread_Dispatch_enable>
4000acfc: 81 e8 00 00 restore
_Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING );
4000ad00: 13 00 00 80 sethi %hi(0x20000), %o1
4000ad04: 40 00 00 48 call 4000ae24 <_Thread_Set_state_locked>
4000ad08: 90 10 00 1d mov %i5, %o0
_Thread_Clear_state_locked( the_thread, STATES_SUSPENDED );
4000ad0c: 10 bf ff ca b 4000ac34 <_Thread_Cancel+0x64>
4000ad10: 13 00 00 20 sethi %hi(0x8000), %o1
4000d32c <_Thread_Clear_state_locked>:
{
4000d32c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
previous_state = the_thread->current_state;
4000d330: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
<== NOT EXECUTED
if ( ( previous_state & state ) != 0 ) {
4000d334: 80 8f 40 19 btst %i5, %i1
<== NOT EXECUTED
4000d338: 02 80 00 07 be 4000d354 <_Thread_Clear_state_locked+0x28>
<== NOT EXECUTED
4000d33c: b2 2f 40 19 andn %i5, %i1, %i1
<== NOT EXECUTED
if ( _States_Is_ready( next_state ) ) {
4000d340: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000d344: 12 80 00 04 bne 4000d354 <_Thread_Clear_state_locked+0x28>
<== NOT EXECUTED
4000d348: f2 26 20 1c st %i1, [ %i0 + 0x1c ]
<== NOT EXECUTED
4000d34c: 7f ff ff ef call 4000d308 <_Thread_Clear_state_locked.part.10>
<== NOT EXECUTED
4000d350: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
4000d354: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d358: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
40007c50 <_Thread_Do_dispatch>:
_Thread_State_release( executing, &lock_context );
}
void _Thread_Do_dispatch( Per_CPU_Control *cpu_self, ISR_Level level )
{
40007c50: 9d e3 bf 98 save %sp, -104, %sp
) {
_Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT );
}
#endif
executing = cpu_self->executing;
40007c54: f6 06 20 20 ld [ %i0 + 0x20 ], %i3
{
40007c58: 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();
40007c5c: 23 10 00 5d sethi %hi(0x40017400), %l1
return _Chain_Immutable_head( the_chain )->next;
40007c60: 33 10 00 68 sethi %hi(0x4001a000), %i1
#if !defined(RTEMS_SMP)
_User_extensions_Thread_switch( executing, heir );
#endif
_Thread_Save_fp( executing );
_Context_Switch( &executing->Registers, &heir->Registers );
40007c64: a0 06 e0 f0 add %i3, 0xf0, %l0
40007c68: b2 16 63 0c or %i1, 0x30c, %i1
chain = &_User_extensions_Switches_list;
tail = _Chain_Immutable_tail( chain );
node = _Chain_Immutable_first( chain );
if ( node != tail ) {
40007c6c: b4 06 60 04 add %i1, 4, %i2
heir = cpu_self->heir;
40007c70: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
cpu_self->dispatch_necessary = false;
40007c74: c0 2e 20 1c clrb [ %i0 + 0x1c ]
if ( heir == executing )
40007c78: 80 a6 c0 1c cmp %i3, %i4
40007c7c: 02 80 00 1e be 40007cf4 <_Thread_Do_dispatch+0xa4>
40007c80: f8 26 20 20 st %i4, [ %i0 + 0x20 ]
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
40007c84: c4 07 20 90 ld [ %i4 + 0x90 ], %g2
40007c88: 80 a0 a0 01 cmp %g2, 1
<== NOT EXECUTED
40007c8c: 12 80 00 03 bne 40007c98 <_Thread_Do_dispatch+0x48>
<== NOT EXECUTED
40007c90: c4 04 62 7c ld [ %l1 + 0x27c ], %g2
<== NOT EXECUTED
heir->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice();
40007c94: c4 27 20 8c st %g2, [ %i4 + 0x8c ]
<== NOT EXECUTED
40007c98: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007c9c: 01 00 00 00 nop
<== NOT EXECUTED
40007ca0: c2 06 40 00 ld [ %i1 ], %g1
<== NOT EXECUTED
40007ca4: 80 a0 40 1a cmp %g1, %i2
<== NOT EXECUTED
40007ca8: 02 80 00 0b be 40007cd4 <_Thread_Do_dispatch+0x84>
<== NOT EXECUTED
40007cac: 92 07 20 f0 add %i4, 0xf0, %o1
<== NOT EXECUTED
while ( node != tail ) {
const User_extensions_Switch_control *extension;
extension = (const User_extensions_Switch_control *) node;
node = _Chain_Immutable_next( node );
(*extension->thread_switch)( executing, heir );
40007cb0: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
node = _Chain_Immutable_next( node );
40007cb4: fa 00 40 00 ld [ %g1 ], %i5
<== NOT EXECUTED
(*extension->thread_switch)( executing, heir );
40007cb8: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
40007cbc: 9f c0 80 00 call %g2
<== NOT EXECUTED
40007cc0: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
while ( node != tail ) {
40007cc4: 80 a7 40 1a cmp %i5, %i2
<== NOT EXECUTED
40007cc8: 12 bf ff fa bne 40007cb0 <_Thread_Do_dispatch+0x60>
<== NOT EXECUTED
40007ccc: 82 10 00 1d mov %i5, %g1
<== NOT EXECUTED
_Context_Switch( &executing->Registers, &heir->Registers );
40007cd0: 92 07 20 f0 add %i4, 0xf0, %o1
<== NOT EXECUTED
40007cd4: 40 00 0d 6e call 4000b28c <_CPU_Context_switch>
<== NOT EXECUTED
40007cd8: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
/*
* 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();
40007cdc: b0 10 00 06 mov %g6, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007ce0: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_Local_disable( level );
} while ( cpu_self->dispatch_necessary );
40007ce4: c4 09 a0 1c ldub [ %g6 + 0x1c ], %g2
<== NOT EXECUTED
40007ce8: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40007cec: 32 bf ff e2 bne,a 40007c74 <_Thread_Do_dispatch+0x24>
<== NOT EXECUTED
40007cf0: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
<== NOT EXECUTED
post_switch:
_Assert( cpu_self->thread_dispatch_disable_level == 1 );
cpu_self->thread_dispatch_disable_level = 0;
40007cf4: c0 26 20 18 clr [ %i0 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007cf8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007cfc: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007d00: 91 d0 20 09 ta 9
_ISR_lock_ISR_disable( lock_context );
40007d04: c2 27 bf fc st %g1, [ %fp + -4 ]
40007d08: d2 06 e0 e0 ld [ %i3 + 0xe0 ], %o1
return &the_chain->Tail.Node;
40007d0c: ba 06 e0 e4 add %i3, 0xe4, %i5
if ( !_Chain_Is_empty(the_chain))
40007d10: 80 a2 40 1d cmp %o1, %i5
40007d14: 02 80 00 10 be 40007d54 <_Thread_Do_dispatch+0x104>
40007d18: b8 06 e0 e0 add %i3, 0xe0, %i4
new_first = old_first->next;
40007d1c: c2 02 40 00 ld [ %o1 ], %g1
head->next = new_first;
40007d20: c2 26 e0 e0 st %g1, [ %i3 + 0xe0 ]
( *action->handler )( executing, action, &lock_context );
40007d24: 94 07 bf fc add %fp, -4, %o2
<== NOT EXECUTED
new_first->previous = head;
40007d28: f8 20 60 04 st %i4, [ %g1 + 4 ]
<== NOT EXECUTED
node->next = NULL;
40007d2c: c0 22 40 00 clr [ %o1 ]
<== NOT EXECUTED
40007d30: c2 02 60 08 ld [ %o1 + 8 ], %g1
<== NOT EXECUTED
40007d34: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007d38: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
40007d3c: 91 d0 20 09 ta 9
<== NOT EXECUTED
40007d40: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40007d44: d2 06 e0 e0 ld [ %i3 + 0xe0 ], %o1
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
40007d48: 80 a7 40 09 cmp %i5, %o1
<== NOT EXECUTED
40007d4c: 32 bf ff f5 bne,a 40007d20 <_Thread_Do_dispatch+0xd0>
<== NOT EXECUTED
40007d50: c2 02 40 00 ld [ %o1 ], %g1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40007d54: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007d58: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007d5c: 01 00 00 00 nop
_Profiling_Thread_dispatch_enable( cpu_self, 0 );
_ISR_Local_enable( level );
_Thread_Run_post_switch_actions( executing );
}
40007d60: 81 c7 e0 08 ret
40007d64: 81 e8 00 00 restore
4000ad64 <_Thread_Exit>:
void _Thread_Exit(
Thread_Control *executing,
Thread_Life_state set,
void *exit_value
)
{
4000ad64: 9d e3 bf 98 save %sp, -104, %sp
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000ad68: 91 d0 20 09 ta 9
state |= set;
4000ad6c: c4 06 21 70 ld [ %i0 + 0x170 ], %g2
4000ad70: b2 16 40 02 or %i1, %g2, %i1
the_thread->Life.exit_value = exit_value;
4000ad74: f4 26 21 78 st %i2, [ %i0 + 0x178 ]
&& _Thread_Is_life_changing( state )
4000ad78: 80 8e 60 06 btst 6, %i1
4000ad7c: 02 80 00 06 be 4000ad94 <_Thread_Exit+0x30>
<== NEVER TAKEN
4000ad80: f2 26 21 70 st %i1, [ %i0 + 0x170 ]
4000ad84: c2 27 bf fc st %g1, [ %fp + -4 ]
4000ad88: 7f ff fe b2 call 4000a850 <_Thread_Change_life_locked.part.36>
4000ad8c: 90 10 00 18 mov %i0, %o0
4000ad90: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ad94: 91 d0 20 0a ta 0xa
4000ad98: 01 00 00 00 nop
0,
set,
THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED
);
_Thread_State_release( executing, &lock_context );
}
4000ad9c: 81 c7 e0 08 ret
4000ada0: 81 e8 00 00 restore
400096b0 <_Thread_Get_name>:
size_t _Thread_Get_name(
const Thread_Control *the_thread,
char *buffer,
size_t buffer_size
)
{
400096b0: 9d e3 bf 98 save %sp, -104, %sp
const char *name;
name = the_thread->Join_queue.Queue.name;
400096b4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
{
400096b8: 94 10 00 19 mov %i1, %o2
if ( name != NULL && name[ 0 ] != '\0' ) {
400096bc: 80 a0 60 00 cmp %g1, 0
400096c0: 02 80 00 06 be 400096d8 <_Thread_Get_name+0x28>
<== NEVER TAKEN
400096c4: 96 10 00 1a mov %i2, %o3
400096c8: c4 48 40 00 ldsb [ %g1 ], %g2
400096cc: 80 a0 a0 00 cmp %g2, 0
400096d0: 12 80 00 09 bne 400096f4 <_Thread_Get_name+0x44>
400096d4: b2 10 00 01 mov %g1, %i1
return strlcpy( buffer, name, buffer_size );
} else {
return _Objects_Name_to_string(
400096d8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
400096dc: c2 27 bf fc st %g1, [ %fp + -4 ]
400096e0: 92 10 20 00 clr %o1
400096e4: 40 00 11 fa call 4000decc <_Objects_Name_to_string>
400096e8: 90 07 bf fc add %fp, -4, %o0
false,
buffer,
buffer_size
);
}
}
400096ec: 81 c7 e0 08 ret
400096f0: 91 e8 00 08 restore %g0, %o0, %o0
return strlcpy( buffer, name, buffer_size );
400096f4: 40 00 1c ba call 400109dc <strlcpy>
400096f8: 91 e8 00 0a restore %g0, %o2, %o0
4000cf70 <_Thread_Handler_initialization>:
_Thread_queue_Heads_size
);
}
void _Thread_Handler_initialization(void)
{
4000cf70: 9d e3 bf a0 save %sp, -96, %sp
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_MPCI_Configuration.maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
4000cf74: 03 10 00 5d sethi %hi(0x40017400), %g1
4000cf78: c2 00 63 38 ld [ %g1 + 0x338 ], %g1 ! 40017738 <_Stack_Allocator_allocate>
4000cf7c: 80 a0 60 00 cmp %g1, 0
rtems_stack_allocate_init_hook stack_allocate_init_hook =
4000cf80: 03 10 00 5d sethi %hi(0x40017400), %g1
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
4000cf84: 02 80 00 0f be 4000cfc0 <_Thread_Handler_initialization+0x50>
<== NEVER TAKEN
4000cf88: fa 00 63 3c ld [ %g1 + 0x33c ], %i5 ! 4001773c <_Stack_Allocator_initialize>
rtems_configuration_get_stack_free_hook() == NULL)
4000cf8c: 03 10 00 5d sethi %hi(0x40017400), %g1
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
4000cf90: c2 00 63 34 ld [ %g1 + 0x334 ], %g1 ! 40017734 <_Stack_Allocator_free>
4000cf94: 80 a0 60 00 cmp %g1, 0
4000cf98: 02 80 00 0a be 4000cfc0 <_Thread_Handler_initialization+0x50>
4000cf9c: 80 a7 60 00 cmp %i5, 0
_Internal_error( INTERNAL_ERROR_BAD_STACK_HOOK );
if ( stack_allocate_init_hook != NULL )
4000cfa0: 02 80 00 06 be 4000cfb8 <_Thread_Handler_initialization+0x48>
4000cfa4: 31 10 00 68 sethi %hi(0x4001a000), %i0
(*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
4000cfa8: 7f ff f5 e1 call 4000a72c <rtems_configuration_get_stack_space_size>
4000cfac: 01 00 00 00 nop
4000cfb0: 9f c7 40 00 call %i5
4000cfb4: 01 00 00 00 nop
/*
* Initialize the internal class of threads. We need an IDLE thread
* per CPU in an SMP system. In addition, if this is a loosely
* coupled multiprocessing system, account for the MPCI Server Thread.
*/
_Thread_Initialize_information( &_Thread_Information );
4000cfb8: 7f ff ff e6 call 4000cf50 <_Thread_Initialize_information>
4000cfbc: 91 ee 21 80 restore %i0, 0x180, %o0
_Internal_error( INTERNAL_ERROR_BAD_STACK_HOOK );
4000cfc0: 7f ff f2 49 call 400098e4 <_Internal_error>
4000cfc4: 90 10 20 0e mov 0xe, %o0
4000cfc8: 01 00 00 00 nop
<== NOT EXECUTED
4000d4d4 <_Thread_Initialize>:
bool _Thread_Initialize(
Thread_Information *information,
Thread_Control *the_thread,
const Thread_Configuration *config
)
{
4000d4d4: 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 )
4000d4d8: d4 16 20 14 lduh [ %i0 + 0x14 ], %o2
memset(
4000d4dc: 94 02 bf f0 add %o2, -16, %o2
4000d4e0: 92 10 20 00 clr %o1
4000d4e4: 40 00 08 ae call 4000f79c <memset>
4000d4e8: 90 06 60 10 add %i1, 0x10, %o0
);
for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) {
4000d4ec: 03 10 00 5a sethi %hi(0x40016800), %g1
4000d4f0: fa 00 62 84 ld [ %g1 + 0x284 ], %i5 ! 40016a84 <_Thread_Control_add_on_count>
4000d4f4: 80 a7 60 00 cmp %i5, 0
4000d4f8: 02 80 00 0c be 4000d528 <_Thread_Initialize+0x54>
4000d4fc: 03 10 00 5a sethi %hi(0x40016800), %g1
4000d500: 86 10 20 00 clr %g3
4000d504: 82 10 62 88 or %g1, 0x288, %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;
4000d508: c4 00 60 04 ld [ %g1 + 4 ], %g2
*(void **) ( (char *) the_thread + add_on->destination_offset ) =
4000d50c: c8 00 40 00 ld [ %g1 ], %g4
(char *) the_thread + add_on->source_offset;
4000d510: 84 06 40 02 add %i1, %g2, %g2
*(void **) ( (char *) the_thread + add_on->destination_offset ) =
4000d514: c4 26 40 04 st %g2, [ %i1 + %g4 ]
for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) {
4000d518: 86 00 e0 01 inc %g3
4000d51c: 80 a0 c0 1d cmp %g3, %i5
4000d520: 12 bf ff fa bne 4000d508 <_Thread_Initialize+0x34>
4000d524: 82 00 60 08 add %g1, 8, %g1
}
/* Set everything to perform the error case clean up */
scheduler_index = 0;
the_thread->Start.allocated_stack = config->allocated_stack;
4000d528: c2 06 a0 0c ld [ %i2 + 0xc ], %g1
4000d52c: c2 26 60 c8 st %g1, [ %i1 + 0xc8 ]
stack_area = config->stack_area;
stack_size = config->stack_size;
/* Allocate floating-point context in stack area */
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( config->is_fp ) {
4000d530: c2 0e a0 28 ldub [ %i2 + 0x28 ], %g1
stack_area = config->stack_area;
4000d534: fa 06 a0 04 ld [ %i2 + 4 ], %i5
if ( config->is_fp ) {
4000d538: 80 a0 60 00 cmp %g1, 0
4000d53c: 02 80 00 06 be 4000d554 <_Thread_Initialize+0x80>
4000d540: f6 06 a0 08 ld [ %i2 + 8 ], %i3
the_thread->fp_context = ( Context_Control_fp *) stack_area;
4000d544: fa 26 61 50 st %i5, [ %i1 + 0x150 ]
the_thread->Start.fp_context = ( Context_Control_fp *) stack_area;
stack_size -= CONTEXT_FP_SIZE;
4000d548: b6 06 ff 78 add %i3, -136, %i3
the_thread->Start.fp_context = ( Context_Control_fp *) stack_area;
4000d54c: fa 26 60 d4 st %i5, [ %i1 + 0xd4 ]
stack_area += CONTEXT_FP_SIZE;
4000d550: ba 07 60 88 add %i5, 0x88, %i5
}
#endif
tls_size = _TLS_Get_allocation_size();
4000d554: 7f ff f6 89 call 4000af78 <_TLS_Get_allocation_size>
<== NOT EXECUTED
4000d558: 01 00 00 00 nop
/* Allocate thread-local storage (TLS) area in stack area */
if ( tls_size > 0 ) {
4000d55c: 80 a2 20 00 cmp %o0, 0
4000d560: 22 80 00 0c be,a 4000d590 <_Thread_Initialize+0xbc>
4000d564: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
uintptr_t tls_align;
tls_align = (uintptr_t) _TLS_Alignment;
4000d568: 03 00 00 00 sethi %hi(0), %g1
4000d56c: 82 10 60 01 or %g1, 1, %g1 ! 1 <_TLS_Alignment>
the_thread->Start.tls_area = (void *)
( ( (uintptr_t) stack_area + tls_align - 1 ) & ~( tls_align - 1 ) );
4000d570: 84 00 7f ff add %g1, -1, %g2
4000d574: 82 20 00 01 neg %g1
4000d578: 84 07 40 02 add %i5, %g2, %g2
4000d57c: 82 08 80 01 and %g2, %g1, %g1
the_thread->Start.tls_area = (void *)
4000d580: c2 26 60 d8 st %g1, [ %i1 + 0xd8 ]
stack_size -= tls_size;
4000d584: b6 26 c0 08 sub %i3, %o0, %i3
stack_area += tls_size;
4000d588: ba 07 40 08 add %i5, %o0, %i5
old_first = head->next;
4000d58c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
new_first = old_first->next;
4000d590: c4 00 40 00 ld [ %g1 ], %g2
the_stack->area = starting_address;
4000d594: fa 26 60 d0 st %i5, [ %i1 + 0xd0 ]
);
/*
* Get thread queue heads
*/
the_thread->Wait.spare_heads = _Freechain_Pop(
4000d598: b8 06 20 30 add %i0, 0x30, %i4
the_stack->size = size;
4000d59c: f6 26 60 cc st %i3, [ %i1 + 0xcc ]
return &the_chain->Tail.Node;
4000d5a0: 86 00 60 30 add %g1, 0x30, %g3
head->next = new_first;
4000d5a4: c4 26 20 30 st %g2, [ %i0 + 0x30 ]
return &the_chain->Tail.Node;
4000d5a8: 88 00 60 34 add %g1, 0x34, %g4
new_first->previous = head;
4000d5ac: f8 20 a0 04 st %i4, [ %g2 + 4 ]
4000d5b0: c2 26 60 5c st %g1, [ %i1 + 0x5c ]
head->next = tail;
4000d5b4: c8 20 60 30 st %g4, [ %g1 + 0x30 ]
tail->previous = head;
4000d5b8: c6 20 60 38 st %g3, [ %g1 + 0x38 ]
head->previous = NULL;
4000d5bc: 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;
4000d5c0: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
the_thread->is_fp = config->is_fp;
4000d5c4: fa 0e a0 28 ldub [ %i2 + 0x28 ], %i5
the_thread->Start.isr_level = config->isr_level;
4000d5c8: c8 06 a0 24 ld [ %i2 + 0x24 ], %g4
the_thread->Start.is_preemptible = config->is_preemptible;
4000d5cc: c6 0e a0 29 ldub [ %i2 + 0x29 ], %g3
the_thread->Start.budget_callout = config->budget_callout;
4000d5d0: c4 06 a0 1c ld [ %i2 + 0x1c ], %g2
_Thread_Timer_initialize( &the_thread->Timer, cpu );
switch ( config->budget_algorithm ) {
4000d5d4: 80 a0 60 02 cmp %g1, 2
the_thread->Start.budget_algorithm = config->budget_algorithm;
4000d5d8: c2 26 60 b0 st %g1, [ %i1 + 0xb0 ]
timer->header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ];
4000d5dc: 03 10 00 7a sethi %hi(0x4001e800), %g1
4000d5e0: 82 10 63 78 or %g1, 0x378, %g1 ! 4001eb78 <_Per_CPU_Information+0x38>
the_thread->is_fp = config->is_fp;
4000d5e4: fa 2e 60 8a stb %i5, [ %i1 + 0x8a ]
4000d5e8: c2 26 60 60 st %g1, [ %i1 + 0x60 ]
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
4000d5ec: 82 10 20 02 mov 2, %g1
the_thread->Start.isr_level = config->isr_level;
4000d5f0: c8 26 60 b8 st %g4, [ %i1 + 0xb8 ]
the_thread->Start.is_preemptible = config->is_preemptible;
4000d5f4: c6 2e 60 ac stb %g3, [ %i1 + 0xac ]
the_thread->Start.budget_callout = config->budget_callout;
4000d5f8: c4 26 60 b4 st %g2, [ %i1 + 0xb4 ]
<== NOT EXECUTED
switch ( config->budget_algorithm ) {
4000d5fc: 12 80 00 05 bne 4000d610 <_Thread_Initialize+0x13c>
<== NOT EXECUTED
4000d600: c2 26 60 74 st %g1, [ %i1 + 0x74 ]
<== NOT EXECUTED
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 =
4000d604: 03 10 00 5d sethi %hi(0x40017400), %g1
4000d608: c2 00 62 7c ld [ %g1 + 0x27c ], %g1 ! 4001767c <_Watchdog_Ticks_per_timeslice>
4000d60c: c2 26 60 8c st %g1, [ %i1 + 0x8c ]
( *scheduler->Operations.node_initialize )(
4000d610: 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,
4000d614: d0 06 80 00 ld [ %i2 ], %o0
scheduler_node = _Thread_Scheduler_get_home_node( the_thread );
4000d618: fa 06 60 38 ld [ %i1 + 0x38 ], %i5
4000d61c: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
4000d620: d6 06 a0 10 ld [ %i2 + 0x10 ], %o3
4000d624: d8 06 a0 14 ld [ %i2 + 0x14 ], %o4
4000d628: 9f c0 40 00 call %g1
4000d62c: 92 10 00 1d mov %i5, %o1
config->priority
);
scheduler_index = 1;
#endif
_Priority_Node_initialize( &the_thread->Real_priority, config->priority );
4000d630: c4 1e a0 10 ldd [ %i2 + 0x10 ], %g2
node->priority = priority;
4000d634: c4 3e 60 30 std %g2, [ %i1 + 0x30 ]
_RBTree_Initialize_one( &aggregation->Contributors, &node->Node.RBTree );
4000d638: 82 06 60 20 add %i1, 0x20, %g1
node->priority = priority;
4000d63c: 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;
4000d640: 09 20 00 00 sethi %hi(0x80000000), %g4
RB_ROOT( the_rbtree ) = the_node;
4000d644: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
return &the_chain->Tail.Node;
4000d648: 9e 06 60 e0 add %i1, 0xe0, %o7
the_thread->Wait.operations = &_Thread_queue_Operations_default;
the_thread->Start.initial_priority = config->priority;
4000d64c: c4 1e a0 10 ldd [ %i2 + 0x10 ], %g2
4000d650: f6 06 a0 20 ld [ %i2 + 0x20 ], %i3
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
4000d654: c2 16 60 0a lduh [ %i1 + 0xa ], %g1
the_thread->current_state = STATES_DORMANT;
4000d658: c8 26 60 1c st %g4, [ %i1 + 0x1c ]
4000d65c: 9a 06 60 e4 add %i1, 0xe4, %o5
the_thread->Start.initial_priority = config->priority;
4000d660: c4 3e 60 c0 std %g2, [ %i1 + 0xc0 ]
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4000d664: 09 10 00 5d sethi %hi(0x40017400), %g4
4000d668: c4 06 20 04 ld [ %i0 + 4 ], %g2
RB_PARENT( the_node, Node ) = NULL;
4000d66c: c0 26 60 28 clr [ %i1 + 0x28 ]
4000d670: 88 11 22 68 or %g4, 0x268, %g4
RB_LEFT( the_node, Node ) = NULL;
4000d674: c0 26 60 20 clr [ %i1 + 0x20 ]
4000d678: 83 28 60 02 sll %g1, 2, %g1
RB_RIGHT( the_node, Node ) = NULL;
4000d67c: c0 26 60 24 clr [ %i1 + 0x24 ]
4000d680: 82 00 7f fc add %g1, -4, %g1
RB_COLOR( the_node, Node ) = RB_BLACK;
4000d684: c0 26 60 2c clr [ %i1 + 0x2c ]
_User_extensions_Iterate(
4000d688: 94 10 20 00 clr %o2
4000d68c: c8 26 60 58 st %g4, [ %i1 + 0x58 ]
4000d690: 13 10 00 25 sethi %hi(0x40009400), %o1
RB_INIT( the_rbtree );
4000d694: c0 26 61 60 clr [ %i1 + 0x160 ]
4000d698: 92 12 61 58 or %o1, 0x158, %o1
head->next = tail;
4000d69c: da 26 60 e0 st %o5, [ %i1 + 0xe0 ]
4000d6a0: 90 07 bf f8 add %fp, -8, %o0
head->previous = NULL;
4000d6a4: c0 26 60 e4 clr [ %i1 + 0xe4 ]
tail->previous = head;
4000d6a8: de 26 60 e8 st %o7, [ %i1 + 0xe8 ]
the_object->name = name;
4000d6ac: f6 26 60 0c st %i3, [ %i1 + 0xc ]
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
4000d6b0: f2 20 80 01 st %i1, [ %g2 + %g1 ]
User_extensions_Thread_create_context ctx = { created, true };
4000d6b4: 82 10 20 01 mov 1, %g1
4000d6b8: f2 27 bf f8 st %i1, [ %fp + -8 ]
_User_extensions_Iterate(
4000d6bc: 7f ff ef f7 call 40009698 <_User_extensions_Iterate>
<== NOT EXECUTED
4000d6c0: c2 2f bf fc stb %g1, [ %fp + -4 ]
<== NOT EXECUTED
* 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 )
4000d6c4: f0 0f bf fc ldub [ %fp + -4 ], %i0
<== NOT EXECUTED
4000d6c8: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4000d6cc: 12 80 00 0b bne 4000d6f8 <_Thread_Initialize+0x224>
<== NOT EXECUTED
4000d6d0: 01 00 00 00 nop
<== NOT EXECUTED
--scheduler_index;
_Scheduler_Node_destroy( scheduler_for_index, scheduler_node_for_index );
}
#else
if ( scheduler_index > 0 ) {
_Scheduler_Node_destroy( config->scheduler, scheduler_node );
4000d6d4: d0 06 80 00 ld [ %i2 ], %o0
<== NOT EXECUTED
( *scheduler->Operations.node_destroy )( scheduler, node );
4000d6d8: c2 02 20 28 ld [ %o0 + 0x28 ], %g1
<== NOT EXECUTED
4000d6dc: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000d6e0: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
}
#endif
_Freechain_Put(
4000d6e4: d2 06 60 5c ld [ %i1 + 0x5c ], %o1
<== NOT EXECUTED
4000d6e8: 7f ff fc 05 call 4000c6fc <_Freechain_Put>
<== NOT EXECUTED
4000d6ec: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
&information->Thread_queue_heads.Free,
the_thread->Wait.spare_heads
);
_Stack_Free( the_thread->Start.allocated_stack );
4000d6f0: 7f ff eb 1f call 4000836c <_Stack_Free>
4000d6f4: d0 06 60 c8 ld [ %i1 + 0xc8 ], %o0
return false;
}
4000d6f8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d6fc: 81 e8 00 00 restore
<== NOT EXECUTED
4000c15c <_Thread_Iterate>:
void _Thread_Iterate(
Thread_Visitor visitor,
void *arg
)
{
4000c15c: 9d e3 bf a0 save %sp, -96, %sp
4000c160: 35 10 00 6d sethi %hi(0x4001b400), %i2
4000c164: b4 16 a2 a0 or %i2, 0x2a0, %i2 ! 4001b6a0 <_Objects_Information_table>
4000c168: a0 06 a0 0c add %i2, 0xc, %l0
const Objects_Information *information;
Objects_Maximum maximum;
Objects_Maximum index;
_Assert( _Objects_Information_table[ api_index ] != NULL );
information = _Objects_Information_table[ api_index ][ 1 ];
4000c16c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4000c170: f6 00 60 04 ld [ %g1 + 4 ], %i3
if ( information == NULL ) {
4000c174: 80 a6 e0 00 cmp %i3, 0
4000c178: 22 80 00 1c be,a 4000c1e8 <_Thread_Iterate+0x8c>
4000c17c: b4 06 a0 04 add %i2, 4, %i2
continue;
}
maximum = _Objects_Get_maximum_index( information );
for ( index = 0 ; index < maximum ; ++index ) {
4000c180: c4 16 e0 02 lduh [ %i3 + 2 ], %g2
4000c184: 80 a0 a0 00 cmp %g2, 0
4000c188: 02 80 00 17 be 4000c1e4 <_Thread_Iterate+0x88>
<== NEVER TAKEN
4000c18c: c2 06 c0 00 ld [ %i3 ], %g1
4000c190: b8 00 7f ff add %g1, -1, %i4
4000c194: ba 10 20 00 clr %i5
4000c198: b9 2f 20 10 sll %i4, 0x10, %i4
4000c19c: b9 37 20 0e srl %i4, 0xe, %i4
4000c1a0: 10 80 00 05 b 4000c1b4 <_Thread_Iterate+0x58>
4000c1a4: b8 07 20 04 add %i4, 4, %i4
4000c1a8: 80 a7 00 1d cmp %i4, %i5
4000c1ac: 22 80 00 0f be,a 4000c1e8 <_Thread_Iterate+0x8c>
4000c1b0: b4 06 a0 04 add %i2, 4, %i2
Thread_Control *the_thread;
the_thread = (Thread_Control *) information->local_table[ index ];
4000c1b4: c2 06 e0 04 ld [ %i3 + 4 ], %g1
4000c1b8: d0 00 40 1d ld [ %g1 + %i5 ], %o0
if ( the_thread != NULL ) {
4000c1bc: 80 a2 20 00 cmp %o0, 0
4000c1c0: 22 bf ff fa be,a 4000c1a8 <_Thread_Iterate+0x4c>
4000c1c4: ba 07 60 04 add %i5, 4, %i5
bool done;
done = (* visitor )( the_thread, arg );
4000c1c8: 9f c6 00 00 call %i0
4000c1cc: 92 10 00 19 mov %i1, %o1
if ( done ) {
4000c1d0: 80 a2 20 00 cmp %o0, 0
4000c1d4: 02 bf ff f5 be 4000c1a8 <_Thread_Iterate+0x4c>
<== ALWAYS TAKEN
4000c1d8: ba 07 60 04 add %i5, 4, %i5
4000c1dc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c1e0: 81 e8 00 00 restore
<== NOT EXECUTED
4000c1e4: b4 06 a0 04 add %i2, 4, %i2
<== NOT EXECUTED
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; ++api_index ) {
4000c1e8: 80 a4 00 1a cmp %l0, %i2
4000c1ec: 32 bf ff e1 bne,a 4000c170 <_Thread_Iterate+0x14>
4000c1f0: c2 06 a0 04 ld [ %i2 + 4 ], %g1
return;
}
}
}
}
}
4000c1f4: 81 c7 e0 08 ret
4000c1f8: 81 e8 00 00 restore
40008154 <_Thread_Kill_zombies>:
{
40008154: 9d e3 bf a0 save %sp, -96, %sp
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008158: 91 d0 20 09 ta 9
return _Chain_Immutable_head( the_chain )->next;
4000815c: 05 10 00 68 sethi %hi(0x4001a000), %g2
40008160: fa 00 a3 18 ld [ %g2 + 0x318 ], %i5 ! 4001a318 <_Thread_Zombies>
40008164: b6 10 a3 18 or %g2, 0x318, %i3
if ( !_Chain_Is_empty(the_chain))
40008168: b0 06 e0 04 add %i3, 4, %i0
4000816c: 80 a7 40 18 cmp %i5, %i0
40008170: 02 80 00 3a be 40008258 <_Thread_Kill_zombies+0x104>
<== ALWAYS TAKEN
40008174: 33 10 00 25 sethi %hi(0x40009400), %i1
new_first = old_first->next;
40008178: c6 07 40 00 ld [ %i5 ], %g3
<== NOT EXECUTED
head->next = new_first;
4000817c: c6 20 a3 18 st %g3, [ %g2 + 0x318 ]
<== NOT EXECUTED
new_first->previous = head;
40008180: f6 20 e0 04 st %i3, [ %g3 + 4 ]
<== NOT EXECUTED
40008184: 35 10 00 5a sethi %hi(0x40016800), %i2
<== NOT EXECUTED
_User_extensions_Iterate(
40008188: b2 16 61 94 or %i1, 0x194, %i1
<== NOT EXECUTED
4000818c: b4 16 a2 b0 or %i2, 0x2b0, %i2
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008190: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008194: 01 00 00 00 nop
<== NOT EXECUTED
Thread_Information *information = (Thread_Information *)
40008198: 40 00 11 2f call 4000c654 <_Objects_Get_information_id>
<== NOT EXECUTED
4000819c: d0 07 60 08 ld [ %i5 + 8 ], %o0
<== NOT EXECUTED
400081a0: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
400081a4: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
400081a8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400081ac: 40 00 05 3b call 40009698 <_User_extensions_Iterate>
<== NOT EXECUTED
400081b0: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400081b4: 91 d0 20 09 ta 9
<== NOT EXECUTED
iter = the_thread->last_user_extensions_iterator;
400081b8: c4 07 61 8c ld [ %i5 + 0x18c ], %g2
<== NOT EXECUTED
while ( iter != NULL ) {
400081bc: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
400081c0: 02 80 00 0a be 400081e8 <_Thread_Kill_zombies+0x94>
<== NOT EXECUTED
400081c4: 01 00 00 00 nop
<== NOT EXECUTED
next = the_node->next;
400081c8: c8 00 80 00 ld [ %g2 ], %g4
<== NOT EXECUTED
previous = the_node->previous;
400081cc: c6 00 a0 04 ld [ %g2 + 4 ], %g3
<== NOT EXECUTED
next->previous = previous;
400081d0: c6 21 20 04 st %g3, [ %g4 + 4 ]
<== NOT EXECUTED
previous->next = next;
400081d4: c8 20 c0 00 st %g4, [ %g3 ]
<== NOT EXECUTED
iter = iter->previous;
400081d8: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
<== NOT EXECUTED
while ( iter != NULL ) {
400081dc: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
400081e0: 32 bf ff fb bne,a 400081cc <_Thread_Kill_zombies+0x78>
<== NOT EXECUTED
400081e4: c8 00 80 00 ld [ %g2 ], %g4
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400081e8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400081ec: 01 00 00 00 nop
<== NOT EXECUTED
( *scheduler->Operations.node_destroy )( scheduler, node );
400081f0: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
<== NOT EXECUTED
400081f4: d2 07 60 38 ld [ %i5 + 0x38 ], %o1
<== NOT EXECUTED
400081f8: 9f c0 40 00 call %g1
<== NOT EXECUTED
400081fc: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
_Freechain_Put(
40008200: d2 07 60 5c ld [ %i5 + 0x5c ], %o1
<== NOT EXECUTED
40008204: 40 00 11 3e call 4000c6fc <_Freechain_Put>
<== NOT EXECUTED
40008208: 90 07 20 30 add %i4, 0x30, %o0
<== NOT EXECUTED
_Stack_Free( the_thread->Start.allocated_stack );
4000820c: 40 00 00 58 call 4000836c <_Stack_Free>
<== NOT EXECUTED
40008210: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
<== NOT EXECUTED
_Context_Destroy( the_thread, &the_thread->Registers );
40008214: c4 01 a0 04 ld [ %g6 + 4 ], %g2
<== NOT EXECUTED
40008218: 80 a0 80 1d cmp %g2, %i5
<== NOT EXECUTED
4000821c: 22 80 00 02 be,a 40008224 <_Thread_Kill_zombies+0xd0>
<== NOT EXECUTED
40008220: c0 21 a0 04 clr [ %g6 + 4 ]
<== NOT EXECUTED
Objects_Control *the_object
)
{
_Assert( _Objects_Allocator_is_owner() );
_Assert( information->deallocate != NULL );
( *information->deallocate )( information, the_object );
40008224: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40008228: c2 07 20 0c ld [ %i4 + 0xc ], %g1
<== NOT EXECUTED
4000822c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40008230: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008234: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40008238: fa 06 c0 00 ld [ %i3 ], %i5
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
4000823c: 80 a7 40 18 cmp %i5, %i0
<== NOT EXECUTED
40008240: 02 80 00 06 be 40008258 <_Thread_Kill_zombies+0x104>
<== NOT EXECUTED
40008244: 01 00 00 00 nop
<== NOT EXECUTED
new_first = old_first->next;
40008248: c4 07 40 00 ld [ %i5 ], %g2
<== NOT EXECUTED
head->next = new_first;
4000824c: c4 26 c0 00 st %g2, [ %i3 ]
<== NOT EXECUTED
new_first->previous = head;
40008250: 10 bf ff d0 b 40008190 <_Thread_Kill_zombies+0x3c>
<== NOT EXECUTED
40008254: f6 20 a0 04 st %i3, [ %g2 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008258: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000825c: 01 00 00 00 nop
<== NOT EXECUTED
}
40008260: 81 c7 e0 08 ret
<== NOT EXECUTED
40008264: 81 e8 00 00 restore
40008118 <_Thread_Restart_other>:
bool _Thread_Restart_other(
Thread_Control *the_thread,
const Thread_Entry_information *entry,
ISR_lock_Context *lock_context
)
{
40008118: 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 ) ) {
4000811c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
40008120: 80 a0 60 00 cmp %g1, 0
40008124: 06 80 00 3e bl 4000821c <_Thread_Restart_other+0x104>
40008128: 01 00 00 00 nop
_Thread_State_release( the_thread, lock_context );
return false;
}
the_thread->Start.Entry = *entry;
4000812c: c2 06 40 00 ld [ %i1 ], %g1
40008130: c2 26 20 a0 st %g1, [ %i0 + 0xa0 ]
40008134: c2 06 60 04 ld [ %i1 + 4 ], %g1
40008138: c2 26 20 a4 st %g1, [ %i0 + 0xa4 ]
previous = the_thread->Life.state;
4000813c: c2 06 21 70 ld [ %i0 + 0x170 ], %g1
the_thread->Start.Entry = *entry;
40008140: c6 06 60 08 ld [ %i1 + 8 ], %g3
state |= set;
40008144: 84 10 60 02 or %g1, 2, %g2
the_thread->Start.Entry = *entry;
40008148: c6 26 20 a8 st %g3, [ %i0 + 0xa8 ]
if (
4000814c: 80 88 60 09 btst 9, %g1
40008150: 02 80 00 12 be 40008198 <_Thread_Restart_other+0x80>
<== ALWAYS TAKEN
40008154: c4 26 21 70 st %g2, [ %i0 + 0x170 ]
disable_level = cpu_self->thread_dispatch_disable_level;
40008158: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000815c: 82 00 60 01 inc %g1
<== NOT EXECUTED
40008160: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40008164: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
_Thread_Finalize_life_change(
the_thread,
the_thread->Start.initial_priority
);
} else {
_Thread_Clear_state_locked( the_thread, STATES_SUSPENDED );
40008168: 13 00 00 20 sethi %hi(0x8000), %o1
<== NOT EXECUTED
4000816c: 40 00 14 57 call 4000d2c8 <_Thread_Clear_state_locked>
<== NOT EXECUTED
40008170: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008174: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008178: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000817c: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_State_release( the_thread, lock_context );
}
_Thread_Dispatch_enable( cpu_self );
40008180: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40008184: 7f ff fd 77 call 40007760 <_Thread_Dispatch_enable>
40008188: b0 10 20 01 mov 1, %i0
4000818c: b0 0e 20 ff and %i0, 0xff, %i0
return true;
}
40008190: 81 c7 e0 08 ret
40008194: 81 e8 00 00 restore
40008198: 7f ff fe 8b call 40007bc4 <_Thread_Change_life_locked.part.36>
4000819c: 90 10 00 18 mov %i0, %o0
disable_level = cpu_self->thread_dispatch_disable_level;
400081a0: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
pending_requests = the_thread->Life.pending_life_change_requests;
400081a4: c4 06 21 74 ld [ %i0 + 0x174 ], %g2
cpu_self->thread_dispatch_disable_level = disable_level + 1;
400081a8: 82 00 60 01 inc %g1
400081ac: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
the_thread->Life.pending_life_change_requests = pending_requests + 1;
400081b0: 82 00 a0 01 add %g2, 1, %g1
400081b4: c2 26 21 74 st %g1, [ %i0 + 0x174 ]
if ( pending_requests == 0 ) {
400081b8: 80 a0 a0 00 cmp %g2, 0
400081bc: 02 80 00 1f be 40008238 <_Thread_Restart_other+0x120>
<== ALWAYS TAKEN
400081c0: ba 10 00 06 mov %g6, %i5
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400081c4: c2 06 80 00 ld [ %i2 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400081c8: 91 d0 20 0a ta 0xa
400081cc: 01 00 00 00 nop
_Thread_Finalize_life_change(
400081d0: f4 1e 20 c0 ldd [ %i0 + 0xc0 ], %i2
_Thread_queue_Extract_with_proxy( the_thread );
400081d4: 40 00 01 f1 call 40008998 <_Thread_queue_Extract_with_proxy>
400081d8: 90 10 00 18 mov %i0, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400081dc: 91 d0 20 09 ta 9
return psr;
400081e0: c2 27 bf fc st %g1, [ %fp + -4 ]
400081e4: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
400081e8: 40 00 04 81 call 400093ec <_Watchdog_Remove>
400081ec: 92 06 20 68 add %i0, 0x68, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400081f0: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400081f4: 91 d0 20 0a ta 0xa
400081f8: 01 00 00 00 nop
_Thread_Raise_real_priority( the_thread, priority );
400081fc: 90 10 00 18 mov %i0, %o0
40008200: 92 10 00 1a mov %i2, %o1
40008204: 7f ff fe 4c call 40007b34 <_Thread_Raise_real_priority>
40008208: 94 10 00 1b mov %i3, %o2
_Thread_Remove_life_change_request( the_thread );
4000820c: 7f ff fe 35 call 40007ae0 <_Thread_Remove_life_change_request>
40008210: 90 10 00 18 mov %i0, %o0
_Thread_Dispatch_enable( cpu_self );
40008214: 10 bf ff dc b 40008184 <_Thread_Restart_other+0x6c>
40008218: 90 10 00 1d mov %i5, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000821c: c2 06 80 00 ld [ %i2 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008220: 91 d0 20 0a ta 0xa
40008224: 01 00 00 00 nop
return false;
40008228: b0 10 20 00 clr %i0 ! 0 <PROM_START>
4000822c: b0 0e 20 ff and %i0, 0xff, %i0
}
40008230: 81 c7 e0 08 ret
40008234: 81 e8 00 00 restore
_Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING );
40008238: 13 00 00 80 sethi %hi(0x20000), %o1
4000823c: 40 00 00 48 call 4000835c <_Thread_Set_state_locked>
40008240: 90 10 00 18 mov %i0, %o0
40008244: 30 bf ff e0 b,a 400081c4 <_Thread_Restart_other+0xac>
40008248 <_Thread_Restart_self>:
void _Thread_Restart_self(
Thread_Control *executing,
const Thread_Entry_information *entry,
ISR_lock_Context *lock_context
)
{
40008248: 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;
4000824c: c2 06 40 00 ld [ %i1 ], %g1
40008250: c2 26 20 a0 st %g1, [ %i0 + 0xa0 ]
40008254: 90 10 00 18 mov %i0, %o0
40008258: c2 06 60 04 ld [ %i1 + 4 ], %g1
4000825c: c2 26 20 a4 st %g1, [ %i0 + 0xa4 ]
state |= set;
40008260: c2 06 21 70 ld [ %i0 + 0x170 ], %g1
executing->Start.Entry = *entry;
40008264: c4 06 60 08 ld [ %i1 + 8 ], %g2
state |= set;
40008268: 82 10 60 02 or %g1, 2, %g1
executing->Start.Entry = *entry;
4000826c: c4 26 20 a8 st %g2, [ %i0 + 0xa8 ]
the_thread->Life.state = state;
40008270: c2 26 21 70 st %g1, [ %i0 + 0x170 ]
40008274: 7f ff fe 54 call 40007bc4 <_Thread_Change_life_locked.part.36>
40008278: c0 27 bf f0 clr [ %fp + -16 ]
disable_level = cpu_self->thread_dispatch_disable_level;
4000827c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40008280: 82 00 60 01 inc %g1
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40008284: ba 10 00 06 mov %g6, %i5
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40008288: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000828c: c2 06 80 00 ld [ %i2 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008290: 91 d0 20 0a ta 0xa
40008294: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008298: 91 d0 20 09 ta 9
_ISR_lock_ISR_disable( lock_context );
4000829c: c2 26 80 00 st %g1, [ %i2 ]
400082a0: c4 1e 20 c0 ldd [ %i0 + 0xc0 ], %g2
400082a4: c4 3e 20 30 std %g2, [ %i0 + 0x30 ]
_Thread_Priority_changed(
400082a8: 94 10 20 00 clr %o2
400082ac: 96 07 bf dc add %fp, -36, %o3
400082b0: 92 06 20 20 add %i0, 0x20, %o1
400082b4: 7f ff fc bb call 400075a0 <_Thread_Priority_changed>
400082b8: 90 10 00 18 mov %i0, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400082bc: c2 06 80 00 ld [ %i2 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400082c0: 91 d0 20 0a ta 0xa
400082c4: 01 00 00 00 nop
false,
&queue_context
);
_Thread_Wait_release_default( executing, lock_context );
_Thread_Priority_update( &queue_context );
400082c8: 7f ff fc bd call 400075bc <_Thread_Priority_update>
400082cc: 90 07 bf dc add %fp, -36, %o0
_Thread_Dispatch_direct( cpu_self );
400082d0: 7f ff fd 19 call 40007734 <_Thread_Dispatch_direct>
400082d4: 90 10 00 1d mov %i5, %o0
400082d8: 01 00 00 00 nop
<== NOT EXECUTED
400082e8 <_Thread_Set_state_locked>:
States_Control _Thread_Set_state_locked(
Thread_Control *the_thread,
States_Control state
)
{
400082e8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
400082ec: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
States_Control next_state;
_Assert( state != 0 );
_Assert( _Thread_State_is_owner( the_thread ) );
previous_state = the_thread->current_state;
400082f0: f0 06 20 1c ld [ %i0 + 0x1c ], %i0
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE States_Control _States_Set (
States_Control states_to_set,
States_Control current_state
)
{
return (current_state | states_to_set);
400082f4: b2 16 00 19 or %i0, %i1, %i1
<== NOT EXECUTED
next_state = _States_Set( state, previous_state);
the_thread->current_state = next_state;
if ( _States_Is_ready( previous_state ) ) {
400082f8: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
400082fc: 12 80 00 07 bne 40008318 <_Thread_Set_state_locked+0x30>
<== NOT EXECUTED
40008300: f2 22 60 1c st %i1, [ %o1 + 0x1c ]
<== NOT EXECUTED
( *scheduler->Operations.block )(
40008304: 11 10 00 5a sethi %hi(0x40016800), %o0
<== NOT EXECUTED
40008308: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 40016ab0 <_Scheduler_Table>
<== NOT EXECUTED
4000830c: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
<== NOT EXECUTED
40008310: 9f c0 40 00 call %g1
<== NOT EXECUTED
40008314: d4 02 60 38 ld [ %o1 + 0x38 ], %o2
<== NOT EXECUTED
_Scheduler_Block( the_thread );
}
return previous_state;
}
40008318: 81 c7 e0 08 ret
<== NOT EXECUTED
4000831c: 81 e8 00 00 restore
<== NOT EXECUTED
4000d778 <_Thread_Start_multitasking>:
#include <rtems/score/threadimpl.h>
#include <rtems/score/assert.h>
void _Thread_Start_multitasking( void )
{
4000d778: 9d e3 bf a0 save %sp, -96, %sp
heir = cpu_self->heir;
4000d77c: c4 01 a0 24 ld [ %g6 + 0x24 ], %g2
cpu_self->dispatch_necessary = false;
4000d780: 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 );
4000d784: 90 00 a0 f0 add %g2, 0xf0, %o0
4000d788: 7f ff f7 04 call 4000b398 <_CPU_Context_restore>
4000d78c: c4 21 a0 20 st %g2, [ %g6 + 0x20 ]
4000d790: 01 00 00 00 nop
<== NOT EXECUTED
400084f4 <_Thread_Timeout>:
the_thread = RTEMS_CONTAINER_OF(
the_watchdog,
Thread_Control,
Timer.Watchdog
);
_Thread_Continue( the_thread, STATUS_TIMEOUT );
400084f4: 13 00 00 1d sethi %hi(0x7400), %o1
<== NOT EXECUTED
400084f8: 90 02 3f 98 add %o0, -104, %o0
<== NOT EXECUTED
400084fc: 92 12 60 06 or %o1, 6, %o1
<== NOT EXECUTED
40008500: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40008504: 7f ff ff cf call 40008440 <_Thread_Continue>
<== NOT EXECUTED
40008508: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000969c <_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;
4000969c: c2 02 20 54 ld [ %o0 + 0x54 ], %g1
if ( queue != NULL && queue->name == _Thread_queue_Object_name ) {
400096a0: 80 a0 60 00 cmp %g1, 0
400096a4: 02 80 00 08 be 400096c4 <_Thread_Wait_get_id+0x28>
400096a8: 90 10 20 00 clr %o0
400096ac: c6 00 60 08 ld [ %g1 + 8 ], %g3
400096b0: 05 10 00 42 sethi %hi(0x40010800), %g2
400096b4: 84 10 a1 30 or %g2, 0x130, %g2 ! 40010930 <_Thread_queue_Object_name>
400096b8: 80 a0 c0 02 cmp %g3, %g2
400096bc: 02 80 00 04 be 400096cc <_Thread_Wait_get_id+0x30>
<== ALWAYS TAKEN
400096c0: 01 00 00 00 nop
queue_object = THREAD_QUEUE_QUEUE_TO_OBJECT( queue );
return queue_object->Object.id;
}
return 0;
}
400096c4: 81 c3 e0 08 retl
400096c8: 01 00 00 00 nop
400096cc: 81 c3 e0 08 retl
400096d0: d0 00 7f f8 ld [ %g1 + -8 ], %o0
4000850c <_Thread_Yield>:
#include <rtems/score/threadimpl.h>
#include <rtems/score/schedulerimpl.h>
void _Thread_Yield( Thread_Control *executing )
{
4000850c: 9d e3 bf 98 save %sp, -104, %sp
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008510: 91 d0 20 09 ta 9
ISR_lock_Context lock_context;
_Thread_State_acquire( executing, &lock_context );
if ( _States_Is_ready( executing->current_state ) ) {
40008514: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
40008518: 80 a0 a0 00 cmp %g2, 0
4000851c: 12 80 00 09 bne 40008540 <_Thread_Yield+0x34>
<== NEVER TAKEN
40008520: 11 10 00 5a sethi %hi(0x40016800), %o0
( *scheduler->Operations.yield )(
40008524: d4 06 20 38 ld [ %i0 + 0x38 ], %o2
40008528: 90 12 22 b0 or %o0, 0x2b0, %o0
4000852c: c4 02 20 0c ld [ %o0 + 0xc ], %g2
40008530: c2 27 bf fc st %g1, [ %fp + -4 ]
40008534: 9f c0 80 00 call %g2
40008538: 92 10 00 18 mov %i0, %o1
4000853c: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008540: 91 d0 20 0a ta 0xa
40008544: 01 00 00 00 nop
_Scheduler_Yield( executing );
}
_Thread_State_release( executing, &lock_context );
}
40008548: 81 c7 e0 08 ret
4000854c: 81 e8 00 00 restore
400085c4 <_Thread_queue_Enqueue>:
{
400085c4: 9d e3 bf 98 save %sp, -104, %sp
the_thread->Wait.queue = queue;
400085c8: f0 26 a0 54 st %i0, [ %i2 + 0x54 ]
400085cc: 10 80 00 08 b 400085ec <_Thread_queue_Enqueue+0x28>
400085d0: 82 10 00 18 mov %i0, %g1
if ( owner == the_thread ) {
400085d4: 22 80 00 44 be,a 400086e4 <_Thread_queue_Enqueue+0x120>
400085d8: c0 26 a0 54 clr [ %i2 + 0x54 ]
queue = owner->Wait.queue;
400085dc: c2 00 60 54 ld [ %g1 + 0x54 ], %g1
} while ( queue != NULL );
400085e0: 80 a0 60 00 cmp %g1, 0
400085e4: 22 80 00 07 be,a 40008600 <_Thread_queue_Enqueue+0x3c>
400085e8: c0 26 e0 14 clr [ %i3 + 0x14 ]
owner = queue->owner;
400085ec: c2 00 60 04 ld [ %g1 + 4 ], %g1
if ( owner == NULL ) {
400085f0: 80 a0 60 00 cmp %g1, 0
400085f4: 12 bf ff f8 bne 400085d4 <_Thread_queue_Enqueue+0x10>
400085f8: 80 a6 80 01 cmp %i2, %g1
400085fc: c0 26 e0 14 clr [ %i3 + 0x14 ]
( *operations->enqueue )( queue, the_thread, queue_context );
40008600: 94 10 00 1b mov %i3, %o2
the_thread->Wait.operations = operations;
40008604: f2 26 a0 58 st %i1, [ %i2 + 0x58 ]
40008608: 92 10 00 1a mov %i2, %o1
4000860c: c2 06 60 04 ld [ %i1 + 4 ], %g1
40008610: 9f c0 40 00 call %g1
40008614: 90 10 00 18 mov %i0, %o0
the_thread->Wait.flags = flags;
40008618: 82 10 24 01 mov 0x401, %g1
4000861c: c2 26 a0 50 st %g1, [ %i2 + 0x50 ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40008620: ba 10 00 06 mov %g6, %i5
disable_level = cpu_self->thread_dispatch_disable_level;
40008624: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
the_thread->Wait.return_code = STATUS_SUCCESSFUL;
40008628: c0 26 a0 4c clr [ %i2 + 0x4c ]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000862c: 82 00 60 01 inc %g1
40008630: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008634: c2 06 c0 00 ld [ %i3 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008638: 91 d0 20 0a ta 0xa
4000863c: 01 00 00 00 nop
( *queue_context->enqueue_callout )(
40008640: c2 06 e0 08 ld [ %i3 + 8 ], %g1
40008644: 96 10 00 1b mov %i3, %o3
40008648: 94 10 00 06 mov %g6, %o2
4000864c: 92 10 00 1a mov %i2, %o1
40008650: 9f c0 40 00 call %g1
40008654: 90 10 00 18 mov %i0, %o0
_Thread_Set_state( the_thread, queue_context->thread_state );
40008658: d2 06 e0 04 ld [ %i3 + 4 ], %o1
4000865c: 7f ff ff 31 call 40008320 <_Thread_Set_state>
40008660: 90 10 00 1a mov %i2, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008664: 91 d0 20 09 ta 9
bool success = ( the_thread->Wait.flags == expected_flags );
40008668: c4 06 a0 50 ld [ %i2 + 0x50 ], %g2
if ( success ) {
4000866c: 80 a0 a4 01 cmp %g2, 0x401
40008670: 02 80 00 28 be 40008710 <_Thread_queue_Enqueue+0x14c>
40008674: 86 10 24 02 mov 0x402, %g3
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008678: 91 d0 20 0a ta 0xa
4000867c: 01 00 00 00 nop
if ( !success ) {
40008680: 80 a0 a4 01 cmp %g2, 0x401
40008684: 12 80 00 07 bne 400086a0 <_Thread_queue_Enqueue+0xdc>
<== ALWAYS TAKEN
40008688: 01 00 00 00 nop
_Thread_Priority_update( queue_context );
4000868c: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
40008690: 40 00 13 06 call 4000d2a8 <_Thread_Priority_update>
40008694: b0 10 00 1d mov %i5, %i0
_Thread_Dispatch_direct( cpu_self );
40008698: 7f ff fd b4 call 40007d68 <_Thread_Dispatch_direct>
4000869c: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400086a0: 91 d0 20 09 ta 9
return psr;
400086a4: c2 27 bf fc st %g1, [ %fp + -4 ]
400086a8: d0 06 a0 60 ld [ %i2 + 0x60 ], %o0
400086ac: 40 00 03 6e call 40009464 <_Watchdog_Remove>
400086b0: 92 06 a0 68 add %i2, 0x68, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400086b4: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400086b8: 91 d0 20 0a ta 0xa
400086bc: 01 00 00 00 nop
_Thread_Clear_state( the_thread, STATES_BLOCKED );
400086c0: 13 0c 00 57 sethi %hi(0x30015c00), %o1
400086c4: 90 10 00 1a mov %i2, %o0
400086c8: 40 00 13 25 call 4000d35c <_Thread_Clear_state>
400086cc: 92 12 63 ff or %o1, 0x3ff, %o1
_Thread_Priority_update( queue_context );
400086d0: 90 10 00 1b mov %i3, %o0
400086d4: 40 00 12 f5 call 4000d2a8 <_Thread_Priority_update>
400086d8: b0 10 00 1d mov %i5, %i0
_Thread_Dispatch_direct( cpu_self );
400086dc: 7f ff fd a3 call 40007d68 <_Thread_Dispatch_direct>
400086e0: 81 e8 00 00 restore
the_thread->Wait.operations = &_Thread_queue_Operations_default;
400086e4: 03 10 00 5d sethi %hi(0x40017400), %g1
400086e8: 82 10 62 68 or %g1, 0x268, %g1 ! 40017668 <_Thread_queue_Operations_default>
400086ec: c2 26 a0 58 st %g1, [ %i2 + 0x58 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400086f0: c2 06 c0 00 ld [ %i3 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400086f4: 91 d0 20 0a ta 0xa
400086f8: 01 00 00 00 nop
( *queue_context->deadlock_callout )( the_thread );
400086fc: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1
40008700: 9f c0 40 00 call %g1
40008704: 90 10 00 1a mov %i2, %o0
}
40008708: 81 c7 e0 08 ret
4000870c: 81 e8 00 00 restore
the_thread->Wait.flags = desired_flags;
40008710: c6 26 a0 50 st %g3, [ %i2 + 0x50 ]
40008714: 91 d0 20 0a ta 0xa
40008718: 01 00 00 00 nop
if ( !success ) {
4000871c: 80 a0 a4 01 cmp %g2, 0x401
40008720: 22 bf ff dc be,a 40008690 <_Thread_queue_Enqueue+0xcc>
<== ALWAYS TAKEN
40008724: 90 10 00 1b mov %i3, %o0
40008728: 30 bf ff de b,a 400086a0 <_Thread_queue_Enqueue+0xdc>
<== NOT EXECUTED
4000879c <_Thread_queue_Extract>:
&queue_context->Lock_context.Lock_context
);
}
void _Thread_queue_Extract( Thread_Control *the_thread )
{
4000879c: 9d e3 bf 78 save %sp, -136, %sp
400087a0: c0 27 bf f0 clr [ %fp + -16 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400087a4: 91 d0 20 09 ta 9
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
400087a8: 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;
400087ac: d0 06 20 54 ld [ %i0 + 0x54 ], %o0
if ( queue != NULL ) {
400087b0: 80 a2 20 00 cmp %o0, 0
400087b4: 02 80 00 1c be 40008824 <_Thread_queue_Extract+0x88>
400087b8: 92 10 00 18 mov %i0, %o1
( *operations->extract )( queue, the_thread, queue_context );
400087bc: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
400087c0: c2 00 60 08 ld [ %g1 + 8 ], %g1
400087c4: 9f c0 40 00 call %g1
400087c8: 94 07 bf dc add %fp, -36, %o2
if ( success ) {
400087cc: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
400087d0: 80 a0 64 01 cmp %g1, 0x401
the_thread->Wait.queue = NULL;
400087d4: c0 26 20 54 clr [ %i0 + 0x54 ]
the_thread->Wait.flags = desired_flags;
400087d8: 82 10 24 04 mov 0x404, %g1
if ( success ) {
400087dc: 02 80 00 0a be 40008804 <_Thread_queue_Extract+0x68>
<== NEVER TAKEN
400087e0: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
the_thread->Wait.operations = &_Thread_queue_Operations_default;
400087e4: 03 10 00 5d sethi %hi(0x40017400), %g1
400087e8: 82 10 62 68 or %g1, 0x268, %g1 ! 40017668 <_Thread_queue_Operations_default>
400087ec: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
400087f0: 92 07 bf dc add %fp, -36, %o1
400087f4: 7f ff ff 57 call 40008550 <_Thread_queue_Unblock_critical.part.31>
400087f8: 90 10 00 18 mov %i0, %o0
&queue_context.Lock_context.Lock_context
);
} else {
_Thread_Wait_release( the_thread, &queue_context );
}
}
400087fc: 81 c7 e0 08 ret
40008800: 81 e8 00 00 restore
40008804: 03 10 00 5d sethi %hi(0x40017400), %g1
<== NOT EXECUTED
40008808: 82 10 62 68 or %g1, 0x268, %g1 ! 40017668 <_Thread_queue_Operations_default>
<== NOT EXECUTED
4000880c: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008810: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008814: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008818: 01 00 00 00 nop
<== NOT EXECUTED
4000881c: 81 c7 e0 08 ret
<== NOT EXECUTED
40008820: 81 e8 00 00 restore
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008824: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008828: 91 d0 20 0a ta 0xa
4000882c: 01 00 00 00 nop
40008830: 81 c7 e0 08 ret
40008834: 81 e8 00 00 restore
4000872c <_Thread_queue_Extract_locked>:
{
4000872c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
( *operations->extract )( queue, the_thread, queue_context );
40008730: c2 06 60 08 ld [ %i1 + 8 ], %g1
<== NOT EXECUTED
40008734: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
40008738: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4000873c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40008740: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( success ) {
40008744: c2 06 a0 50 ld [ %i2 + 0x50 ], %g1
<== NOT EXECUTED
40008748: 80 a0 64 01 cmp %g1, 0x401
<== NOT EXECUTED
4000874c: 02 80 00 0b be 40008778 <_Thread_queue_Extract_locked+0x4c>
<== NOT EXECUTED
40008750: 82 10 24 04 mov 0x404, %g1
<== NOT EXECUTED
unblock = true;
40008754: b0 10 20 01 mov 1, %i0
<== NOT EXECUTED
the_thread->Wait.flags = flags;
40008758: c2 26 a0 50 st %g1, [ %i2 + 0x50 ]
<== NOT EXECUTED
return _Thread_queue_Make_ready_again( the_thread );
4000875c: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
the_thread->Wait.queue = NULL;
40008760: c0 26 a0 54 clr [ %i2 + 0x54 ]
<== NOT EXECUTED
the_thread->Wait.operations = &_Thread_queue_Operations_default;
40008764: 03 10 00 5d sethi %hi(0x40017400), %g1
<== NOT EXECUTED
40008768: 82 10 62 68 or %g1, 0x268, %g1 ! 40017668 <_Thread_queue_Operations_default>
<== NOT EXECUTED
4000876c: c2 26 a0 58 st %g1, [ %i2 + 0x58 ]
<== NOT EXECUTED
}
40008770: 81 c7 e0 08 ret
<== NOT EXECUTED
40008774: 81 e8 00 00 restore
<== NOT EXECUTED
unblock = false;
40008778: b0 10 20 00 clr %i0
<== NOT EXECUTED
the_thread->Wait.flags = desired_flags;
4000877c: c2 26 a0 50 st %g1, [ %i2 + 0x50 ]
<== NOT EXECUTED
return _Thread_queue_Make_ready_again( the_thread );
40008780: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
the_thread->Wait.queue = NULL;
40008784: c0 26 a0 54 clr [ %i2 + 0x54 ]
<== NOT EXECUTED
the_thread->Wait.operations = &_Thread_queue_Operations_default;
40008788: 03 10 00 5d sethi %hi(0x40017400), %g1
<== NOT EXECUTED
4000878c: 82 10 62 68 or %g1, 0x268, %g1 ! 40017668 <_Thread_queue_Operations_default>
<== NOT EXECUTED
40008790: c2 26 a0 58 st %g1, [ %i2 + 0x58 ]
<== NOT EXECUTED
}
40008794: 81 c7 e0 08 ret
<== NOT EXECUTED
40008798: 81 e8 00 00 restore
<== NOT EXECUTED
4000db3c <_Thread_queue_Queue_get_name_and_id>:
const Thread_queue_Queue *queue,
char *buffer,
size_t buffer_size,
Objects_Id *id
)
{
4000db3c: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
const char *name;
name = queue->name;
4000db40: c4 06 20 08 ld [ %i0 + 8 ], %g2
<== NOT EXECUTED
if ( name == _Thread_queue_Object_name ) {
4000db44: 03 10 00 94 sethi %hi(0x40025000), %g1
<== NOT EXECUTED
4000db48: 82 10 61 f8 or %g1, 0x1f8, %g1 ! 400251f8 <_Thread_queue_Object_name>
<== NOT EXECUTED
4000db4c: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4000db50: 02 80 00 0c be 4000db80 <_Thread_queue_Queue_get_name_and_id+0x44>
<== NOT EXECUTED
4000db54: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
false,
buffer,
buffer_size
);
} else {
if ( name == NULL ) {
4000db58: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000db5c: 02 80 00 05 be 4000db70 <_Thread_queue_Queue_get_name_and_id+0x34>
<== NOT EXECUTED
4000db60: c0 26 c0 00 clr [ %i3 ]
<== NOT EXECUTED
name = _Thread_queue_Object_name;
}
*id = 0;
return strlcpy( buffer, name, buffer_size );
4000db64: b2 10 00 02 mov %g2, %i1
<== NOT EXECUTED
4000db68: 40 00 2f 81 call 4001996c <strlcpy>
<== NOT EXECUTED
4000db6c: 91 e8 00 0a restore %g0, %o2, %o0
<== NOT EXECUTED
name = _Thread_queue_Object_name;
4000db70: 84 10 00 01 mov %g1, %g2
<== NOT EXECUTED
return strlcpy( buffer, name, buffer_size );
4000db74: b0 10 00 0a mov %o2, %i0
<== NOT EXECUTED
4000db78: 40 00 2f 7d call 4001996c <strlcpy>
<== NOT EXECUTED
4000db7c: 93 e8 00 02 restore %g0, %g2, %o1
<== NOT EXECUTED
*id = queue_object->Object.id;
4000db80: c4 06 3f f8 ld [ %i0 + -8 ], %g2
<== NOT EXECUTED
4000db84: c4 26 c0 00 st %g2, [ %i3 ]
<== NOT EXECUTED
return _Objects_Name_to_string(
4000db88: 96 10 00 1a mov %i2, %o3
<== NOT EXECUTED
4000db8c: c2 06 3f fc ld [ %i0 + -4 ], %g1
<== NOT EXECUTED
4000db90: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
4000db94: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000db98: 7f ff f9 aa call 4000c240 <_Objects_Name_to_string>
<== NOT EXECUTED
4000db9c: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
}
}
4000dba0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dba4: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
40008838 <_Thread_queue_Surrender>:
Thread_queue_Heads *heads,
Thread_Control *previous_owner,
Thread_queue_Context *queue_context,
const Thread_queue_Operations *operations
)
{
40008838: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
4000883c: c0 26 e0 14 clr [ %i3 + 0x14 ]
<== NOT EXECUTED
Per_CPU_Control *cpu_self;
_Assert( heads != NULL );
_Thread_queue_Context_clear_priority_updates( queue_context );
new_owner = ( *operations->surrender )(
40008840: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
40008844: c2 07 20 0c ld [ %i4 + 0xc ], %g1
<== NOT EXECUTED
40008848: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000884c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40008850: 9f c0 40 00 call %g1
<== NOT EXECUTED
40008854: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
queue,
heads,
previous_owner,
queue_context
);
queue->owner = new_owner;
40008858: d0 26 20 04 st %o0, [ %i0 + 4 ]
<== NOT EXECUTED
if ( success ) {
4000885c: c2 02 20 50 ld [ %o0 + 0x50 ], %g1
<== NOT EXECUTED
40008860: 80 a0 64 01 cmp %g1, 0x401
<== NOT EXECUTED
40008864: 02 80 00 25 be 400088f8 <_Thread_queue_Surrender+0xc0>
<== NOT EXECUTED
40008868: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
the_thread->Wait.flags = flags;
4000886c: 82 10 24 04 mov 0x404, %g1
<== NOT EXECUTED
40008870: c2 22 20 50 st %g1, [ %o0 + 0x50 ]
<== NOT EXECUTED
unblock = true;
40008874: b8 10 20 01 mov 1, %i4
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
40008878: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
the_thread->Wait.queue = NULL;
4000887c: c0 27 60 54 clr [ %i5 + 0x54 ]
<== NOT EXECUTED
the_thread->Wait.operations = &_Thread_queue_Operations_default;
40008880: 05 10 00 5d sethi %hi(0x40017400), %g2
40008884: 84 10 a2 68 or %g2, 0x268, %g2 ! 40017668 <_Thread_queue_Operations_default>
40008888: c4 27 60 58 st %g2, [ %i5 + 0x58 ]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000888c: 82 00 60 01 inc %g1
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40008890: b0 10 00 06 mov %g6, %i0
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40008894: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008898: c2 06 c0 00 ld [ %i3 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000889c: 91 d0 20 0a ta 0xa
400088a0: 01 00 00 00 nop
_Thread_queue_Queue_release(
queue,
&queue_context->Lock_context.Lock_context
);
_Thread_Priority_update( queue_context );
400088a4: 40 00 12 81 call 4000d2a8 <_Thread_Priority_update>
400088a8: 90 10 00 1b mov %i3, %o0
if ( unblock ) {
400088ac: 80 8f 20 ff btst 0xff, %i4
400088b0: 12 80 00 04 bne 400088c0 <_Thread_queue_Surrender+0x88>
<== ALWAYS TAKEN
400088b4: 01 00 00 00 nop
_Thread_Remove_timer_and_unblock( new_owner, queue );
}
_Thread_Dispatch_enable( cpu_self );
400088b8: 7f ff fd 37 call 40007d94 <_Thread_Dispatch_enable>
<== NOT EXECUTED
400088bc: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400088c0: 91 d0 20 09 ta 9
return psr;
400088c4: c2 27 bf fc st %g1, [ %fp + -4 ]
400088c8: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
400088cc: 40 00 02 e6 call 40009464 <_Watchdog_Remove>
400088d0: 92 07 60 68 add %i5, 0x68, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400088d4: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400088d8: 91 d0 20 0a ta 0xa
400088dc: 01 00 00 00 nop
_Thread_Clear_state( the_thread, STATES_BLOCKED );
400088e0: 13 0c 00 57 sethi %hi(0x30015c00), %o1
400088e4: 90 10 00 1d mov %i5, %o0
400088e8: 40 00 12 9d call 4000d35c <_Thread_Clear_state>
400088ec: 92 12 63 ff or %o1, 0x3ff, %o1
400088f0: 7f ff fd 29 call 40007d94 <_Thread_Dispatch_enable>
400088f4: 81 e8 00 00 restore
the_thread->Wait.flags = desired_flags;
400088f8: 82 10 24 04 mov 0x404, %g1
<== NOT EXECUTED
unblock = false;
400088fc: b8 10 20 00 clr %i4
<== NOT EXECUTED
40008900: 10 bf ff de b 40008878 <_Thread_queue_Surrender+0x40>
<== NOT EXECUTED
40008904: c2 22 20 50 st %g1, [ %o0 + 0x50 ]
<== NOT EXECUTED
4000ad0c <_Timecounter_Bintime>:
{
4000ad0c: 9d e3 bf a0 save %sp, -96, %sp
4000ad10: 33 10 00 68 sethi %hi(0x4001a000), %i1
4000ad14: b2 16 63 74 or %i1, 0x374, %i1 ! 4001a374 <timehands>
th = timehands;
4000ad18: fa 06 40 00 ld [ %i1 ], %i5
gen = atomic_load_acq_int(&th->th_generation);
4000ad1c: f4 07 60 70 ld [ %i5 + 0x70 ], %i2
*bt = th->th_bintime;
4000ad20: c4 1f 60 30 ldd [ %i5 + 0x30 ], %g2
4000ad24: c4 3e 00 00 std %g2, [ %i0 ]
4000ad28: c4 1f 60 38 ldd [ %i5 + 0x38 ], %g2
bintime_addx(bt, th->th_scale * tc_delta(th));
4000ad2c: f6 07 40 00 ld [ %i5 ], %i3
*bt = th->th_bintime;
4000ad30: c4 3e 20 08 std %g2, [ %i0 + 8 ]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
4000ad34: 90 10 00 1b mov %i3, %o0
4000ad38: c2 06 c0 00 ld [ %i3 ], %g1
bintime_addx(bt, th->th_scale * tc_delta(th));
4000ad3c: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
4000ad40: 9f c0 40 00 call %g1
4000ad44: e0 07 60 14 ld [ %i5 + 0x14 ], %l0
4000ad48: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
4000ad4c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000ad50: f6 06 e0 04 ld [ %i3 + 4 ], %i3
4000ad54: 90 22 00 01 sub %o0, %g1, %o0
4000ad58: 90 0a 00 1b and %o0, %i3, %o0
bintime_addx(bt, th->th_scale * tc_delta(th));
4000ad5c: b8 5f 00 08 smul %i4, %o0, %i4
4000ad60: 92 52 00 10 umul %o0, %l0, %o1
4000ad64: 91 40 00 00 rd %y, %o0
4000ad68: 90 07 00 08 add %i4, %o0, %o0
4000ad6c: 9a 82 40 03 addcc %o1, %g3, %o5
4000ad70: 98 c2 00 02 addxcc %o0, %g2, %o4
4000ad74: 0a 80 00 12 bcs 4000adbc <_Timecounter_Bintime+0xb0>
4000ad78: 88 10 20 00 clr %g4
if (_u > _bt->frac)
4000ad7c: 80 a1 20 00 cmp %g4, 0
4000ad80: 02 80 00 06 be 4000ad98 <_Timecounter_Bintime+0x8c>
4000ad84: d8 3e 20 08 std %o4, [ %i0 + 8 ]
_bt->sec++;
4000ad88: c4 1e 00 00 ldd [ %i0 ], %g2
4000ad8c: 9a 80 e0 01 addcc %g3, 1, %o5
4000ad90: 98 40 a0 00 addx %g2, 0, %o4
4000ad94: d8 3e 00 00 std %o4, [ %i0 ]
} while (gen == 0 || gen != th->th_generation);
4000ad98: 80 a6 a0 00 cmp %i2, 0
4000ad9c: 02 bf ff df be 4000ad18 <_Timecounter_Bintime+0xc>
<== NEVER TAKEN
4000ada0: 01 00 00 00 nop
4000ada4: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
4000ada8: 80 a0 40 1a cmp %g1, %i2
4000adac: 12 bf ff db bne 4000ad18 <_Timecounter_Bintime+0xc>
4000adb0: 01 00 00 00 nop
}
4000adb4: 81 c7 e0 08 ret
4000adb8: 81 e8 00 00 restore
4000adbc: 10 bf ff f0 b 4000ad7c <_Timecounter_Bintime+0x70>
4000adc0: 88 10 20 01 mov 1, %g4
4000b67c <_Timecounter_Binuptime>:
{
4000b67c: 9d e3 bf a0 save %sp, -96, %sp
4000b680: 33 10 00 4d sethi %hi(0x40013400), %i1
4000b684: b2 16 61 e4 or %i1, 0x1e4, %i1 ! 400135e4 <timehands>
th = timehands;
4000b688: fa 06 40 00 ld [ %i1 ], %i5
gen = atomic_load_acq_int(&th->th_generation);
4000b68c: f4 07 60 70 ld [ %i5 + 0x70 ], %i2
*bt = th->th_offset;
4000b690: c4 1f 60 20 ldd [ %i5 + 0x20 ], %g2
4000b694: c4 3e 00 00 std %g2, [ %i0 ]
4000b698: c4 1f 60 28 ldd [ %i5 + 0x28 ], %g2
bintime_addx(bt, th->th_scale * tc_delta(th));
4000b69c: f6 07 40 00 ld [ %i5 ], %i3
*bt = th->th_offset;
4000b6a0: c4 3e 20 08 std %g2, [ %i0 + 8 ]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
4000b6a4: 90 10 00 1b mov %i3, %o0
4000b6a8: c2 06 c0 00 ld [ %i3 ], %g1
bintime_addx(bt, th->th_scale * tc_delta(th));
4000b6ac: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
4000b6b0: 9f c0 40 00 call %g1
4000b6b4: e0 07 60 14 ld [ %i5 + 0x14 ], %l0
4000b6b8: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
4000b6bc: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000b6c0: f6 06 e0 04 ld [ %i3 + 4 ], %i3
4000b6c4: 90 22 00 01 sub %o0, %g1, %o0
4000b6c8: 90 0a 00 1b and %o0, %i3, %o0
bintime_addx(bt, th->th_scale * tc_delta(th));
4000b6cc: b8 5f 00 08 smul %i4, %o0, %i4
4000b6d0: 92 52 00 10 umul %o0, %l0, %o1
4000b6d4: 91 40 00 00 rd %y, %o0
4000b6d8: 90 07 00 08 add %i4, %o0, %o0
4000b6dc: 9a 82 40 03 addcc %o1, %g3, %o5
4000b6e0: 98 c2 00 02 addxcc %o0, %g2, %o4
4000b6e4: 0a 80 00 12 bcs 4000b72c <_Timecounter_Binuptime+0xb0>
4000b6e8: 88 10 20 00 clr %g4
if (_u > _bt->frac)
4000b6ec: 80 a1 20 00 cmp %g4, 0
4000b6f0: 02 80 00 06 be 4000b708 <_Timecounter_Binuptime+0x8c>
4000b6f4: d8 3e 20 08 std %o4, [ %i0 + 8 ]
_bt->sec++;
4000b6f8: c4 1e 00 00 ldd [ %i0 ], %g2
4000b6fc: 9a 80 e0 01 addcc %g3, 1, %o5
4000b700: 98 40 a0 00 addx %g2, 0, %o4
4000b704: d8 3e 00 00 std %o4, [ %i0 ]
} while (gen == 0 || gen != th->th_generation);
4000b708: 80 a6 a0 00 cmp %i2, 0
4000b70c: 02 bf ff df be 4000b688 <_Timecounter_Binuptime+0xc>
<== NEVER TAKEN
4000b710: 01 00 00 00 nop
4000b714: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
4000b718: 80 a0 40 1a cmp %g1, %i2
4000b71c: 12 bf ff db bne 4000b688 <_Timecounter_Binuptime+0xc>
4000b720: 01 00 00 00 nop
}
4000b724: 81 c7 e0 08 ret
4000b728: 81 e8 00 00 restore
4000b72c: 10 bf ff f0 b 4000b6ec <_Timecounter_Binuptime+0x70>
4000b730: 88 10 20 01 mov 1, %g4
4000ae4c <_Timecounter_Getbintime>:
{
4000ae4c: 07 10 00 68 sethi %hi(0x4001a000), %g3
4000ae50: 86 10 e3 74 or %g3, 0x374, %g3 ! 4001a374 <timehands>
th = timehands;
4000ae54: c2 00 c0 00 ld [ %g3 ], %g1
gen = atomic_load_acq_int(&th->th_generation);
4000ae58: c4 00 60 70 ld [ %g1 + 0x70 ], %g2
*bt = th->th_bintime;
4000ae5c: d8 18 60 30 ldd [ %g1 + 0x30 ], %o4
4000ae60: d8 3a 00 00 std %o4, [ %o0 ]
4000ae64: d8 18 60 38 ldd [ %g1 + 0x38 ], %o4
4000ae68: d8 3a 20 08 std %o4, [ %o0 + 8 ]
} while (gen == 0 || gen != th->th_generation);
4000ae6c: 80 a0 a0 00 cmp %g2, 0
4000ae70: 02 bf ff f9 be 4000ae54 <_Timecounter_Getbintime+0x8>
<== NEVER TAKEN
4000ae74: 01 00 00 00 nop
4000ae78: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
4000ae7c: 80 a0 40 02 cmp %g1, %g2
4000ae80: 12 bf ff f5 bne 4000ae54 <_Timecounter_Getbintime+0x8>
4000ae84: 01 00 00 00 nop
}
4000ae88: 81 c3 e0 08 retl
4000ae8c: 01 00 00 00 nop
400068f4 <_Timecounter_Getbinuptime>:
{
400068f4: 07 10 00 36 sethi %hi(0x4000d800), %g3
400068f8: 86 10 e1 5c or %g3, 0x15c, %g3 ! 4000d95c <timehands>
th = timehands;
400068fc: c2 00 c0 00 ld [ %g3 ], %g1
gen = atomic_load_acq_int(&th->th_generation);
40006900: c4 00 60 70 ld [ %g1 + 0x70 ], %g2
*bt = th->th_offset;
40006904: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4
40006908: d8 3a 00 00 std %o4, [ %o0 ]
4000690c: d8 18 60 28 ldd [ %g1 + 0x28 ], %o4
40006910: d8 3a 20 08 std %o4, [ %o0 + 8 ]
} while (gen == 0 || gen != th->th_generation);
40006914: 80 a0 a0 00 cmp %g2, 0
40006918: 02 bf ff f9 be 400068fc <_Timecounter_Getbinuptime+0x8>
<== NEVER TAKEN
4000691c: 01 00 00 00 nop
40006920: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
40006924: 80 a0 40 02 cmp %g1, %g2
40006928: 12 bf ff f5 bne 400068fc <_Timecounter_Getbinuptime+0x8>
<== NEVER TAKEN
4000692c: 01 00 00 00 nop
}
40006930: 81 c3 e0 08 retl
40006934: 01 00 00 00 nop
40006a68 <_Timecounter_Getmicrotime>:
{
40006a68: 07 10 00 36 sethi %hi(0x4000d800), %g3
40006a6c: 86 10 e1 5c or %g3, 0x15c, %g3 ! 4000d95c <timehands>
th = timehands;
40006a70: c2 00 c0 00 ld [ %g3 ], %g1
gen = atomic_load_acq_int(&th->th_generation);
40006a74: c4 00 60 70 ld [ %g1 + 0x70 ], %g2
*tvp = th->th_microtime;
40006a78: d8 18 60 40 ldd [ %g1 + 0x40 ], %o4
40006a7c: d8 3a 00 00 std %o4, [ %o0 ]
40006a80: d8 18 60 48 ldd [ %g1 + 0x48 ], %o4
40006a84: d8 3a 20 08 std %o4, [ %o0 + 8 ]
} while (gen == 0 || gen != th->th_generation);
40006a88: 80 a0 a0 00 cmp %g2, 0
40006a8c: 02 bf ff f9 be 40006a70 <_Timecounter_Getmicrotime+0x8>
<== NEVER TAKEN
40006a90: 01 00 00 00 nop
40006a94: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
40006a98: 80 a0 40 02 cmp %g1, %g2
40006a9c: 12 bf ff f5 bne 40006a70 <_Timecounter_Getmicrotime+0x8>
<== NEVER TAKEN
40006aa0: 01 00 00 00 nop
}
40006aa4: 81 c3 e0 08 retl
40006aa8: 01 00 00 00 nop
4000698c <_Timecounter_Getmicrouptime>:
{
4000698c: 19 10 00 36 sethi %hi(0x4000d800), %o4
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
40006990: 1b 00 03 d0 sethi %hi(0xf4000), %o5
40006994: 98 13 21 5c or %o4, 0x15c, %o4
40006998: 9a 13 62 40 or %o5, 0x240, %o5
th = timehands;
4000699c: c2 03 00 00 ld [ %o4 ], %g1
gen = atomic_load_acq_int(&th->th_generation);
400069a0: c8 00 60 70 ld [ %g1 + 0x70 ], %g4
_tv->tv_sec = _bt->sec;
400069a4: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
400069a8: c4 3a 00 00 std %g2, [ %o0 ]
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
400069ac: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
400069b0: 86 50 80 0d umul %g2, %o5, %g3
400069b4: 85 40 00 00 rd %y, %g2
400069b8: c4 22 20 08 st %g2, [ %o0 + 8 ]
} while (gen == 0 || gen != th->th_generation);
400069bc: 80 a1 20 00 cmp %g4, 0
400069c0: 02 bf ff f7 be 4000699c <_Timecounter_Getmicrouptime+0x10>
<== NEVER TAKEN
400069c4: 01 00 00 00 nop
400069c8: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
400069cc: 80 a0 40 04 cmp %g1, %g4
400069d0: 12 bf ff f3 bne 4000699c <_Timecounter_Getmicrouptime+0x10>
<== NEVER TAKEN
400069d4: 01 00 00 00 nop
}
400069d8: 81 c3 e0 08 retl
400069dc: 01 00 00 00 nop
4000ae90 <_Timecounter_Getnanotime>:
{
4000ae90: 07 10 00 68 sethi %hi(0x4001a000), %g3
4000ae94: 86 10 e3 74 or %g3, 0x374, %g3 ! 4001a374 <timehands>
th = timehands;
4000ae98: c2 00 c0 00 ld [ %g3 ], %g1
gen = atomic_load_acq_int(&th->th_generation);
4000ae9c: c4 00 60 70 ld [ %g1 + 0x70 ], %g2
*tsp = th->th_nanotime;
4000aea0: d8 18 60 50 ldd [ %g1 + 0x50 ], %o4
4000aea4: d8 3a 00 00 std %o4, [ %o0 ]
4000aea8: d8 18 60 58 ldd [ %g1 + 0x58 ], %o4
4000aeac: d8 3a 20 08 std %o4, [ %o0 + 8 ]
} while (gen == 0 || gen != th->th_generation);
4000aeb0: 80 a0 a0 00 cmp %g2, 0
4000aeb4: 02 bf ff f9 be 4000ae98 <_Timecounter_Getnanotime+0x8>
<== NEVER TAKEN
4000aeb8: 01 00 00 00 nop
4000aebc: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
4000aec0: 80 a0 40 02 cmp %g1, %g2
4000aec4: 12 bf ff f5 bne 4000ae98 <_Timecounter_Getnanotime+0x8>
<== NEVER TAKEN
4000aec8: 01 00 00 00 nop
}
4000aecc: 81 c3 e0 08 retl
4000aed0: 01 00 00 00 nop
4000adf8 <_Timecounter_Getnanouptime>:
{
4000adf8: 19 10 00 68 sethi %hi(0x4001a000), %o4
_ts->tv_nsec = ((uint64_t)1000000000 *
4000adfc: 1b 0e e6 b2 sethi %hi(0x3b9ac800), %o5
4000ae00: 98 13 23 74 or %o4, 0x374, %o4
4000ae04: 9a 13 62 00 or %o5, 0x200, %o5
th = timehands;
4000ae08: c2 03 00 00 ld [ %o4 ], %g1
gen = atomic_load_acq_int(&th->th_generation);
4000ae0c: c8 00 60 70 ld [ %g1 + 0x70 ], %g4
_ts->tv_sec = _bt->sec;
4000ae10: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
4000ae14: c4 3a 00 00 std %g2, [ %o0 ]
(uint32_t)(_bt->frac >> 32)) >> 32;
4000ae18: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
_ts->tv_nsec = ((uint64_t)1000000000 *
4000ae1c: 86 50 80 0d umul %g2, %o5, %g3
4000ae20: 85 40 00 00 rd %y, %g2
4000ae24: c4 22 20 08 st %g2, [ %o0 + 8 ]
} while (gen == 0 || gen != th->th_generation);
4000ae28: 80 a1 20 00 cmp %g4, 0
4000ae2c: 02 bf ff f7 be 4000ae08 <_Timecounter_Getnanouptime+0x10>
<== NEVER TAKEN
4000ae30: 01 00 00 00 nop
4000ae34: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
4000ae38: 80 a0 40 04 cmp %g1, %g4
4000ae3c: 12 bf ff f3 bne 4000ae08 <_Timecounter_Getnanouptime+0x10>
<== NEVER TAKEN
4000ae40: 01 00 00 00 nop
}
4000ae44: 81 c3 e0 08 retl
4000ae48: 01 00 00 00 nop
4000aed4 <_Timecounter_Install>:
{
4000aed4: 9d e3 bf 98 save %sp, -104, %sp
if (tc->tc_quality < timecounter->tc_quality)
4000aed8: 03 10 00 68 sethi %hi(0x4001a000), %g1
4000aedc: c4 00 63 70 ld [ %g1 + 0x370 ], %g2 ! 4001a370 <_Timecounter>
4000aee0: c6 00 a0 14 ld [ %g2 + 0x14 ], %g3
4000aee4: c8 06 20 14 ld [ %i0 + 0x14 ], %g4
4000aee8: 80 a1 00 03 cmp %g4, %g3
4000aeec: 06 80 00 16 bl 4000af44 <_Timecounter_Install+0x70>
<== NEVER TAKEN
4000aef0: 01 00 00 00 nop
if (tc->tc_quality == timecounter->tc_quality &&
4000aef4: 32 80 00 0f bne,a 4000af30 <_Timecounter_Install+0x5c>
4000aef8: f0 20 63 70 st %i0, [ %g1 + 0x370 ]
4000aefc: c8 00 a0 08 ld [ %g2 + 8 ], %g4
4000af00: c6 06 20 08 ld [ %i0 + 8 ], %g3
4000af04: 80 a1 00 03 cmp %g4, %g3
4000af08: 18 80 00 0f bgu 4000af44 <_Timecounter_Install+0x70>
<== NEVER TAKEN
4000af0c: 01 00 00 00 nop
4000af10: 32 80 00 08 bne,a 4000af30 <_Timecounter_Install+0x5c>
<== NEVER TAKEN
4000af14: f0 20 63 70 st %i0, [ %g1 + 0x370 ]
<== NOT EXECUTED
4000af18: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
4000af1c: c4 06 20 0c ld [ %i0 + 0xc ], %g2
4000af20: 80 a0 c0 02 cmp %g3, %g2
4000af24: 18 80 00 08 bgu 4000af44 <_Timecounter_Install+0x70>
4000af28: 01 00 00 00 nop
timecounter = tc;
4000af2c: f0 20 63 70 st %i0, [ %g1 + 0x370 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000af30: 91 d0 20 09 ta 9
_Timecounter_Acquire(&lock_context);
4000af34: c2 27 bf fc st %g1, [ %fp + -4 ]
_Timecounter_Windup(new_boottimebin, &lock_context);
4000af38: 90 10 20 00 clr %o0
4000af3c: 7f ff fe aa call 4000a9e4 <_Timecounter_Windup>
4000af40: 92 07 bf fc add %fp, -4, %o1
}
4000af44: 81 c7 e0 08 ret
4000af48: 81 e8 00 00 restore
4000ac78 <_Timecounter_Sbinuptime>:
{
4000ac78: 9d e3 bf a0 save %sp, -96, %sp
4000ac7c: 33 10 00 68 sethi %hi(0x4001a000), %i1
4000ac80: b2 16 63 74 or %i1, 0x374, %i1 ! 4001a374 <timehands>
th = timehands;
4000ac84: fa 06 40 00 ld [ %i1 ], %i5
gen = atomic_load_acq_int(&th->th_generation);
4000ac88: f6 07 60 70 ld [ %i5 + 0x70 ], %i3
sbt += (th->th_scale * tc_delta(th)) >> 32;
4000ac8c: f8 07 40 00 ld [ %i5 ], %i4
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
4000ac90: c2 07 00 00 ld [ %i4 ], %g1
4000ac94: e2 07 60 24 ld [ %i5 + 0x24 ], %l1
4000ac98: e0 07 60 28 ld [ %i5 + 0x28 ], %l0
sbt += (th->th_scale * tc_delta(th)) >> 32;
4000ac9c: f4 07 60 10 ld [ %i5 + 0x10 ], %i2
4000aca0: e4 07 60 14 ld [ %i5 + 0x14 ], %l2
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
4000aca4: 9f c0 40 00 call %g1
4000aca8: 90 10 00 1c mov %i4, %o0
4000acac: c4 07 60 18 ld [ %i5 + 0x18 ], %g2
tc->tc_counter_mask);
4000acb0: c2 07 20 04 ld [ %i4 + 4 ], %g1
} while (gen == 0 || gen != th->th_generation);
4000acb4: 80 a6 e0 00 cmp %i3, 0
4000acb8: 02 bf ff f3 be 4000ac84 <_Timecounter_Sbinuptime+0xc>
<== NEVER TAKEN
4000acbc: 01 00 00 00 nop
4000acc0: c6 07 60 70 ld [ %i5 + 0x70 ], %g3
4000acc4: 80 a0 c0 1b cmp %g3, %i3
4000acc8: 12 bf ff ef bne 4000ac84 <_Timecounter_Sbinuptime+0xc>
<== NEVER TAKEN
4000accc: 84 22 00 02 sub %o0, %g2, %g2
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
4000acd0: 84 08 80 01 and %g2, %g1, %g2
sbt += (th->th_scale * tc_delta(th)) >> 32;
4000acd4: b4 5e 80 02 smul %i2, %g2, %i2
4000acd8: 86 50 80 12 umul %g2, %l2, %g3
4000acdc: 85 40 00 00 rd %y, %g2
return (((sbintime_t)_bt.sec << 32) + (_bt.frac >> 32));
4000ace0: 9a 10 20 00 clr %o5
4000ace4: ba 06 80 02 add %i2, %g2, %i5
4000ace8: b2 83 40 10 addcc %o5, %l0, %i1
4000acec: 84 10 20 00 clr %g2
4000acf0: b0 44 40 02 addx %l1, %g2, %i0
4000acf4: b8 10 20 00 clr %i4
}
4000acf8: 86 87 40 19 addcc %i5, %i1, %g3
4000acfc: 84 47 00 18 addx %i4, %i0, %g2
4000ad00: b2 10 00 03 mov %g3, %i1
4000ad04: 81 c7 e0 08 ret
4000ad08: 91 e8 00 02 restore %g0, %g2, %o0
4000cf98 <_Timecounter_Tick_simple>:
void
_Timecounter_Tick_simple(uint32_t delta, uint32_t offset,
ISR_lock_Context *lock_context)
{
4000cf98: 9d e3 bf a0 save %sp, -96, %sp
struct bintime bt;
struct timehands *th;
uint32_t ogen;
th = timehands;
4000cf9c: 03 10 00 54 sethi %hi(0x40015000), %g1
4000cfa0: c2 00 60 94 ld [ %g1 + 0x94 ], %g1 ! 40015094 <timehands>
ogen = th->th_generation;
th->th_offset_count = offset;
4000cfa4: f2 20 60 18 st %i1, [ %g1 + 0x18 ]
bintime_addx(&th->th_offset, th->th_scale * delta);
4000cfa8: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4000cfac: f8 18 60 28 ldd [ %g1 + 0x28 ], %i4
4000cfb0: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
4000cfb4: 86 58 c0 18 smul %g3, %i0, %g3
ogen = th->th_generation;
4000cfb8: c8 00 60 70 ld [ %g1 + 0x70 ], %g4
bintime_addx(&th->th_offset, th->th_scale * delta);
4000cfbc: b2 50 80 18 umul %g2, %i0, %i1
4000cfc0: b1 40 00 00 rd %y, %i0
4000cfc4: b0 00 c0 18 add %g3, %i0, %i0
4000cfc8: 96 86 40 1d addcc %i1, %i5, %o3
4000cfcc: 94 c6 00 1c addxcc %i0, %i4, %o2
4000cfd0: 0a 80 00 30 bcs 4000d090 <_Timecounter_Tick_simple+0xf8>
<== NEVER TAKEN
4000cfd4: 84 10 20 00 clr %g2
if (_u > _bt->frac)
4000cfd8: 80 a0 a0 00 cmp %g2, 0
4000cfdc: 12 80 00 28 bne 4000d07c <_Timecounter_Tick_simple+0xe4>
<== NEVER TAKEN
4000cfe0: d4 38 60 28 std %o2, [ %g1 + 0x28 ]
4000cfe4: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4
4000cfe8: c4 18 60 68 ldd [ %g1 + 0x68 ], %g2
4000cfec: b2 80 c0 0b addcc %g3, %o3, %i1
4000cff0: b0 c0 80 0a addxcc %g2, %o2, %i0
_bt->sec++;
4000cff4: 0a 80 00 29 bcs 4000d098 <_Timecounter_Tick_simple+0x100>
4000cff8: 96 83 60 01 addcc %o5, 1, %o3
bt = th->th_offset;
4000cffc: 94 10 00 0c mov %o4, %o2
4000d000: 96 10 00 0d mov %o5, %o3
_bt->sec += _bt2->sec;
4000d004: c4 18 60 60 ldd [ %g1 + 0x60 ], %g2
4000d008: ba 82 c0 03 addcc %o3, %g3, %i5
bintime_add(&bt, &th->th_boottime);
/* Update the UTC timestamps used by the get*() functions. */
th->th_bintime = bt;
4000d00c: f0 38 60 38 std %i0, [ %g1 + 0x38 ]
4000d010: b8 42 80 02 addx %o2, %g2, %i4
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
4000d014: 15 00 03 d0 sethi %hi(0xf4000), %o2
_ts->tv_nsec = ((uint64_t)1000000000 *
4000d018: 05 0e e6 b2 sethi %hi(0x3b9ac800), %g2
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
4000d01c: 94 12 a2 40 or %o2, 0x240, %o2
_ts->tv_nsec = ((uint64_t)1000000000 *
4000d020: 84 10 a2 00 or %g2, 0x200, %g2
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
4000d024: 96 56 00 0a umul %i0, %o2, %o3
4000d028: 95 40 00 00 rd %y, %o2
_ts->tv_nsec = ((uint64_t)1000000000 *
4000d02c: 86 56 00 02 umul %i0, %g2, %g3
4000d030: 85 40 00 00 rd %y, %g2
4000d034: f8 38 60 30 std %i4, [ %g1 + 0x30 ]
/*
* Now that the struct timehands is again consistent, set the new
* generation number, making sure to not make it zero.
*/
if (++ogen == 0)
4000d038: 88 81 20 01 inccc %g4
_tv->tv_sec = _bt->sec;
4000d03c: f8 38 60 40 std %i4, [ %g1 + 0x40 ]
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
4000d040: d4 20 60 48 st %o2, [ %g1 + 0x48 ]
_ts->tv_sec = _bt->sec;
4000d044: f8 38 60 50 std %i4, [ %g1 + 0x50 ]
4000d048: 12 80 00 03 bne 4000d054 <_Timecounter_Tick_simple+0xbc>
<== ALWAYS TAKEN
4000d04c: c4 20 60 58 st %g2, [ %g1 + 0x58 ]
ogen = 1;
4000d050: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
th->th_generation = ogen;
/* Go live with the new struct timehands. */
time_second = th->th_microtime.tv_sec;
4000d054: 05 10 00 54 sethi %hi(0x40015000), %g2
4000d058: f8 38 a0 88 std %i4, [ %g2 + 0x88 ] ! 40015088 <_Timecounter_Time_second>
th->th_generation = ogen;
4000d05c: c8 20 60 70 st %g4, [ %g1 + 0x70 ]
time_uptime = th->th_offset.sec;
4000d060: 03 10 00 54 sethi %hi(0x40015000), %g1
4000d064: da 20 60 80 st %o5, [ %g1 + 0x80 ] ! 40015080 <_Timecounter_Time_uptime>
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000d068: c2 06 80 00 ld [ %i2 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000d06c: 91 d0 20 0a ta 0xa
4000d070: 01 00 00 00 nop
_Timecounter_Release(lock_context);
_Watchdog_Tick(_Per_CPU_Get_snapshot());
4000d074: 7f ff f8 d7 call 4000b3d0 <_Watchdog_Tick>
4000d078: 91 e8 00 06 restore %g0, %g6, %o0
_bt->sec++;
4000d07c: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
<== NOT EXECUTED
4000d080: 9a 80 e0 01 addcc %g3, 1, %o5
<== NOT EXECUTED
4000d084: 98 40 a0 00 addx %g2, 0, %o4
<== NOT EXECUTED
4000d088: 10 bf ff d8 b 4000cfe8 <_Timecounter_Tick_simple+0x50>
<== NOT EXECUTED
4000d08c: d8 38 60 20 std %o4, [ %g1 + 0x20 ]
<== NOT EXECUTED
4000d090: 10 bf ff d2 b 4000cfd8 <_Timecounter_Tick_simple+0x40>
<== NOT EXECUTED
4000d094: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
_bt->sec++;
4000d098: 10 bf ff db b 4000d004 <_Timecounter_Tick_simple+0x6c>
4000d09c: 94 43 20 00 addx %o4, 0, %o2
4000e2e4 <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
4000e2e4: 9d e3 bf a0 save %sp, -96, %sp
uint32_t seconds = add->tv_sec;
4000e2e8: f8 1e 40 00 ldd [ %i1 ], %i4
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
4000e2ec: c2 06 60 08 ld [ %i1 + 8 ], %g1
time->tv_sec += add->tv_sec;
4000e2f0: d8 1e 00 00 ldd [ %i0 ], %o4
time->tv_nsec += add->tv_nsec;
4000e2f4: c4 06 20 08 ld [ %i0 + 8 ], %g2
time->tv_sec += add->tv_sec;
4000e2f8: b6 87 40 0d addcc %i5, %o5, %i3
time->tv_nsec += add->tv_nsec;
4000e2fc: 84 00 80 01 add %g2, %g1, %g2
time->tv_sec += add->tv_sec;
4000e300: b4 47 00 0c addx %i4, %o4, %i2
time->tv_nsec += add->tv_nsec;
4000e304: c4 26 20 08 st %g2, [ %i0 + 8 ]
uint32_t seconds = add->tv_sec;
4000e308: 88 10 00 1d mov %i5, %g4
time->tv_sec += add->tv_sec;
4000e30c: f4 3e 00 00 std %i2, [ %i0 ]
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
4000e310: 3b 0e e6 b2 sethi %hi(0x3b9ac800), %i5
4000e314: ba 17 61 ff or %i5, 0x1ff, %i5 ! 3b9ac9ff <RAM_SIZE+0x3b5ac9ff>
4000e318: 80 a0 80 1d cmp %g2, %i5
4000e31c: 08 80 00 10 bleu 4000e35c <_Timespec_Add_to+0x78>
4000e320: 82 10 00 02 mov %g2, %g1
4000e324: 86 86 e0 01 addcc %i3, 1, %g3
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
4000e328: 39 31 19 4d sethi %hi(0xc4653400), %i4
4000e32c: 84 46 a0 00 addx %i2, 0, %g2
4000e330: b8 17 22 00 or %i4, 0x200, %i4
time->tv_sec++;
4000e334: b6 10 00 03 mov %g3, %i3
4000e338: 86 80 e0 01 inccc %g3
4000e33c: b4 10 00 02 mov %g2, %i2
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
4000e340: 82 00 40 1c add %g1, %i4, %g1
4000e344: 84 40 a0 00 addx %g2, 0, %g2
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
4000e348: 80 a0 40 1d cmp %g1, %i5
4000e34c: 18 bf ff fa bgu 4000e334 <_Timespec_Add_to+0x50>
<== NEVER TAKEN
4000e350: 88 01 20 01 inc %g4
4000e354: c2 26 20 08 st %g1, [ %i0 + 8 ]
4000e358: f4 3e 00 00 std %i2, [ %i0 ]
seconds++;
}
return seconds;
}
4000e35c: 81 c7 e0 08 ret
4000e360: 91 e8 00 04 restore %g0, %g4, %o0
400102a8 <_Timespec_Less_than>:
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
400102a8: c4 02 00 00 ld [ %o0 ], %g2
400102ac: c2 02 40 00 ld [ %o1 ], %g1
400102b0: c8 02 20 04 ld [ %o0 + 4 ], %g4
400102b4: 80 a0 40 02 cmp %g1, %g2
400102b8: 14 80 00 13 bg 40010304 <_Timespec_Less_than+0x5c>
<== NEVER TAKEN
400102bc: c6 02 60 04 ld [ %o1 + 4 ], %g3
400102c0: 02 80 00 0f be 400102fc <_Timespec_Less_than+0x54>
<== ALWAYS TAKEN
400102c4: 80 a0 c0 04 cmp %g3, %g4
return true;
if ( lhs->tv_sec > rhs->tv_sec )
400102c8: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
400102cc: 34 80 00 0a bg,a 400102f4 <_Timespec_Less_than+0x4c>
<== NEVER TAKEN
400102d0: 90 10 20 00 clr %o0
<== NOT EXECUTED
400102d4: 02 80 00 0f be 40010310 <_Timespec_Less_than+0x68>
<== ALWAYS TAKEN
400102d8: 80 a1 00 03 cmp %g4, %g3
return false;
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
400102dc: c4 02 20 08 ld [ %o0 + 8 ], %g2
<== NOT EXECUTED
400102e0: c2 02 60 08 ld [ %o1 + 8 ], %g1
400102e4: 80 a0 80 01 cmp %g2, %g1
400102e8: 06 80 00 03 bl 400102f4 <_Timespec_Less_than+0x4c>
400102ec: 90 10 20 01 mov 1, %o0
return false;
400102f0: 90 10 20 00 clr %o0
return true;
return false;
}
400102f4: 81 c3 e0 08 retl
400102f8: 90 0a 20 01 and %o0, 1, %o0
if ( lhs->tv_sec < rhs->tv_sec )
400102fc: 08 bf ff f4 bleu 400102cc <_Timespec_Less_than+0x24>
40010300: 80 a0 80 01 cmp %g2, %g1
return true;
40010304: 90 10 20 01 mov 1, %o0
}
40010308: 81 c3 e0 08 retl
4001030c: 90 0a 20 01 and %o0, 1, %o0
if ( lhs->tv_sec > rhs->tv_sec )
40010310: 28 bf ff f4 bleu,a 400102e0 <_Timespec_Less_than+0x38>
40010314: c4 02 20 08 ld [ %o0 + 8 ], %g2
return false;
40010318: 10 bf ff f7 b 400102f4 <_Timespec_Less_than+0x4c>
4001031c: 90 10 20 00 clr %o0
400094dc <_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;
400094dc: 03 10 00 5a sethi %hi(0x40016800), %g1
400094e0: c4 00 63 c0 ld [ %g1 + 0x3c0 ], %g2 ! 40016bc0 <_User_extensions_Initial_count>
for ( i = 0 ; i < n ; ++i ) {
400094e4: 80 a0 a0 00 cmp %g2, 0
400094e8: 02 80 00 1a be 40009550 <_User_extensions_Handler_initialization+0x74>
<== NEVER TAKEN
400094ec: 89 28 a0 01 sll %g2, 1, %g4
400094f0: 03 10 00 70 sethi %hi(0x4001c000), %g1
400094f4: 88 01 00 02 add %g4, %g2, %g4
400094f8: 82 10 60 78 or %g1, 0x78, %g1
400094fc: 89 29 20 02 sll %g4, 2, %g4
old_last = tail->previous;
40009500: 1b 10 00 68 sethi %hi(0x4001a000), %o5
40009504: 05 10 00 5a sethi %hi(0x40016800), %g2
40009508: 9a 13 63 0c or %o5, 0x30c, %o5
4000950c: 84 10 a3 d4 or %g2, 0x3d4, %g2
40009510: 88 01 00 01 add %g4, %g1, %g4
the_node->next = tail;
40009514: 98 03 60 04 add %o5, 4, %o4
User_extensions_thread_switch_extension callout;
callout = initial_table[ i ].thread_switch;
40009518: c6 00 80 00 ld [ %g2 ], %g3
if ( callout != NULL ) {
4000951c: 80 a0 e0 00 cmp %g3, 0
40009520: 22 80 00 09 be,a 40009544 <_User_extensions_Handler_initialization+0x68>
40009524: 82 00 60 0c add %g1, 0xc, %g1
User_extensions_Switch_control *c;
c = &initial_switch_controls[ i ];
c->thread_switch = callout;
40009528: c6 20 60 08 st %g3, [ %g1 + 8 ]
4000952c: d8 20 40 00 st %o4, [ %g1 ]
old_last = tail->previous;
40009530: c6 03 60 08 ld [ %o5 + 8 ], %g3
tail->previous = the_node;
40009534: c2 23 60 08 st %g1, [ %o5 + 8 ]
old_last->next = the_node;
40009538: c2 20 c0 00 st %g1, [ %g3 ]
the_node->previous = old_last;
4000953c: c6 20 60 04 st %g3, [ %g1 + 4 ]
40009540: 82 00 60 0c add %g1, 0xc, %g1
for ( i = 0 ; i < n ; ++i ) {
40009544: 80 a0 40 04 cmp %g1, %g4
40009548: 12 bf ff f4 bne 40009518 <_User_extensions_Handler_initialization+0x3c>
4000954c: 84 00 a0 24 add %g2, 0x24, %g2
_Chain_Initialize_node( &c->Node );
_Chain_Append_unprotected( &_User_extensions_Switches_list, &c->Node );
}
}
}
40009550: 81 c3 e0 08 retl
40009554: 01 00 00 00 nop
40009698 <_User_extensions_Iterate>:
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor,
Chain_Iterator_direction direction
)
{
40009698: 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;
4000969c: 03 10 00 5a sethi %hi(0x40016800), %g1
400096a0: c2 00 63 c0 ld [ %g1 + 0x3c0 ], %g1 ! 40016bc0 <_User_extensions_Initial_count>
400096a4: b9 28 60 03 sll %g1, 3, %i4
400096a8: 21 10 00 5a sethi %hi(0x40016800), %l0
400096ac: b8 07 00 01 add %i4, %g1, %i4
400096b0: a0 14 23 c4 or %l0, 0x3c4, %l0
400096b4: b9 2f 20 02 sll %i4, 2, %i4
ISR_Level level;
_ISR_Local_disable( level );
#endif
executing = _Thread_Executing;
400096b8: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
if ( direction == CHAIN_ITERATOR_FORWARD ) {
400096bc: 80 a6 a0 00 cmp %i2, 0
400096c0: 12 80 00 47 bne 400097dc <_User_extensions_Iterate+0x144>
400096c4: b8 04 00 1c add %l0, %i4, %i4
initial_current = initial_begin;
while ( initial_current != initial_end ) {
400096c8: 80 a7 00 10 cmp %i4, %l0
400096cc: 02 80 00 0a be 400096f4 <_User_extensions_Iterate+0x5c>
<== NEVER TAKEN
400096d0: b6 10 00 10 mov %l0, %i3
(*visitor)( executing, arg, initial_current );
400096d4: 94 10 00 1b mov %i3, %o2
400096d8: 92 10 00 18 mov %i0, %o1
400096dc: 9f c6 40 00 call %i1
400096e0: 90 10 00 1d mov %i5, %o0
++initial_current;
400096e4: b6 06 e0 24 add %i3, 0x24, %i3
while ( initial_current != initial_end ) {
400096e8: 80 a7 00 1b cmp %i4, %i3
400096ec: 12 bf ff fb bne 400096d8 <_User_extensions_Iterate+0x40>
400096f0: 94 10 00 1b mov %i3, %o2
}
end = _Chain_Immutable_tail( &_User_extensions_List.Active );
400096f4: 37 10 00 68 sethi %hi(0x4001a000), %i3
400096f8: b6 16 e3 28 or %i3, 0x328, %i3 ! 4001a328 <_User_extensions_List+0x4>
400096fc: 84 06 ff fc add %i3, -4, %g2
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40009700: 91 d0 20 09 ta 9
old_last = tail->previous;
40009704: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
tail->previous = the_node;
40009708: 86 07 bf ec add %fp, -20, %g3
the_node->next = tail;
4000970c: 9e 00 a0 10 add %g2, 0x10, %o7
tail->previous = the_node;
40009710: c6 20 a0 14 st %g3, [ %g2 + 0x14 ]
&the_iterator->Registry_node
);
the_iterator->direction = direction;
if ( direction == CHAIN_ITERATOR_FORWARD ) {
40009714: 80 a6 a0 00 cmp %i2, 0
the_node->next = tail;
40009718: de 27 bf ec st %o7, [ %fp + -20 ]
old_last->next = the_node;
4000971c: c6 21 00 00 st %g3, [ %g4 ]
the_node->previous = old_last;
40009720: c8 27 bf f0 st %g4, [ %fp + -16 ]
if ( direction == CHAIN_ITERATOR_FORWARD ) {
40009724: 02 80 00 03 be 40009730 <_User_extensions_Iterate+0x98>
40009728: f4 27 bf f4 st %i2, [ %fp + -12 ]
the_iterator->position = _Chain_Head( the_chain );
} else {
the_iterator->position = _Chain_Tail( the_chain );
4000972c: 84 00 a0 04 add %g2, 4, %g2
&_User_extensions_List.Iterators,
&iter.Iterator,
direction
);
if ( executing != NULL ) {
40009730: 80 a7 60 00 cmp %i5, 0
40009734: 02 80 00 05 be 40009748 <_User_extensions_Iterate+0xb0>
40009738: c4 27 bf f8 st %g2, [ %fp + -8 ]
iter.previous = executing->last_user_extensions_iterator;
4000973c: c4 07 61 8c ld [ %i5 + 0x18c ], %g2
40009740: c4 27 bf fc st %g2, [ %fp + -4 ]
executing->last_user_extensions_iterator = &iter;
40009744: c6 27 61 8c st %g3, [ %i5 + 0x18c ]
end = _Chain_Immutable_head( &_User_extensions_List.Active );
40009748: 10 80 00 0f b 40009784 <_User_extensions_Iterate+0xec>
4000974c: 84 10 00 1a mov %i2, %g2
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Iterator_next(
const Chain_Iterator *the_iterator
)
{
if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) {
return _Chain_Next( the_iterator->position );
40009750: d4 00 c0 00 ld [ %g3 ], %o2
}
while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) {
40009754: 80 a6 c0 0a cmp %i3, %o2
40009758: 02 80 00 13 be 400097a4 <_User_extensions_Iterate+0x10c>
4000975c: 80 a7 60 00 cmp %i5, 0
RTEMS_INLINE_ROUTINE void _Chain_Iterator_set_position(
Chain_Iterator *the_iterator,
Chain_Node *the_node
)
{
the_iterator->position = the_node;
40009760: d4 27 bf f8 st %o2, [ %fp + -8 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009764: 91 d0 20 0a ta 0xa
40009768: 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 );
4000976c: 94 02 a0 14 add %o2, 0x14, %o2
40009770: 92 10 00 18 mov %i0, %o1
40009774: 9f c6 40 00 call %i1
40009778: 90 10 00 1d mov %i5, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000977c: 91 d0 20 09 ta 9
_ISR_lock_ISR_disable_and_acquire(
40009780: c4 07 bf f4 ld [ %fp + -12 ], %g2
if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) {
40009784: 80 a0 a0 00 cmp %g2, 0
40009788: 02 bf ff f2 be 40009750 <_User_extensions_Iterate+0xb8>
4000978c: c6 07 bf f8 ld [ %fp + -8 ], %g3
return _Chain_Previous( the_iterator->position );
40009790: d4 00 e0 04 ld [ %g3 + 4 ], %o2
while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) {
40009794: 80 a6 c0 0a cmp %i3, %o2
40009798: 32 bf ff f3 bne,a 40009764 <_User_extensions_Iterate+0xcc>
4000979c: d4 27 bf f8 st %o2, [ %fp + -8 ]
_User_extensions_Acquire( &lock_context );
}
if ( executing != NULL ) {
400097a0: 80 a7 60 00 cmp %i5, 0
400097a4: 02 80 00 03 be 400097b0 <_User_extensions_Iterate+0x118>
400097a8: c4 07 bf fc ld [ %fp + -4 ], %g2
executing->last_user_extensions_iterator = iter.previous;
400097ac: c4 27 61 8c st %g2, [ %i5 + 0x18c ]
next = the_node->next;
400097b0: c6 07 bf ec ld [ %fp + -20 ], %g3
previous = the_node->previous;
400097b4: c4 07 bf f0 ld [ %fp + -16 ], %g2
next->previous = previous;
400097b8: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
400097bc: c6 20 80 00 st %g3, [ %g2 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400097c0: 91 d0 20 0a ta 0xa
400097c4: 01 00 00 00 nop
_Chain_Iterator_destroy( &iter.Iterator );
_User_extensions_Release( &lock_context );
if ( direction == CHAIN_ITERATOR_BACKWARD ) {
400097c8: 80 a6 a0 01 cmp %i2, 1
400097cc: 02 80 00 08 be 400097ec <_User_extensions_Iterate+0x154>
400097d0: 80 a7 00 10 cmp %i4, %l0
while ( initial_current != initial_begin ) {
--initial_current;
(*visitor)( executing, arg, initial_current );
}
}
}
400097d4: 81 c7 e0 08 ret
400097d8: 81 e8 00 00 restore
end = _Chain_Immutable_head( &_User_extensions_List.Active );
400097dc: 05 10 00 68 sethi %hi(0x4001a000), %g2
400097e0: 84 10 a3 24 or %g2, 0x324, %g2 ! 4001a324 <_User_extensions_List>
400097e4: 10 bf ff c7 b 40009700 <_User_extensions_Iterate+0x68>
400097e8: b6 10 00 02 mov %g2, %i3
while ( initial_current != initial_begin ) {
400097ec: 02 bf ff fa be 400097d4 <_User_extensions_Iterate+0x13c>
<== NEVER TAKEN
400097f0: 05 0e 38 e3 sethi %hi(0x38e38c00), %g2
400097f4: 84 10 a2 39 or %g2, 0x239, %g2 ! 38e38e39 <RAM_SIZE+0x38a38e39>
400097f8: b6 07 3f dc add %i4, -36, %i3
400097fc: 82 26 c0 10 sub %i3, %l0, %g1
40009800: 83 30 60 02 srl %g1, 2, %g1
40009804: 82 58 40 02 smul %g1, %g2, %g1
40009808: 05 30 00 00 sethi %hi(0xc0000000), %g2
4000980c: 82 28 40 02 andn %g1, %g2, %g1
40009810: 82 00 60 01 inc %g1
40009814: 85 28 60 03 sll %g1, 3, %g2
40009818: 82 00 80 01 add %g2, %g1, %g1
4000981c: 83 28 60 02 sll %g1, 2, %g1
40009820: b8 27 00 01 sub %i4, %g1, %i4
(*visitor)( executing, arg, initial_current );
40009824: 94 10 00 1b mov %i3, %o2
40009828: 92 10 00 18 mov %i0, %o1
4000982c: 9f c6 40 00 call %i1
40009830: 90 10 00 1d mov %i5, %o0
while ( initial_current != initial_begin ) {
40009834: 80 a6 c0 1c cmp %i3, %i4
40009838: 12 bf ff fb bne 40009824 <_User_extensions_Iterate+0x18c>
4000983c: b6 06 ff dc add %i3, -36, %i3
}
40009840: 81 c7 e0 08 ret
40009844: 81 e8 00 00 restore
4000da64 <_User_extensions_Remove_set>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000da64: 91 d0 20 09 ta 9
iter_node = _Chain_Head( &the_registry->Iterators );
4000da68: 05 10 00 54 sethi %hi(0x40015000), %g2
4000da6c: 84 10 a1 c0 or %g2, 0x1c0, %g2 ! 400151c0 <_User_extensions_List+0xc>
4000da70: 88 00 a0 04 add %g2, 4, %g4
while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
4000da74: c4 00 80 00 ld [ %g2 ], %g2
4000da78: 80 a0 80 04 cmp %g2, %g4
4000da7c: 22 80 00 11 be,a 4000dac0 <_User_extensions_Remove_set+0x5c>
<== ALWAYS TAKEN
4000da80: c6 02 00 00 ld [ %o0 ], %g3
if ( iter->position == the_node_to_extract ) {
4000da84: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
<== NOT EXECUTED
4000da88: 80 a2 00 03 cmp %o0, %g3
<== NOT EXECUTED
4000da8c: 32 bf ff fb bne,a 4000da78 <_User_extensions_Remove_set+0x14>
<== NOT EXECUTED
4000da90: c4 00 80 00 ld [ %g2 ], %g2
<== NOT EXECUTED
if ( iter->direction == CHAIN_ITERATOR_FORWARD ) {
4000da94: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
4000da98: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
4000da9c: 32 80 00 1b bne,a 4000db08 <_User_extensions_Remove_set+0xa4>
<== NOT EXECUTED
4000daa0: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
iter->position = _Chain_Previous( the_node_to_extract );
4000daa4: c6 02 20 04 ld [ %o0 + 4 ], %g3
<== NOT EXECUTED
4000daa8: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
<== NOT EXECUTED
while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
4000daac: c4 00 80 00 ld [ %g2 ], %g2
<== NOT EXECUTED
4000dab0: 80 a0 80 04 cmp %g2, %g4
<== NOT EXECUTED
4000dab4: 32 bf ff f5 bne,a 4000da88 <_User_extensions_Remove_set+0x24>
<== NOT EXECUTED
4000dab8: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
<== NOT EXECUTED
next = the_node->next;
4000dabc: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
previous = the_node->previous;
4000dac0: c4 02 20 04 ld [ %o0 + 4 ], %g2
next->previous = previous;
4000dac4: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
4000dac8: c6 20 80 00 st %g3, [ %g2 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000dacc: 91 d0 20 0a ta 0xa
4000dad0: 01 00 00 00 nop
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL ) {
4000dad4: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
4000dad8: 80 a0 60 00 cmp %g1, 0
4000dadc: 02 80 00 09 be 4000db00 <_User_extensions_Remove_set+0x9c>
4000dae0: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000dae4: 91 d0 20 09 ta 9
next = the_node->next;
4000dae8: c6 02 20 08 ld [ %o0 + 8 ], %g3
previous = the_node->previous;
4000daec: c4 02 20 0c ld [ %o0 + 0xc ], %g2
next->previous = previous;
4000daf0: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
4000daf4: c6 20 80 00 st %g3, [ %g2 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000daf8: 91 d0 20 0a ta 0xa
4000dafc: 01 00 00 00 nop
_Per_CPU_Acquire_all( &lock_context );
_Chain_Extract_unprotected( &the_extension->Switch.Node );
_Per_CPU_Release_all( &lock_context );
}
}
4000db00: 81 c3 e0 08 retl
4000db04: 01 00 00 00 nop
iter->position = _Chain_Next( the_node_to_extract );
4000db08: 10 bf ff db b 4000da74 <_User_extensions_Remove_set+0x10>
<== NOT EXECUTED
4000db0c: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
<== NOT EXECUTED
40009558 <_User_extensions_Thread_create_visitor>:
void _User_extensions_Thread_create_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
40009558: 9d e3 bf a0 save %sp, -96, %sp
User_extensions_thread_create_extension callout = callouts->thread_create;
4000955c: c4 06 80 00 ld [ %i2 ], %g2
if ( callout != NULL ) {
40009560: 80 a0 a0 00 cmp %g2, 0
40009564: 02 80 00 0a be 4000958c <_User_extensions_Thread_create_visitor+0x34>
40009568: 01 00 00 00 nop
User_extensions_Thread_create_context *ctx = arg;
ctx->ok = ctx->ok && (*callout)( executing, ctx->created );
4000956c: d0 0e 60 04 ldub [ %i1 + 4 ], %o0
40009570: 80 8a 20 ff btst 0xff, %o0
40009574: 22 80 00 06 be,a 4000958c <_User_extensions_Thread_create_visitor+0x34>
<== NEVER TAKEN
40009578: d0 2e 60 04 stb %o0, [ %i1 + 4 ]
<== NOT EXECUTED
4000957c: d2 06 40 00 ld [ %i1 ], %o1
40009580: 9f c0 80 00 call %g2
40009584: 90 10 00 18 mov %i0, %o0
40009588: d0 2e 60 04 stb %o0, [ %i1 + 4 ]
}
}
4000958c: 81 c7 e0 08 ret
40009590: 81 e8 00 00 restore
4000d7ac <_Watchdog_Do_tickle>:
#ifdef RTEMS_SMP
ISR_lock_Control *lock,
#endif
ISR_lock_Context *lock_context
)
{
4000d7ac: 9d e3 bf a0 save %sp, -96, %sp
4000d7b0: ba 10 20 02 mov 2, %i5
do {
if ( first->expire <= now ) {
4000d7b4: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
4000d7b8: 80 a0 40 1a cmp %g1, %i2
4000d7bc: 18 80 00 26 bgu 4000d854 <_Watchdog_Do_tickle+0xa8>
4000d7c0: 01 00 00 00 nop
4000d7c4: 22 80 00 21 be,a 4000d848 <_Watchdog_Do_tickle+0x9c>
4000d7c8: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
RBTree_Node *node = _RBTree_Right( &the_watchdog->Node.RBTree );
4000d7cc: c4 06 60 04 ld [ %i1 + 4 ], %g2
if ( node != NULL ) {
4000d7d0: 80 a0 a0 00 cmp %g2, 0
4000d7d4: 32 80 00 05 bne,a 4000d7e8 <_Watchdog_Do_tickle+0x3c>
4000d7d8: c2 00 80 00 ld [ %g2 ], %g1
header->first = _RBTree_Parent( &the_watchdog->Node.RBTree );
4000d7dc: 10 80 00 19 b 4000d840 <_Watchdog_Do_tickle+0x94>
4000d7e0: c2 06 60 08 ld [ %i1 + 8 ], %g1
while ( ( left = _RBTree_Left( node ) ) != NULL ) {
4000d7e4: c2 00 80 00 ld [ %g2 ], %g1
<== NOT EXECUTED
4000d7e8: 80 a0 60 00 cmp %g1, 0
4000d7ec: 32 bf ff fe bne,a 4000d7e4 <_Watchdog_Do_tickle+0x38>
<== NEVER TAKEN
4000d7f0: 84 10 00 01 mov %g1, %g2
<== NOT EXECUTED
header->first = node;
4000d7f4: 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 );
4000d7f8: 92 10 00 19 mov %i1, %o1
4000d7fc: 7f ff fb ca call 4000c724 <_RBTree_Extract>
4000d800: 90 10 00 18 mov %i0, %o0
_Watchdog_Set_state( first, WATCHDOG_INACTIVE );
routine = first->routine;
4000d804: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
4000d808: fa 26 60 0c st %i5, [ %i1 + 0xc ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000d80c: c2 07 00 00 ld [ %i4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000d810: 91 d0 20 0a ta 0xa
4000d814: 01 00 00 00 nop
_ISR_lock_Release_and_ISR_enable( lock, lock_context );
( *routine )( first );
4000d818: 9f c0 80 00 call %g2
4000d81c: 90 10 00 19 mov %i1, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000d820: 91 d0 20 09 ta 9
_ISR_lock_ISR_disable_and_acquire( lock, lock_context );
4000d824: c2 27 00 00 st %g1, [ %i4 ]
} else {
break;
}
first = _Watchdog_Header_first( header );
4000d828: f2 06 20 04 ld [ %i0 + 4 ], %i1
} while ( first != NULL );
4000d82c: 80 a6 60 00 cmp %i1, 0
4000d830: 32 bf ff e2 bne,a 4000d7b8 <_Watchdog_Do_tickle+0xc>
4000d834: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
}
4000d838: 81 c7 e0 08 ret
4000d83c: 81 e8 00 00 restore
header->first = _RBTree_Parent( &the_watchdog->Node.RBTree );
4000d840: 10 bf ff ee b 4000d7f8 <_Watchdog_Do_tickle+0x4c>
4000d844: c2 26 20 04 st %g1, [ %i0 + 4 ]
if ( first->expire <= now ) {
4000d848: 80 a0 40 1b cmp %g1, %i3
4000d84c: 28 bf ff e1 bleu,a 4000d7d0 <_Watchdog_Do_tickle+0x24>
4000d850: c4 06 60 04 ld [ %i1 + 4 ], %g2
}
4000d854: 81 c7 e0 08 ret
4000d858: 81 e8 00 00 restore
40009464 <_Watchdog_Remove>:
void _Watchdog_Remove(
Watchdog_Header *header,
Watchdog_Control *the_watchdog
)
{
40009464: 9d e3 bf a0 save %sp, -96, %sp
if ( _Watchdog_Is_scheduled( the_watchdog ) ) {
40009468: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000946c: 80 a0 60 01 cmp %g1, 1
40009470: 28 80 00 04 bleu,a 40009480 <_Watchdog_Remove+0x1c>
40009474: c2 06 20 04 ld [ %i0 + 4 ], %g1
}
_RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree );
_Watchdog_Set_state( the_watchdog, WATCHDOG_INACTIVE );
}
}
40009478: 81 c7 e0 08 ret
4000947c: 81 e8 00 00 restore
if ( header->first == &the_watchdog->Node.RBTree ) {
40009480: 80 a0 40 19 cmp %g1, %i1
40009484: 22 80 00 09 be,a 400094a8 <_Watchdog_Remove+0x44>
40009488: c4 06 60 04 ld [ %i1 + 4 ], %g2
_RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree );
4000948c: 92 10 00 19 mov %i1, %o1
40009490: 40 00 0c a5 call 4000c724 <_RBTree_Extract>
40009494: 90 10 00 18 mov %i0, %o0
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
40009498: 82 10 20 02 mov 2, %g1
4000949c: c2 26 60 0c st %g1, [ %i1 + 0xc ]
}
400094a0: 81 c7 e0 08 ret
400094a4: 81 e8 00 00 restore
if ( node != NULL ) {
400094a8: 80 a0 a0 00 cmp %g2, 0
400094ac: 32 80 00 05 bne,a 400094c0 <_Watchdog_Remove+0x5c>
400094b0: c2 00 80 00 ld [ %g2 ], %g1
header->first = _RBTree_Parent( &the_watchdog->Node.RBTree );
400094b4: 10 80 00 08 b 400094d4 <_Watchdog_Remove+0x70>
400094b8: c2 06 60 08 ld [ %i1 + 8 ], %g1
while ( ( left = _RBTree_Left( node ) ) != NULL ) {
400094bc: c2 00 80 00 ld [ %g2 ], %g1
<== NOT EXECUTED
400094c0: 80 a0 60 00 cmp %g1, 0
400094c4: 32 bf ff fe bne,a 400094bc <_Watchdog_Remove+0x58>
<== NEVER TAKEN
400094c8: 84 10 00 01 mov %g1, %g2
<== NOT EXECUTED
header->first = node;
400094cc: 10 bf ff f0 b 4000948c <_Watchdog_Remove+0x28>
400094d0: c4 26 20 04 st %g2, [ %i0 + 4 ]
header->first = _RBTree_Parent( &the_watchdog->Node.RBTree );
400094d4: 10 bf ff ee b 4000948c <_Watchdog_Remove+0x28>
400094d8: c2 26 20 04 st %g1, [ %i0 + 4 ]
400098f8 <_Workspace_Handler_initialization>:
void _Workspace_Handler_initialization(
const Memory_Information *mem,
Heap_Initialization_or_extend_handler extend
)
{
400098f8: 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();
400098fc: 03 10 00 5d sethi %hi(0x40017400), %g1
40009900: c2 08 63 40 ldub [ %g1 + 0x340 ], %g1 ! 40017740 <_Stack_Allocator_avoids_workspace>
40009904: 80 a0 60 00 cmp %g1, 0
40009908: 02 80 00 41 be 40009a0c <_Workspace_Handler_initialization+0x114>
4000990c: 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 ) {
40009910: c2 06 00 00 ld [ %i0 ], %g1
remaining = rtems_configuration_get_work_space_size();
40009914: 05 10 00 5a sethi %hi(0x40016800), %g2
40009918: e0 00 a2 7c ld [ %g2 + 0x27c ], %l0 ! 40016a7c <_Workspace_Size>
unified = rtems_configuration_get_unified_work_area();
4000991c: 07 10 00 5d sethi %hi(0x40017400), %g3
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
40009920: 80 a0 60 00 cmp %g1, 0
40009924: 02 80 00 2b be 400099d0 <_Workspace_Handler_initialization+0xd8>
40009928: a0 02 00 10 add %o0, %l0, %l0
if ( free_size > overhead ) {
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
4000992c: e4 08 e2 80 ldub [ %g3 + 0x280 ], %l2
init_or_extend = _Heap_Initialize;
40009930: 05 10 00 1a sethi %hi(0x40006800), %g2
<== NOT EXECUTED
} else {
size = 0;
}
}
space_available = ( *init_or_extend )(
40009934: 23 10 00 7a sethi %hi(0x4001e800), %l1
<== NOT EXECUTED
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
40009938: b4 10 20 00 clr %i2
<== NOT EXECUTED
4000993c: b6 10 20 00 clr %i3
<== NOT EXECUTED
init_or_extend = _Heap_Initialize;
40009940: 84 10 a2 10 or %g2, 0x210, %g2
<== NOT EXECUTED
space_available = ( *init_or_extend )(
40009944: a2 14 63 a8 or %l1, 0x3a8, %l1
<== NOT EXECUTED
return &information->areas[ index ];
40009948: fa 06 20 04 ld [ %i0 + 4 ], %i5
<== NOT EXECUTED
4000994c: ba 07 40 1a add %i5, %i2, %i5
<== NOT EXECUTED
free_size = _Memory_Get_free_size( area );
40009950: d2 07 60 04 ld [ %i5 + 4 ], %o1
<== NOT EXECUTED
return (uintptr_t) area->end - (uintptr_t) area->free;
40009954: f8 07 60 08 ld [ %i5 + 8 ], %i4
<== NOT EXECUTED
40009958: b8 27 00 09 sub %i4, %o1, %i4
<== NOT EXECUTED
if ( free_size > overhead ) {
4000995c: 80 a7 20 16 cmp %i4, 0x16
<== NOT EXECUTED
40009960: 28 80 00 19 bleu,a 400099c4 <_Workspace_Handler_initialization+0xcc>
<== NOT EXECUTED
40009964: b6 06 e0 01 inc %i3
<== NOT EXECUTED
if ( unified ) {
40009968: 80 a4 a0 00 cmp %l2, 0
<== NOT EXECUTED
4000996c: 12 80 00 0a bne 40009994 <_Workspace_Handler_initialization+0x9c>
<== NOT EXECUTED
40009970: 94 10 00 1c mov %i4, %o2
if ( remaining > 0 ) {
40009974: 80 a4 20 00 cmp %l0, 0
40009978: 02 80 00 1b be 400099e4 <_Workspace_Handler_initialization+0xec>
4000997c: 96 10 20 08 mov 8, %o3
size = remaining < free_size - overhead ?
40009980: 82 07 3f ea add %i4, -22, %g1
remaining + overhead : free_size;
40009984: 80 a0 40 10 cmp %g1, %l0
40009988: 38 80 00 02 bgu,a 40009990 <_Workspace_Handler_initialization+0x98>
4000998c: b8 04 20 16 add %l0, 0x16, %i4
space_available = ( *init_or_extend )(
40009990: 94 10 00 1c mov %i4, %o2
40009994: 96 10 20 08 mov 8, %o3
40009998: 9f c0 80 00 call %g2
4000999c: 90 10 00 11 mov %l1, %o0
area->free = (char *) area->free + consume;
400099a0: c2 07 60 04 ld [ %i5 + 4 ], %g1
400099a4: b8 00 40 1c add %g1, %i4, %i4
page_size
);
_Memory_Consume( area, size );
if ( space_available < remaining ) {
400099a8: 80 a2 00 10 cmp %o0, %l0
400099ac: 1a 80 00 14 bcc 400099fc <_Workspace_Handler_initialization+0x104>
<== NEVER TAKEN
400099b0: f8 27 60 04 st %i4, [ %i5 + 4 ]
400099b4: c2 06 00 00 ld [ %i0 ], %g1
remaining -= space_available;
400099b8: a0 24 00 08 sub %l0, %o0, %l0
} else {
remaining = 0;
}
init_or_extend = extend;
400099bc: 84 10 00 19 mov %i1, %g2
<== NOT EXECUTED
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
400099c0: b6 06 e0 01 inc %i3
400099c4: 80 a6 c0 01 cmp %i3, %g1
400099c8: 0a bf ff e0 bcs 40009948 <_Workspace_Handler_initialization+0x50>
400099cc: b4 06 a0 0c add %i2, 0xc, %i2
}
}
if ( remaining > 0 ) {
400099d0: 80 a4 20 00 cmp %l0, 0
400099d4: 12 80 00 12 bne 40009a1c <_Workspace_Handler_initialization+0x124>
400099d8: 01 00 00 00 nop
_Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE );
}
_Heap_Protection_set_delayed_free_fraction( &_Workspace_Area, 1 );
}
400099dc: 81 c7 e0 08 ret
400099e0: 81 e8 00 00 restore
space_available = ( *init_or_extend )(
400099e4: 94 10 20 00 clr %o2
400099e8: 9f c0 80 00 call %g2
400099ec: 90 10 00 11 mov %l1, %o0
init_or_extend = extend;
400099f0: 84 10 00 19 mov %i1, %g2
400099f4: 10 bf ff f3 b 400099c0 <_Workspace_Handler_initialization+0xc8>
400099f8: c2 06 00 00 ld [ %i0 ], %g1
400099fc: c2 06 00 00 ld [ %i0 ], %g1
40009a00: 84 10 00 19 mov %i1, %g2
remaining = 0;
40009a04: 10 bf ff ef b 400099c0 <_Workspace_Handler_initialization+0xc8>
40009a08: a0 10 20 00 clr %l0
remaining = rtems_configuration_get_work_space_size();
40009a0c: 40 00 03 48 call 4000a72c <rtems_configuration_get_stack_space_size>
40009a10: 01 00 00 00 nop
40009a14: 10 bf ff c0 b 40009914 <_Workspace_Handler_initialization+0x1c>
40009a18: c2 06 00 00 ld [ %i0 ], %g1
<== NOT EXECUTED
_Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE );
40009a1c: 7f ff ff b2 call 400098e4 <_Internal_error>
<== NOT EXECUTED
40009a20: 90 10 20 02 mov 2, %o0
40009a24: 01 00 00 00 nop