00000000400274f0 <_CORE_message_queue_Broadcast>:
const void *buffer,
size_t size,
uint32_t *count,
Thread_queue_Context *queue_context
)
{
400274f0: a9bb7bfd stp x29, x30, [sp, #-80]!
400274f4: 910003fd mov x29, sp
400274f8: a90153f3 stp x19, x20, [sp, #16]
400274fc: aa0003f4 mov x20, x0
Thread_Control *the_thread;
uint32_t number_broadcasted;
if ( size > the_message_queue->maximum_message_size ) {
40027500: f9401400 ldr x0, [x0, #40]
{
40027504: a9025bf5 stp x21, x22, [sp, #32]
40027508: aa0403f5 mov x21, x4
if ( size > the_message_queue->maximum_message_size ) {
4002750c: eb02001f cmp x0, x2
40027510: 54000543 b.cc 400275b8 <_CORE_message_queue_Broadcast+0xc8> // b.lo, b.ul, b.last
number_broadcasted = 0;
_CORE_message_queue_Acquire_critical( the_message_queue, queue_context );
while (
40027514: a90363f7 stp x23, x24, [sp, #48]
40027518: aa0203f6 mov x22, x2
*
* 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 ) {
4002751c: b9402697 ldr w23, [x20, #36]
40027520: f90023f9 str x25, [sp, #64]
40027524: aa0103f8 mov x24, x1
40027528: aa0303f9 mov x25, x3
4002752c: 35000557 cbnz w23, 400275d4 <_CORE_message_queue_Broadcast+0xe4>
RTEMS_INLINE_ROUTINE Thread_Control *_Thread_queue_First_locked(
Thread_queue_Control *the_thread_queue,
const Thread_queue_Operations *operations
)
{
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
40027530: f9400280 ldr x0, [x20]
/*
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
the_thread = _Thread_queue_First_locked(
40027534: f9400e81 ldr x1, [x20, #24]
if ( heads != NULL ) {
40027538: b40002c0 cbz x0, 40027590 <_CORE_message_queue_Broadcast+0xa0>
return ( *operations->first )( heads );
4002753c: f9401021 ldr x1, [x1, #32]
40027540: d63f0020 blr x1
40027544: aa0003f3 mov x19, x0
memcpy(destination, source, size);
40027548: aa1803e1 mov x1, x24
4002754c: aa1603e2 mov x2, x22
&the_message_queue->Wait_queue,
the_message_queue->operations
);
if ( the_thread == NULL ) {
40027550: b4000200 cbz x0, 40027590 <_CORE_message_queue_Broadcast+0xa0> <== NEVER TAKEN
memcpy(destination, source, size);
40027554: a9478003 ldp x3, x0, [x0, #120]
return NULL;
}
*(size_t *) the_thread->Wait.return_argument = size;
40027558: f9000076 str x22, [x3]
the_thread->Wait.count = (uint32_t) submit_type;
4002755c: b900727f str wzr, [x19, #112]
0,
queue_context
)
)
) {
number_broadcasted += 1;
40027560: 110006f7 add w23, w23, #0x1
memcpy(destination, source, size);
40027564: 94002c04 bl 40032574 <memcpy>
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
_Thread_queue_Extract_critical(
40027568: f9400e81 ldr x1, [x20, #24]
4002756c: aa1503e3 mov x3, x21
40027570: aa1303e2 mov x2, x19
40027574: aa1403e0 mov x0, x20
40027578: 9400076e bl 40029330 <_Thread_queue_Extract_critical>
__asm__ volatile (
4002757c: d53b4220 mrs x0, daif
40027580: d50342df msr daifset, #0x2
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
40027584: b90002a0 str w0, [x21]
if ( the_message_queue->number_of_pending_messages != 0 ) {
40027588: b9402680 ldr w0, [x20, #36]
4002758c: 34fffd20 cbz w0, 40027530 <_CORE_message_queue_Broadcast+0x40> <== ALWAYS TAKEN
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
40027590: b94002a0 ldr w0, [x21]
__asm__ volatile (
40027594: d51b4220 msr daif, x0
_CORE_message_queue_Acquire( the_message_queue, queue_context );
}
_CORE_message_queue_Release( the_message_queue, queue_context );
*count = number_broadcasted;
40027598: b9000337 str w23, [x25]
return STATUS_SUCCESSFUL;
4002759c: 52800000 mov w0, #0x0 // #0
}
400275a0: a94153f3 ldp x19, x20, [sp, #16]
400275a4: a9425bf5 ldp x21, x22, [sp, #32]
*count = number_broadcasted;
400275a8: a94363f7 ldp x23, x24, [sp, #48]
400275ac: f94023f9 ldr x25, [sp, #64]
}
400275b0: a8c57bfd ldp x29, x30, [sp], #80
400275b4: d65f03c0 ret
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
400275b8: b9400080 ldr w0, [x4]
400275bc: d51b4220 msr daif, x0
return STATUS_MESSAGE_INVALID_SIZE;
400275c0: 528f4100 mov w0, #0x7a08 // #31240
}
400275c4: a94153f3 ldp x19, x20, [sp, #16]
400275c8: a9425bf5 ldp x21, x22, [sp, #32]
400275cc: a8c57bfd ldp x29, x30, [sp], #80
400275d0: d65f03c0 ret
number_broadcasted = 0;
400275d4: 52800017 mov w23, #0x0 // #0
400275d8: 17ffffee b 40027590 <_CORE_message_queue_Broadcast+0xa0>
400275dc: 00000000 udf #0
000000004002e460 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Thread_queue_Context *queue_context
)
{
4002e460: a9bd7bfd stp x29, x30, [sp, #-48]!
return &the_chain->Tail.Node;
4002e464: 9100e006 add x6, x0, #0x38
4002e468: 910003fd mov x29, sp
4002e46c: a90153f3 stp x19, x20, [sp, #16]
4002e470: aa0003f3 mov x19, x0
return _Chain_Immutable_head( the_chain )->next;
4002e474: f9401814 ldr x20, [x0, #48]
4002e478: a9025bf5 stp x21, x22, [sp, #32]
4002e47c: aa0103f5 mov x21, x1
4002e480: aa0503f6 mov x22, x5
if ( !_Chain_Is_empty(the_chain))
4002e484: eb06029f cmp x20, x6
4002e488: 54000660 b.eq 4002e554 <_CORE_message_queue_Seize+0xf4> // b.none
new_first = old_first->next;
4002e48c: f9400284 ldr x4, [x20]
head->next = new_first;
4002e490: 9100c005 add x5, x0, #0x30
CORE_message_queue_Buffer *the_message;
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
4002e494: b9402661 ldr w1, [x19, #36]
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
4002e498: aa0203e0 mov x0, x2
*size_p = the_message->size;
4002e49c: f9400a82 ldr x2, [x20, #16]
4002e4a0: f9001a64 str x4, [x19, #48]
new_first->previous = head;
4002e4a4: f9000485 str x5, [x4, #8]
the_message_queue->number_of_pending_messages -= 1;
4002e4a8: 51000421 sub w1, w1, #0x1
4002e4ac: b9002661 str w1, [x19, #36]
4002e4b0: 91008281 add x1, x20, #0x20
*size_p = the_message->size;
4002e4b4: f9000062 str x2, [x3]
executing->Wait.count =
4002e4b8: b9401a83 ldr w3, [x20, #24]
4002e4bc: b90072a3 str w3, [x21, #112]
4002e4c0: 94002a3f bl 40038dbc <memcpy>
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
4002e4c4: f9400260 ldr x0, [x19]
* 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(
4002e4c8: f9400e61 ldr x1, [x19, #24]
if ( heads != NULL ) {
4002e4cc: b40002a0 cbz x0, 4002e520 <_CORE_message_queue_Seize+0xc0>
return ( *operations->first )( heads );
4002e4d0: f9401021 ldr x1, [x1, #32]
4002e4d4: d63f0020 blr x1
4002e4d8: aa0003f5 mov x21, x0
&the_message_queue->Wait_queue,
the_message_queue->operations
);
if ( the_thread == NULL ) {
4002e4dc: b4000220 cbz x0, 4002e520 <_CORE_message_queue_Seize+0xc0> <== NEVER TAKEN
/*
* 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(
4002e4e0: b94072a4 ldr w4, [x21, #112]
4002e4e4: aa1403e1 mov x1, x20
4002e4e8: b9408aa3 ldr w3, [x21, #136]
4002e4ec: aa1303e0 mov x0, x19
4002e4f0: f94042a2 ldr x2, [x21, #128]
4002e4f4: 9400198b bl 40034b20 <_CORE_message_queue_Insert_message>
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(
4002e4f8: f9400e61 ldr x1, [x19, #24]
4002e4fc: aa1303e0 mov x0, x19
4002e500: aa1603e3 mov x3, x22
4002e504: aa1503e2 mov x2, x21
4002e508: 94000cf2 bl 400318d0 <_Thread_queue_Extract_critical>
&the_message_queue->Wait_queue.Queue,
the_message_queue->operations,
the_thread,
queue_context
);
return STATUS_SUCCESSFUL;
4002e50c: 52800000 mov w0, #0x0 // #0
the_message_queue->operations,
executing,
queue_context
);
return _Thread_Wait_get_status( executing );
}
4002e510: a94153f3 ldp x19, x20, [sp, #16]
4002e514: a9425bf5 ldp x21, x22, [sp, #32]
4002e518: a8c37bfd ldp x29, x30, [sp], #48
4002e51c: d65f03c0 ret
old_last = tail->previous;
4002e520: 9101a273 add x19, x19, #0x68
4002e524: f9400660 ldr x0, [x19, #8]
the_node->next = tail;
4002e528: f9000293 str x19, [x20]
tail->previous = the_node;
4002e52c: f9000674 str x20, [x19, #8]
old_last->next = the_node;
4002e530: f9000014 str x20, [x0]
the_node->previous = old_last;
4002e534: f9000680 str x0, [x20, #8]
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
4002e538: b94002c0 ldr w0, [x22]
4002e53c: d51b4220 msr daif, x0
return STATUS_SUCCESSFUL;
4002e540: 52800000 mov w0, #0x0 // #0
}
4002e544: a94153f3 ldp x19, x20, [sp, #16]
4002e548: a9425bf5 ldp x21, x22, [sp, #32]
4002e54c: a8c37bfd ldp x29, x30, [sp], #48
4002e550: d65f03c0 ret
if ( !wait ) {
4002e554: 12001c84 and w4, w4, #0xff
4002e558: 34000144 cbz w4, 4002e580 <_CORE_message_queue_Seize+0x120>
_Thread_queue_Enqueue(
4002e55c: f9400c01 ldr x1, [x0, #24]
executing->Wait.return_argument_second.mutable_object = buffer;
4002e560: a9078aa3 stp x3, x2, [x21, #120]
queue_context->thread_state = thread_state;
4002e564: 52800202 mov w2, #0x10 // #16
4002e568: b90004a2 str w2, [x5, #4]
_Thread_queue_Enqueue(
4002e56c: aa0503e3 mov x3, x5
4002e570: aa1503e2 mov x2, x21
4002e574: 94000c63 bl 40031700 <_Thread_queue_Enqueue>
return (Status_Control) the_thread->Wait.return_code;
4002e578: b9408ea0 ldr w0, [x21, #140]
return _Thread_Wait_get_status( executing );
4002e57c: 17ffffe5 b 4002e510 <_CORE_message_queue_Seize+0xb0>
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
4002e580: b94000a0 ldr w0, [x5]
4002e584: d51b4220 msr daif, x0
return STATUS_UNSATISFIED;
4002e588: 528161a0 mov w0, #0xb0d // #2829
4002e58c: 17ffffe1 b 4002e510 <_CORE_message_queue_Seize+0xb0>
000000004002e590 <_CORE_message_queue_Submit>:
size_t size,
CORE_message_queue_Submit_types submit_type,
bool wait,
Thread_queue_Context *queue_context
)
{
4002e590: a9bb7bfd stp x29, x30, [sp, #-80]!
4002e594: 910003fd mov x29, sp
4002e598: a90153f3 stp x19, x20, [sp, #16]
4002e59c: aa0003f3 mov x19, x0
CORE_message_queue_Buffer *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
4002e5a0: f9401400 ldr x0, [x0, #40]
{
4002e5a4: a9025bf5 stp x21, x22, [sp, #32]
4002e5a8: aa0603f5 mov x21, x6
if ( size > the_message_queue->maximum_message_size ) {
4002e5ac: eb03001f cmp x0, x3
4002e5b0: 54000783 b.cc 4002e6a0 <_CORE_message_queue_Submit+0x110> // b.lo, b.ul, b.last
*
* 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 ) {
4002e5b4: b9402660 ldr w0, [x19, #36]
4002e5b8: aa0303f4 mov x20, x3
4002e5bc: a90363f7 stp x23, x24, [sp, #48]
4002e5c0: 2a0403f6 mov w22, w4
4002e5c4: aa0103f8 mov x24, x1
4002e5c8: a9046bf9 stp x25, x26, [sp, #64]
4002e5cc: aa0203f9 mov x25, x2
4002e5d0: 12001cba and w26, w5, #0xff
4002e5d4: 35000340 cbnz w0, 4002e63c <_CORE_message_queue_Submit+0xac>
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
4002e5d8: f9400260 ldr x0, [x19]
/*
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
the_thread = _Thread_queue_First_locked(
4002e5dc: f9400e61 ldr x1, [x19, #24]
if ( heads != NULL ) {
4002e5e0: b40002e0 cbz x0, 4002e63c <_CORE_message_queue_Submit+0xac>
return ( *operations->first )( heads );
4002e5e4: f9401021 ldr x1, [x1, #32]
4002e5e8: d63f0020 blr x1
4002e5ec: aa0003f7 mov x23, x0
&the_message_queue->Wait_queue,
the_message_queue->operations
);
if ( the_thread == NULL ) {
4002e5f0: b4000260 cbz x0, 4002e63c <_CORE_message_queue_Submit+0xac> <== NEVER TAKEN
memcpy(destination, source, size);
4002e5f4: a9478003 ldp x3, x0, [x0, #120]
return NULL;
}
*(size_t *) the_thread->Wait.return_argument = size;
4002e5f8: f9000074 str x20, [x3]
the_thread->Wait.count = (uint32_t) submit_type;
4002e5fc: b90072f6 str w22, [x23, #112]
memcpy(destination, source, size);
4002e600: aa1903e1 mov x1, x25
4002e604: aa1403e2 mov x2, x20
4002e608: 940029ed bl 40038dbc <memcpy>
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
_Thread_queue_Extract_critical(
4002e60c: f9400e61 ldr x1, [x19, #24]
4002e610: aa1703e2 mov x2, x23
4002e614: aa1303e0 mov x0, x19
4002e618: aa1503e3 mov x3, x21
4002e61c: 94000cad bl 400318d0 <_Thread_queue_Extract_critical>
buffer,
size,
submit_type,
queue_context
);
if ( the_thread != NULL ) {
4002e620: a94363f7 ldp x23, x24, [sp, #48]
return STATUS_SUCCESSFUL;
4002e624: 52800000 mov w0, #0x0 // #0
4002e628: a9446bf9 ldp x25, x26, [sp, #64]
executing,
queue_context
);
return _Thread_Wait_get_status( executing );
#endif
}
4002e62c: a94153f3 ldp x19, x20, [sp, #16]
4002e630: a9425bf5 ldp x21, x22, [sp, #32]
4002e634: a8c57bfd ldp x29, x30, [sp], #80
4002e638: d65f03c0 ret
return _Chain_Immutable_head( the_chain )->next;
4002e63c: f9403261 ldr x1, [x19, #96]
return &the_chain->Tail.Node;
4002e640: 9101a260 add x0, x19, #0x68
return _Chain_Immutable_head( the_chain )->next;
4002e644: 91018265 add x5, x19, #0x60
if ( !_Chain_Is_empty(the_chain))
4002e648: eb00003f cmp x1, x0
4002e64c: 540004a0 b.eq 4002e6e0 <_CORE_message_queue_Submit+0x150> // b.none
new_first = old_first->next;
4002e650: f9400020 ldr x0, [x1]
head->next = new_first;
4002e654: f9003260 str x0, [x19, #96]
_CORE_message_queue_Insert_message(
4002e658: 2a1603e4 mov w4, w22
4002e65c: aa1403e3 mov x3, x20
4002e660: aa1903e2 mov x2, x25
new_first->previous = head;
4002e664: f9000405 str x5, [x0, #8]
4002e668: aa1303e0 mov x0, x19
4002e66c: 9400192d bl 40034b20 <_CORE_message_queue_Insert_message>
if (
4002e670: b9402660 ldr w0, [x19, #36]
4002e674: 7100041f cmp w0, #0x1
4002e678: 54000220 b.eq 4002e6bc <_CORE_message_queue_Submit+0x12c> // b.none
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
4002e67c: b94002a0 ldr w0, [x21]
4002e680: d51b4220 msr daif, x0
return STATUS_SUCCESSFUL;
4002e684: 52800000 mov w0, #0x0 // #0
}
4002e688: a94153f3 ldp x19, x20, [sp, #16]
4002e68c: a9425bf5 ldp x21, x22, [sp, #32]
}
4002e690: a94363f7 ldp x23, x24, [sp, #48]
4002e694: a9446bf9 ldp x25, x26, [sp, #64]
4002e698: a8c57bfd ldp x29, x30, [sp], #80
4002e69c: d65f03c0 ret
4002e6a0: b94000c0 ldr w0, [x6]
4002e6a4: d51b4220 msr daif, x0
return STATUS_MESSAGE_INVALID_SIZE;
4002e6a8: 528f4100 mov w0, #0x7a08 // #31240
}
4002e6ac: a94153f3 ldp x19, x20, [sp, #16]
4002e6b0: a9425bf5 ldp x21, x22, [sp, #32]
4002e6b4: a8c57bfd ldp x29, x30, [sp], #80
4002e6b8: d65f03c0 ret
&& the_message_queue->notify_handler != NULL
4002e6bc: f9402e62 ldr x2, [x19, #88]
4002e6c0: b4fffde2 cbz x2, 4002e67c <_CORE_message_queue_Submit+0xec>
( *the_message_queue->notify_handler )(
4002e6c4: aa1303e0 mov x0, x19
4002e6c8: aa1503e1 mov x1, x21
4002e6cc: d63f0040 blr x2
return STATUS_SUCCESSFUL;
4002e6d0: 52800000 mov w0, #0x0 // #0
( *the_message_queue->notify_handler )(
4002e6d4: a94363f7 ldp x23, x24, [sp, #48]
4002e6d8: a9446bf9 ldp x25, x26, [sp, #64]
4002e6dc: 17ffffd4 b 4002e62c <_CORE_message_queue_Submit+0x9c>
if ( !wait ) {
4002e6e0: 3400025a cbz w26, 4002e728 <_CORE_message_queue_Submit+0x198>
if ( _ISR_Is_in_progress() ) {
4002e6e4: 9400058b bl 4002fd10 <_ISR_Is_in_progress>
4002e6e8: 72001c1f tst w0, #0xff
4002e6ec: 540002a1 b.ne 4002e740 <_CORE_message_queue_Submit+0x1b0> // b.any
_Thread_queue_Enqueue(
4002e6f0: f9400e61 ldr x1, [x19, #24]
executing->Wait.count = submit_type;
4002e6f4: b9007316 str w22, [x24, #112]
executing->Wait.return_argument_second.immutable_object = buffer;
4002e6f8: f9004319 str x25, [x24, #128]
queue_context->thread_state = thread_state;
4002e6fc: 52800200 mov w0, #0x10 // #16
executing->Wait.option = (uint32_t) size;
4002e700: b9008b14 str w20, [x24, #136]
_Thread_queue_Enqueue(
4002e704: aa1803e2 mov x2, x24
4002e708: b90006a0 str w0, [x21, #4]
4002e70c: aa1503e3 mov x3, x21
4002e710: aa1303e0 mov x0, x19
4002e714: 94000bfb bl 40031700 <_Thread_queue_Enqueue>
4002e718: b9408f00 ldr w0, [x24, #140]
4002e71c: a94363f7 ldp x23, x24, [sp, #48]
4002e720: a9446bf9 ldp x25, x26, [sp, #64]
return _Thread_Wait_get_status( executing );
4002e724: 17ffffc2 b 4002e62c <_CORE_message_queue_Submit+0x9c>
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
4002e728: b94002a0 ldr w0, [x21]
4002e72c: d51b4220 msr daif, x0
return STATUS_TOO_MANY;
4002e730: 528160a0 mov w0, #0xb05 // #2821
4002e734: a94363f7 ldp x23, x24, [sp, #48]
4002e738: a9446bf9 ldp x25, x26, [sp, #64]
4002e73c: 17ffffbc b 4002e62c <_CORE_message_queue_Submit+0x9c>
4002e740: b94002a0 ldr w0, [x21]
4002e744: d51b4220 msr daif, x0
return STATUS_MESSAGE_QUEUE_WAIT_IN_ISR;
4002e748: 528161a0 mov w0, #0xb0d // #2829
4002e74c: a94363f7 ldp x23, x24, [sp, #48]
4002e750: a9446bf9 ldp x25, x26, [sp, #64]
4002e754: 17ffffb6 b 4002e62c <_CORE_message_queue_Submit+0x9c>
...
0000000040024c50 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
40024c50: a9bd7bfd stp x29, x30, [sp, #-48]!
40024c54: 910003fd mov x29, sp
40024c58: a90153f3 stp x19, x20, [sp, #16]
40024c5c: aa0003f4 mov x20, x0
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
40024c60: f9401009 ldr x9, [x0, #32]
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
40024c64: b1002020 adds x0, x1, #0x8
40024c68: 54000d22 b.cs 40024e0c <_Heap_Allocate_aligned_with_boundary+0x1bc> // b.hs, b.nlast
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
40024c6c: aa0103e7 mov x7, x1
40024c70: 91003d2a add x10, x9, #0xf
40024c74: b5000c23 cbnz x3, 40024df8 <_Heap_Allocate_aligned_with_boundary+0x1a8>
*
* @return The first block of the free list.
*/
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
40024c78: f9400a81 ldr x1, [x20, #16]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
40024c7c: eb01029f cmp x20, x1
40024c80: 54000ce0 b.eq 40024e1c <_Heap_Allocate_aligned_with_boundary+0x1cc> // b.none
uintptr_t alloc_begin = alloc_end - alloc_size;
40024c84: d2800108 mov x8, #0x8 // #8
40024c88: cb070108 sub x8, x8, x7
while ( block != free_list_tail ) {
40024c8c: 52800013 mov w19, #0x0 // #0
uintptr_t const free_size = alloc_block_begin - block_begin;
40024c90: 928001eb mov x11, #0xfffffffffffffff0 // #-16
40024c94: f90013f5 str x21, [sp, #32]
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
40024c98: f9400424 ldr x4, [x1, #8]
);
}
}
/* Statistics */
++search_count;
40024c9c: 11000673 add w19, w19, #0x1
if ( block->size_and_flag > block_size_floor ) {
40024ca0: eb00009f cmp x4, x0
40024ca4: 54000089 b.ls 40024cb4 <_Heap_Allocate_aligned_with_boundary+0x64> // b.plast
*/
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
40024ca8: 91004035 add x21, x1, #0x10
if ( alignment == 0 ) {
40024cac: b5000242 cbnz x2, 40024cf4 <_Heap_Allocate_aligned_with_boundary+0xa4>
if ( alloc_begin != 0 ) {
40024cb0: b5000815 cbnz x21, 40024db0 <_Heap_Allocate_aligned_with_boundary+0x160><== ALWAYS TAKEN
break;
}
block = block->next;
40024cb4: f9400821 ldr x1, [x1, #16]
while ( block != free_list_tail ) {
40024cb8: eb01029f cmp x20, x1
40024cbc: 54fffee1 b.ne 40024c98 <_Heap_Allocate_aligned_with_boundary+0x48> // b.any
40024cc0: f94013f5 ldr x21, [sp, #32]
++stats->allocs;
stats->searches += search_count;
stats->lifetime_allocated += _Heap_Block_size( block );
} else {
/* Statistics */
++stats->failed_allocs;
40024cc4: 91014281 add x1, x20, #0x50
40024cc8: b9404022 ldr w2, [x1, #64]
40024ccc: d2800000 mov x0, #0x0 // #0
40024cd0: 11000442 add w2, w2, #0x1
40024cd4: b9004022 str w2, [x1, #64]
}
/* Statistics */
if ( stats->max_search < search_count ) {
40024cd8: b9403422 ldr w2, [x1, #52]
40024cdc: 6b13005f cmp w2, w19
40024ce0: 54000042 b.cs 40024ce8 <_Heap_Allocate_aligned_with_boundary+0x98> // b.hs, b.nlast
stats->max_search = search_count;
40024ce4: b9003433 str w19, [x1, #52]
}
return (void *) alloc_begin;
}
40024ce8: a94153f3 ldp x19, x20, [sp, #16]
40024cec: a8c37bfd ldp x29, x30, [sp], #48
40024cf0: d65f03c0 ret
*
* @return The block size.
*/
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40024cf4: 927ff885 and x5, x4, #0xfffffffffffffffe
uintptr_t const block_end = block_begin + block_size;
40024cf8: 8b0100a5 add x5, x5, x1
uintptr_t alloc_begin = alloc_end - alloc_size;
40024cfc: 8b050104 add x4, x8, x5
40024d00: f940168d ldr x13, [x20, #40]
return value - (value % alignment);
40024d04: 9ac20886 udiv x6, x4, x2
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
40024d08: cb0d00a5 sub x5, x5, x13
40024d0c: 8b0a00a5 add x5, x5, x10
40024d10: 9b0290c6 msub x6, x6, x2, x4
40024d14: cb060086 sub x6, x4, x6
if ( alloc_begin > alloc_begin_ceiling ) {
40024d18: eb0600bf cmp x5, x6
40024d1c: 54000082 b.cs 40024d2c <_Heap_Allocate_aligned_with_boundary+0xdc> // b.hs, b.nlast
40024d20: 9ac208a4 udiv x4, x5, x2
40024d24: 9b029484 msub x4, x4, x2, x5
40024d28: cb0400a6 sub x6, x5, x4
if ( boundary != 0 ) {
40024d2c: b40002c3 cbz x3, 40024d84 <_Heap_Allocate_aligned_with_boundary+0x134>
alloc_end = alloc_begin + alloc_size;
40024d30: 8b0600ee add x14, x7, x6
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
40024d34: 8b1500ec add x12, x7, x21
40024d38: 9ac309c5 udiv x5, x14, x3
40024d3c: 9b03b8a5 msub x5, x5, x3, x14
40024d40: cb0501c4 sub x4, x14, x5
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
40024d44: eb0401df cmp x14, x4
40024d48: fa4480c2 ccmp x6, x4, #0x2, hi // hi = pmore
40024d4c: 540001c2 b.cs 40024d84 <_Heap_Allocate_aligned_with_boundary+0x134> // b.hs, b.nlast
if ( boundary_line < boundary_floor ) {
40024d50: eb04019f cmp x12, x4
40024d54: 54fffb08 b.hi 40024cb4 <_Heap_Allocate_aligned_with_boundary+0x64> // b.pmore
alloc_begin = boundary_line - alloc_size;
40024d58: cb070084 sub x4, x4, x7
40024d5c: 9ac20886 udiv x6, x4, x2
40024d60: 9b0290c6 msub x6, x6, x2, x4
40024d64: cb060086 sub x6, x4, x6
alloc_end = alloc_begin + alloc_size;
40024d68: 8b0600e5 add x5, x7, x6
40024d6c: 9ac308a4 udiv x4, x5, x3
40024d70: 9b039484 msub x4, x4, x3, x5
40024d74: cb0400a4 sub x4, x5, x4
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
40024d78: eb0400df cmp x6, x4
40024d7c: fa4430a0 ccmp x5, x4, #0x0, cc // cc = lo, ul, last
40024d80: 54fffe88 b.hi 40024d50 <_Heap_Allocate_aligned_with_boundary+0x100> // b.pmore
if ( alloc_begin >= alloc_begin_floor ) {
40024d84: eb1500df cmp x6, x21
40024d88: 54fff963 b.cc 40024cb4 <_Heap_Allocate_aligned_with_boundary+0x64> // b.lo, b.ul, b.last
40024d8c: 9ac908c4 udiv x4, x6, x9
uintptr_t const free_size = alloc_block_begin - block_begin;
40024d90: cb010165 sub x5, x11, x1
40024d94: 9b091484 madd x4, x4, x9, x5
if ( free_size >= min_block_size || free_size == 0 ) {
40024d98: f100009f cmp x4, #0x0
40024d9c: fa4411a0 ccmp x13, x4, #0x0, ne // ne = any
40024da0: 54fff8a8 b.hi 40024cb4 <_Heap_Allocate_aligned_with_boundary+0x64> // b.pmore
40024da4: aa0603f5 mov x21, x6
if ( alloc_begin != 0 ) {
40024da8: b4fff875 cbz x21, 40024cb4 <_Heap_Allocate_aligned_with_boundary+0x64> <== NEVER TAKEN
40024dac: d503201f nop
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
40024db0: aa1503e2 mov x2, x21
40024db4: aa0703e3 mov x3, x7
40024db8: aa1403e0 mov x0, x20
40024dbc: 940000d9 bl 40025120 <_Heap_Block_allocate>
++stats->allocs;
40024dc0: 91014281 add x1, x20, #0x50
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
40024dc4: aa0003e2 mov x2, x0
stats->lifetime_allocated += _Heap_Block_size( block );
40024dc8: f9402a85 ldr x5, [x20, #80]
return (void *) alloc_begin;
40024dcc: aa1503e0 mov x0, x21
++stats->allocs;
40024dd0: 29470c24 ldp w4, w3, [x1, #56]
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40024dd4: f9400442 ldr x2, [x2, #8]
stats->searches += search_count;
40024dd8: 0b130084 add w4, w4, w19
++stats->allocs;
40024ddc: 11000463 add w3, w3, #0x1
40024de0: 927ff842 and x2, x2, #0xfffffffffffffffe
40024de4: f94013f5 ldr x21, [sp, #32]
40024de8: 29070c24 stp w4, w3, [x1, #56]
stats->lifetime_allocated += _Heap_Block_size( block );
40024dec: 8b050042 add x2, x2, x5
40024df0: f9002a82 str x2, [x20, #80]
40024df4: 17ffffb9 b 40024cd8 <_Heap_Allocate_aligned_with_boundary+0x88>
if ( boundary < alloc_size ) {
40024df8: eb03003f cmp x1, x3
40024dfc: 54000088 b.hi 40024e0c <_Heap_Allocate_aligned_with_boundary+0x1bc> // b.pmore
alignment = page_size;
40024e00: f100005f cmp x2, #0x0
40024e04: 9a891042 csel x2, x2, x9, ne // ne = any
40024e08: 17ffff9c b 40024c78 <_Heap_Allocate_aligned_with_boundary+0x28>
return NULL;
40024e0c: d2800000 mov x0, #0x0 // #0
}
40024e10: a94153f3 ldp x19, x20, [sp, #16]
40024e14: a8c37bfd ldp x29, x30, [sp], #48
40024e18: d65f03c0 ret
while ( block != free_list_tail ) {
40024e1c: 52800013 mov w19, #0x0 // #0
40024e20: 17ffffa9 b 40024cc4 <_Heap_Allocate_aligned_with_boundary+0x74>
...
0000000040028ff0 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused RTEMS_UNUSED
)
{
40028ff0: a9b87bfd stp x29, x30, [sp, #-128]!
40028ff4: 910003fd mov x29, sp
40028ff8: a90153f3 stp x19, x20, [sp, #16]
40028ffc: aa0103f3 mov x19, x1
40029000: a9025bf5 stp x21, x22, [sp, #32]
40029004: ab020036 adds x22, x1, x2
40029008: a9046bf9 stp x25, x26, [sp, #64]
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; Heap_Block *extend_last_block = NULL;
4002900c: a9077fff stp xzr, xzr, [sp, #112]
Heap_Block *const first_block = heap->first_block;
40029010: f9402019 ldr x25, [x0, #64]
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
40029014: 54000482 b.cs 400290a4 <_Heap_Extend+0xb4> // b.hs, b.nlast
40029018: a90363f7 stp x23, x24, [sp, #48]
4002901c: aa0003f7 mov x23, x0
40029020: aa0203e1 mov x1, x2
uintptr_t const free_size = stats->free_size;
40029024: 9101401a add x26, x0, #0x50
if ( extend_area_end < extend_area_begin ) {
return 0;
}
extend_area_ok = _Heap_Get_first_and_last_block(
40029028: 9101e3e5 add x5, sp, #0x78
4002902c: a9420ef8 ldp x24, x3, [x23, #32]
40029030: 9101c3e4 add x4, sp, #0x70
40029034: aa1303e0 mov x0, x19
uintptr_t const free_size = stats->free_size;
40029038: f9400f55 ldr x21, [x26, #24]
extend_area_ok = _Heap_Get_first_and_last_block(
4002903c: aa1803e2 mov x2, x24
40029040: 97ffefb4 bl 40024f10 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
40029044: 72001c1f tst w0, #0xff
40029048: 540013e0 b.eq 400292c4 <_Heap_Extend+0x2d4> // b.none
4002904c: a90573fb stp x27, x28, [sp, #80]
Heap_Block *const first_block = heap->first_block;
40029050: aa1903e3 mov x3, x25
40029054: aa1303f4 mov x20, x19
return 0;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
40029058: eb19007f cmp x3, x25
4002905c: aa0303e0 mov x0, x3
Heap_Block *link_above_block = NULL;
40029060: d280001b mov x27, #0x0 // #0
Heap_Block *link_below_block = NULL;
40029064: d2800002 mov x2, #0x0 // #0
Heap_Block *merge_above_block = NULL;
40029068: d280001c mov x28, #0x0 // #0
Heap_Block *merge_below_block = NULL;
4002906c: d2800006 mov x6, #0x0 // #0
(uintptr_t) start_block : heap->area_begin;
40029070: 54000401 b.ne 400290f0 <_Heap_Extend+0x100> // b.any <== NEVER TAKEN
40029074: d503201f nop
uintptr_t const sub_area_end = start_block->prev_size;
40029078: f9400064 ldr x4, [x3]
(uintptr_t) start_block : heap->area_begin;
4002907c: f9401ae0 ldr x0, [x23, #48]
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
40029080: eb04027f cmp x19, x4
return value - (value % alignment);
40029084: 9ad80881 udiv x1, x4, x24
- HEAP_BLOCK_HEADER_SIZE);
40029088: d1004085 sub x5, x4, #0x10
if (
4002908c: fa563002 ccmp x0, x22, #0x2, cc // cc = lo, ul, last
return value - (value % alignment);
40029090: 9b189021 msub x1, x1, x24, x4
- HEAP_BLOCK_HEADER_SIZE);
40029094: cb0100a5 sub x5, x5, x1
40029098: 540003c2 b.cs 40029110 <_Heap_Extend+0x120> // b.hs, b.nlast
4002909c: a94363f7 ldp x23, x24, [sp, #48]
400290a0: a94573fb ldp x27, x28, [sp, #80]
return 0;
400290a4: d2800000 mov x0, #0x0 // #0
/* Statistics */
stats->size += extended_size;
return extended_size;
}
400290a8: a94153f3 ldp x19, x20, [sp, #16]
400290ac: a9425bf5 ldp x21, x22, [sp, #32]
400290b0: a9446bf9 ldp x25, x26, [sp, #64]
400290b4: a8c87bfd ldp x29, x30, [sp], #128
400290b8: d65f03c0 ret
} else if ( extend_area_end < sub_area_end ) {
400290bc: eb0402df cmp x22, x4
400290c0: 9a832042 csel x2, x2, x3, cs // cs = hs, nlast
if ( sub_area_end == extend_area_begin ) {
400290c4: eb04027f cmp x19, x4
400290c8: 540002e0 b.eq 40029124 <_Heap_Extend+0x134> // b.none
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
400290cc: f94004a3 ldr x3, [x5, #8]
link_above_block = end_block;
400290d0: 9a85937b csel x27, x27, x5, ls // ls = plast
400290d4: 927ff863 and x3, x3, #0xfffffffffffffffe
return (Heap_Block *) ((uintptr_t) block + offset);
400290d8: 8b050063 add x3, x3, x5
} while ( start_block != first_block );
400290dc: eb03033f cmp x25, x3
400290e0: 54000300 b.eq 40029140 <_Heap_Extend+0x150> // b.none
(uintptr_t) start_block : heap->area_begin;
400290e4: eb19007f cmp x3, x25
400290e8: aa0303e0 mov x0, x3
400290ec: 54fffc60 b.eq 40029078 <_Heap_Extend+0x88> // b.none <== NEVER TAKEN
uintptr_t const sub_area_end = start_block->prev_size;
400290f0: f9400064 ldr x4, [x3]
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
400290f4: eb04027f cmp x19, x4
- HEAP_BLOCK_HEADER_SIZE);
400290f8: d1004085 sub x5, x4, #0x10
return value - (value % alignment);
400290fc: 9ad80881 udiv x1, x4, x24
if (
40029100: fa563002 ccmp x0, x22, #0x2, cc // cc = lo, ul, last
40029104: 9b189021 msub x1, x1, x24, x4
- HEAP_BLOCK_HEADER_SIZE);
40029108: cb0100a5 sub x5, x5, x1
4002910c: 54fffc83 b.cc 4002909c <_Heap_Extend+0xac> // b.lo, b.ul, b.last
if ( extend_area_end == sub_area_begin ) {
40029110: eb16001f cmp x0, x22
40029114: 54fffd41 b.ne 400290bc <_Heap_Extend+0xcc> // b.any
40029118: aa0303e6 mov x6, x3
if ( sub_area_end == extend_area_begin ) {
4002911c: eb04027f cmp x19, x4
40029120: 54fffd61 b.ne 400290cc <_Heap_Extend+0xdc> // b.any <== ALWAYS TAKEN
start_block->prev_size = extend_area_end;
40029124: f9000076 str x22, [x3]
merge_above_block = end_block;
40029128: aa0503fc mov x28, x5
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4002912c: f94004a3 ldr x3, [x5, #8]
40029130: 927ff863 and x3, x3, #0xfffffffffffffffe
return (Heap_Block *) ((uintptr_t) block + offset);
40029134: 8b050063 add x3, x3, x5
} while ( start_block != first_block );
40029138: eb03033f cmp x25, x3
4002913c: 54fffd41 b.ne 400290e4 <_Heap_Extend+0xf4> // b.any
if ( extend_area_begin < heap->area_begin ) {
40029140: f9401ae0 ldr x0, [x23, #48]
40029144: eb13001f cmp x0, x19
40029148: 54000cc9 b.ls 400292e0 <_Heap_Extend+0x2f0> // b.plast
heap->area_begin = extend_area_begin;
4002914c: f9001af3 str x19, [x23, #48]
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
40029150: a94707e0 ldp x0, x1, [sp, #112]
extend_first_block_size =
40029154: cb000023 sub x3, x1, x0
extend_first_block_size | HEAP_PREV_BLOCK_USED;
40029158: b2400064 orr x4, x3, #0x1
extend_first_block->size_and_flag =
4002915c: a9001016 stp x22, x4, [x0]
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
40029160: f94022e4 ldr x4, [x23, #64]
extend_last_block->size_and_flag = 0;
40029164: a9007c23 stp x3, xzr, [x1]
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
40029168: eb00009f cmp x4, x0
4002916c: 54000b09 b.ls 400292cc <_Heap_Extend+0x2dc> // b.plast
heap->first_block = extend_first_block;
40029170: f90022e0 str x0, [x23, #64]
if ( merge_below_block != NULL ) {
40029174: b4000c06 cbz x6, 400292f4 <_Heap_Extend+0x304>
uintptr_t const page_size = heap->page_size;
40029178: f94012e2 ldr x2, [x23, #32]
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
4002917c: 91004261 add x1, x19, #0x10
uintptr_t remainder = value % alignment;
40029180: 9ac20820 udiv x0, x1, x2
40029184: 9b028400 msub x0, x0, x2, x1
if ( remainder != 0 ) {
40029188: b40000a0 cbz x0, 4002919c <_Heap_Extend+0x1ac>
return value - remainder + alignment;
4002918c: 8b010041 add x1, x2, x1
40029190: cb000021 sub x1, x1, x0
uintptr_t const new_first_block_begin =
40029194: d1004034 sub x20, x1, #0x10
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
40029198: aa1403f3 mov x19, x20
++stats->used_blocks;
4002919c: b9403343 ldr w3, [x26, #48]
uintptr_t const new_first_block_size =
400291a0: cb1400c0 sub x0, x6, x20
--stats->frees;
400291a4: b9404742 ldr w2, [x26, #68]
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
400291a8: b2400000 orr x0, x0, #0x1
new_first_block->prev_size = first_block->prev_size;
400291ac: f94000c4 ldr x4, [x6]
--stats->frees;
400291b0: 51000442 sub w2, w2, #0x1
++stats->used_blocks;
400291b4: 11000463 add w3, w3, #0x1
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
400291b8: a9000264 stp x4, x0, [x19]
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) );
400291bc: aa1703e0 mov x0, x23
++stats->used_blocks;
400291c0: b9003343 str w3, [x26, #48]
--stats->frees;
400291c4: b9004742 str w2, [x26, #68]
new_first_block->prev_size = first_block->prev_size;
400291c8: f90037e6 str x6, [sp, #104]
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) );
400291cc: 94000065 bl 40029360 <_Heap_Free>
return _Heap_Free_list_head(heap)->next;
400291d0: f9400ae0 ldr x0, [x23, #16]
}
400291d4: f94037e6 ldr x6, [sp, #104]
Heap_Block *prev = block->prev;
400291d8: a9410801 ldp x1, x2, [x0, #16]
prev->next = next;
400291dc: f9000841 str x1, [x2, #16]
next->prev = prev;
400291e0: f9000c22 str x2, [x1, #24]
Heap_Block *prev = block_next->prev;
400291e4: f9400ee1 ldr x1, [x23, #24]
new_block->prev = prev;
400291e8: a9010417 stp x23, x1, [x0, #16]
prev->next = new_block;
400291ec: f9000820 str x0, [x1, #16]
block_next->prev = new_block;
400291f0: f9000ee0 str x0, [x23, #24]
if ( merge_above_block != NULL ) {
400291f4: b40008bc cbz x28, 40029308 <_Heap_Extend+0x318>
uintptr_t const last_block_new_size = _Heap_Align_down(
400291f8: d10042d6 sub x22, x22, #0x10
++stats->used_blocks;
400291fc: b9403346 ldr w6, [x26, #48]
return value - (value % alignment);
40029200: f94012e7 ldr x7, [x23, #32]
uintptr_t const last_block_new_size = _Heap_Align_down(
40029204: cb1c02c3 sub x3, x22, x28
(last_block->size_and_flag - last_block_new_size)
40029208: f9400782 ldr x2, [x28, #8]
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) );
4002920c: 91004381 add x1, x28, #0x10
40029210: 9ac70864 udiv x4, x3, x7
--stats->frees;
40029214: b9404745 ldr w5, [x26, #68]
(last_block->size_and_flag - last_block_new_size)
40029218: 8b020382 add x2, x28, x2
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) );
4002921c: aa1703e0 mov x0, x23
++stats->used_blocks;
40029220: 110004c6 add w6, w6, #0x1
--stats->frees;
40029224: 510004a5 sub w5, w5, #0x1
40029228: 9b078c84 msub x4, x4, x7, x3
4002922c: cb040063 sub x3, x3, x4
(last_block->size_and_flag - last_block_new_size)
40029230: cb160096 sub x22, x4, x22
new_last_block->size_and_flag =
40029234: 8b030384 add x4, x28, x3
(last_block->size_and_flag - last_block_new_size)
40029238: 8b160042 add x2, x2, x22
| HEAP_PREV_BLOCK_USED;
4002923c: b2400042 orr x2, x2, #0x1
new_last_block->size_and_flag =
40029240: f9000482 str x2, [x4, #8]
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
40029244: f9400782 ldr x2, [x28, #8]
40029248: 92400042 and x2, x2, #0x1
block->size_and_flag = size | flag;
4002924c: aa030043 orr x3, x2, x3
40029250: f9000783 str x3, [x28, #8]
++stats->used_blocks;
40029254: b9003346 str w6, [x26, #48]
--stats->frees;
40029258: b9004745 str w5, [x26, #68]
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) );
4002925c: 94000041 bl 40029360 <_Heap_Free>
return _Heap_Free_list_head(heap)->next;
40029260: f9400ae0 ldr x0, [x23, #16]
Heap_Block *prev = block->prev;
40029264: a9410801 ldp x1, x2, [x0, #16]
prev->next = next;
40029268: f9000841 str x1, [x2, #16]
next->prev = prev;
4002926c: f9000c22 str x2, [x1, #24]
Heap_Block *prev = block_next->prev;
40029270: f9400ee1 ldr x1, [x23, #24]
new_block->prev = prev;
40029274: a9010417 stp x23, x1, [x0, #16]
prev->next = new_block;
40029278: f9000820 str x0, [x1, #16]
block_next->prev = new_block;
4002927c: f9000ee0 str x0, [x23, #24]
_Heap_Block_set_size(
40029280: a9440ee1 ldp x1, x3, [x23, #64]
extended_size = stats->free_size - free_size;
40029284: a9410342 ldp x2, x0, [x26, #16]
stats->size += extended_size;
40029288: a94363f7 ldp x23, x24, [sp, #48]
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4002928c: f9400464 ldr x4, [x3, #8]
_Heap_Block_set_size(
40029290: cb030021 sub x1, x1, x3
extended_size = stats->free_size - free_size;
40029294: cb150000 sub x0, x0, x21
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
40029298: 92400084 and x4, x4, #0x1
block->size_and_flag = size | flag;
4002929c: aa040021 orr x1, x1, x4
stats->size += extended_size;
400292a0: a94573fb ldp x27, x28, [sp, #80]
400292a4: f9000461 str x1, [x3, #8]
400292a8: 8b000041 add x1, x2, x0
400292ac: f9000b41 str x1, [x26, #16]
}
400292b0: a94153f3 ldp x19, x20, [sp, #16]
400292b4: a9425bf5 ldp x21, x22, [sp, #32]
400292b8: a9446bf9 ldp x25, x26, [sp, #64]
400292bc: a8c87bfd ldp x29, x30, [sp], #128
400292c0: d65f03c0 ret
400292c4: a94363f7 ldp x23, x24, [sp, #48]
400292c8: 17ffff77 b 400290a4 <_Heap_Extend+0xb4>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
400292cc: f94026e0 ldr x0, [x23, #72]
400292d0: eb01001f cmp x0, x1
400292d4: 54fff502 b.cs 40029174 <_Heap_Extend+0x184> // b.hs, b.nlast
heap->last_block = extend_last_block;
400292d8: f90026e1 str x1, [x23, #72]
400292dc: 17ffffa6 b 40029174 <_Heap_Extend+0x184>
} else if ( heap->area_end < extend_area_end ) {
400292e0: f9401ee0 ldr x0, [x23, #56]
400292e4: eb16001f cmp x0, x22
400292e8: 54fff342 b.cs 40029150 <_Heap_Extend+0x160> // b.hs, b.nlast
heap->area_end = extend_area_end;
400292ec: f9001ef6 str x22, [x23, #56]
400292f0: 17ffff98 b 40029150 <_Heap_Extend+0x160>
} else if ( link_below_block != NULL ) {
400292f4: b4fff802 cbz x2, 400291f4 <_Heap_Extend+0x204>
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
400292f8: cb010040 sub x0, x2, x1
400292fc: b2400000 orr x0, x0, #0x1
last_block->size_and_flag =
40029300: f9000420 str x0, [x1, #8]
}
40029304: 17ffffbc b 400291f4 <_Heap_Extend+0x204>
} else if ( link_above_block != NULL ) {
40029308: b400015b cbz x27, 40029330 <_Heap_Extend+0x340>
_Heap_Link_above(
4002930c: a9470be0 ldp x0, x2, [sp, #112]
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
40029310: f9400761 ldr x1, [x27, #8]
40029314: 92400021 and x1, x1, #0x1
_Heap_Block_set_size( link, first_block_begin - link_begin );
40029318: cb1b0000 sub x0, x0, x27
block->size_and_flag = size | flag;
4002931c: aa010000 orr x0, x0, x1
40029320: f9000760 str x0, [x27, #8]
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
40029324: f9400440 ldr x0, [x2, #8]
40029328: b2400000 orr x0, x0, #0x1
4002932c: f9000440 str x0, [x2, #8]
if ( merge_below_block == NULL && merge_above_block == NULL ) {
40029330: b5fffa86 cbnz x6, 40029280 <_Heap_Extend+0x290>
_Heap_Free_block( heap, extend_first_block );
40029334: f9403be1 ldr x1, [sp, #112]
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) );
40029338: aa1703e0 mov x0, x23
++stats->used_blocks;
4002933c: b9403343 ldr w3, [x26, #48]
--stats->frees;
40029340: b9404742 ldr w2, [x26, #68]
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) );
40029344: 91004021 add x1, x1, #0x10
++stats->used_blocks;
40029348: 11000463 add w3, w3, #0x1
4002934c: b9003343 str w3, [x26, #48]
--stats->frees;
40029350: 51000442 sub w2, w2, #0x1
40029354: b9004742 str w2, [x26, #68]
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
40029358: 17ffffc1 b 4002925c <_Heap_Extend+0x26c>
4002935c: 00000000 udf #0
0000000040029360 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
40029360: aa0003e2 mov x2, x0
/*
* 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 ) {
40029364: b4000a21 cbz x1, 400294a8 <_Heap_Free+0x148>
return value - (value % alignment);
40029368: f9401044 ldr x4, [x2, #32]
- HEAP_BLOCK_HEADER_SIZE);
4002936c: d1004026 sub x6, x1, #0x10
return (uintptr_t) block >= (uintptr_t) heap->first_block
40029370: f9402045 ldr x5, [x2, #64]
alloc_begin = (uintptr_t) alloc_begin_ptr;
block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
return false;
40029374: 52800000 mov w0, #0x0 // #0
return value - (value % alignment);
40029378: 9ac40823 udiv x3, x1, x4
4002937c: 9b048461 msub x1, x3, x4, x1
- HEAP_BLOCK_HEADER_SIZE);
40029380: cb0100c1 sub x1, x6, x1
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40029384: eb05003f cmp x1, x5
40029388: 54000583 b.cc 40029438 <_Heap_Free+0xd8> // b.lo, b.ul, b.last
4002938c: f9402448 ldr x8, [x2, #72]
40029390: eb08003f cmp x1, x8
40029394: 54000528 b.hi 40029438 <_Heap_Free+0xd8> // b.pmore
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40029398: f9400426 ldr x6, [x1, #8]
4002939c: 927ff8c7 and x7, x6, #0xfffffffffffffffe
return (Heap_Block *) ((uintptr_t) block + offset);
400293a0: 8b070024 add x4, x1, x7
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
400293a4: eb0400bf cmp x5, x4
400293a8: 54000488 b.hi 40029438 <_Heap_Free+0xd8> // b.pmore <== NEVER TAKEN
400293ac: eb04011f cmp x8, x4
400293b0: 54000443 b.cc 40029438 <_Heap_Free+0xd8> // b.lo, b.ul, b.last
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
400293b4: f9400483 ldr x3, [x4, #8]
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
400293b8: 12000060 and w0, w3, #0x1
400293bc: 360003e3 tbz w3, #0, 40029438 <_Heap_Free+0xd8> <== NEVER TAKEN
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
400293c0: 927ff863 and x3, x3, #0xfffffffffffffffe
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
400293c4: 120000c6 and w6, w6, #0x1
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 ));
400293c8: eb04011f cmp x8, x4
400293cc: 54000380 b.eq 4002943c <_Heap_Free+0xdc> // b.none
400293d0: 8b030089 add x9, x4, x3
400293d4: f9400529 ldr x9, [x9, #8]
400293d8: 37000329 tbnz w9, #0, 4002943c <_Heap_Free+0xdc>
400293dc: 5280002a mov w10, #0x1 // #1
if ( !_Heap_Is_prev_used( block ) ) {
400293e0: 34000326 cbz w6, 40029444 <_Heap_Free+0xe4>
Heap_Block *prev = old_block->prev;
400293e4: a9411085 ldp x5, x4, [x4, #16]
new_block->prev = prev;
400293e8: a9011025 stp x5, x4, [x1, #16]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
400293ec: 8b0300e3 add x3, x7, x3
next->prev = new_block;
400293f0: f9000ca1 str x1, [x5, #24]
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
400293f4: b2400066 orr x6, x3, #0x1
400293f8: 91014042 add x2, x2, #0x50
prev->next = new_block;
400293fc: f9000881 str x1, [x4, #16]
40029400: f9000426 str x6, [x1, #8]
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
40029404: f8236823 str x3, [x1, x3]
/* Statistics */
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
stats->lifetime_freed += block_size;
40029408: f9400445 ldr x5, [x2, #8]
stats->free_size += block_size;
4002940c: f9400c44 ldr x4, [x2, #24]
stats->lifetime_freed += block_size;
40029410: 8b0700a5 add x5, x5, x7
--stats->used_blocks;
40029414: b9403043 ldr w3, [x2, #48]
++stats->frees;
40029418: b9404441 ldr w1, [x2, #68]
stats->free_size += block_size;
4002941c: 8b070087 add x7, x4, x7
--stats->used_blocks;
40029420: 51000463 sub w3, w3, #0x1
stats->lifetime_freed += block_size;
40029424: f9000445 str x5, [x2, #8]
++stats->frees;
40029428: 11000421 add w1, w1, #0x1
stats->free_size += block_size;
4002942c: f9000c47 str x7, [x2, #24]
--stats->used_blocks;
40029430: b9003043 str w3, [x2, #48]
++stats->frees;
40029434: b9004441 str w1, [x2, #68]
return( true );
}
40029438: d65f03c0 ret
if ( !_Heap_Is_prev_used( block ) ) {
4002943c: 5280000a mov w10, #0x0 // #0
40029440: 35000386 cbnz w6, 400294b0 <_Heap_Free+0x150>
uintptr_t const prev_size = block->prev_size;
40029444: f9400029 ldr x9, [x1]
return (Heap_Block *) ((uintptr_t) block + offset);
40029448: cb090026 sub x6, x1, x9
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4002944c: eb0500df cmp x6, x5
40029450: 54000283 b.cc 400294a0 <_Heap_Free+0x140> // b.lo, b.ul, b.last <== NEVER TAKEN
40029454: eb0800df cmp x6, x8
40029458: 54000248 b.hi 400294a0 <_Heap_Free+0x140> // b.pmore <== NEVER TAKEN
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4002945c: f94004c5 ldr x5, [x6, #8]
if ( !_Heap_Is_prev_used ( prev_block) ) {
40029460: 36000205 tbz w5, #0, 400294a0 <_Heap_Free+0x140> <== NEVER TAKEN
uintptr_t const size = block_size + prev_size + next_block_size;
40029464: 8b070129 add x9, x9, x7
if ( next_is_free ) { /* coalesce both */
40029468: 340004aa cbz w10, 400294fc <_Heap_Free+0x19c>
Heap_Block *prev = block->prev;
4002946c: f9400c85 ldr x5, [x4, #24]
uintptr_t const size = block_size + prev_size + next_block_size;
40029470: 8b090063 add x3, x3, x9
Heap_Block *next = block->next;
40029474: f9400884 ldr x4, [x4, #16]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
40029478: b2400068 orr x8, x3, #0x1
stats->free_blocks -= 1;
4002947c: b9407841 ldr w1, [x2, #120]
40029480: 91014042 add x2, x2, #0x50
prev->next = next;
40029484: f90008a4 str x4, [x5, #16]
next->prev = prev;
40029488: f9000c85 str x5, [x4, #24]
4002948c: 51000421 sub w1, w1, #0x1
40029490: b9002841 str w1, [x2, #40]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
40029494: f90004c8 str x8, [x6, #8]
next_block->prev_size = size;
40029498: f82368c3 str x3, [x6, x3]
4002949c: 17ffffdb b 40029408 <_Heap_Free+0xa8>
return false;
400294a0: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
}
400294a4: d65f03c0 ret <== NOT EXECUTED
return true;
400294a8: 52800020 mov w0, #0x1 // #1
}
400294ac: d65f03c0 ret
Heap_Block *next = block_before->next;
400294b0: f9400845 ldr x5, [x2, #16]
new_block->prev = block_before;
400294b4: a9010825 stp x5, x2, [x1, #16]
++stats->free_blocks;
400294b8: 91014042 add x2, x2, #0x50
block_before->next = new_block;
400294bc: f81c0041 stur x1, [x2, #-64]
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
400294c0: b24000e3 orr x3, x7, #0x1
if ( stats->max_free_blocks < stats->free_blocks ) {
400294c4: b9402c46 ldr w6, [x2, #44]
next->prev = new_block;
400294c8: f9000ca1 str x1, [x5, #24]
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
400294cc: f9000423 str x3, [x1, #8]
++stats->free_blocks;
400294d0: b9402843 ldr w3, [x2, #40]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
400294d4: f9400485 ldr x5, [x4, #8]
++stats->free_blocks;
400294d8: 11000463 add w3, w3, #0x1
if ( stats->max_free_blocks < stats->free_blocks ) {
400294dc: 6b06007f cmp w3, w6
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
400294e0: 927ff8a5 and x5, x5, #0xfffffffffffffffe
400294e4: f9000485 str x5, [x4, #8]
next_block->prev_size = block_size;
400294e8: f8276827 str x7, [x1, x7]
++stats->free_blocks;
400294ec: b9002843 str w3, [x2, #40]
if ( stats->max_free_blocks < stats->free_blocks ) {
400294f0: 54fff8c9 b.ls 40029408 <_Heap_Free+0xa8> // b.plast
stats->max_free_blocks = stats->free_blocks;
400294f4: b9002c43 str w3, [x2, #44]
400294f8: 17ffffc4 b 40029408 <_Heap_Free+0xa8>
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
400294fc: b2400123 orr x3, x9, #0x1
40029500: f90004c3 str x3, [x6, #8]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
40029504: 91014042 add x2, x2, #0x50
40029508: f9400483 ldr x3, [x4, #8]
4002950c: 927ff863 and x3, x3, #0xfffffffffffffffe
40029510: f9000483 str x3, [x4, #8]
next_block->prev_size = size;
40029514: f8276829 str x9, [x1, x7]
40029518: 17ffffbc b 40029408 <_Heap_Free+0xa8>
4002951c: 00000000 udf #0
000000004002d310 <_Heap_Get_free_information>:
return _Heap_Free_list_head(heap)->next;
4002d310: f9400803 ldr x3, [x0, #16]
{
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
info->largest = 0;
4002d314: a9007c3f stp xzr, xzr, [x1]
info->total = 0;
4002d318: f900083f str xzr, [x1, #16]
for(the_block = _Heap_Free_list_first(the_heap);
4002d31c: eb03001f cmp x0, x3
4002d320: 54000260 b.eq 4002d36c <_Heap_Get_free_information+0x5c> // b.none <== NEVER TAKEN
4002d324: d2800025 mov x5, #0x1 // #1
4002d328: d2800006 mov x6, #0x0 // #0
4002d32c: d2800004 mov x4, #0x0 // #0
4002d330: 14000003 b 4002d33c <_Heap_Get_free_information+0x2c>
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
info->total += the_size;
if ( info->largest < the_size )
4002d334: f9400426 ldr x6, [x1, #8]
4002d338: aa0703e5 mov x5, x7
the_block = the_block->next)
4002d33c: f9400462 ldr x2, [x3, #8]
for(the_block = _Heap_Free_list_first(the_heap);
4002d340: 910004a7 add x7, x5, #0x1
4002d344: 927f7842 and x2, x2, #0xfffffffe
info->total += the_size;
4002d348: 8b020084 add x4, x4, x2
if ( info->largest < the_size )
4002d34c: eb06005f cmp x2, x6
4002d350: 54000049 b.ls 4002d358 <_Heap_Get_free_information+0x48> // b.plast
info->largest = the_size;
4002d354: f9000422 str x2, [x1, #8]
the_block = the_block->next)
4002d358: f9400863 ldr x3, [x3, #16]
for(the_block = _Heap_Free_list_first(the_heap);
4002d35c: eb03001f cmp x0, x3
4002d360: 54fffea1 b.ne 4002d334 <_Heap_Get_free_information+0x24> // b.any
4002d364: f9000025 str x5, [x1]
4002d368: f9000824 str x4, [x1, #16]
} }
4002d36c: d65f03c0 ret
0000000040026c60 <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
40026c60: a9bc7bfd stp x29, x30, [sp, #-64]!
40026c64: 910003fd mov x29, sp
40026c68: a90153f3 stp x19, x20, [sp, #16]
40026c6c: aa0003f4 mov x20, x0
40026c70: a9025bf5 stp x21, x22, [sp, #32]
Heap_Block *current;
size_t i;
_Heap_Protection_free_all_delayed_blocks( heap );
for (i = 0; i < block_count; ++i) {
40026c74: b40006a2 cbz x2, 40026d48 <_Heap_Greedy_allocate+0xe8>
40026c78: aa0203f6 mov x22, x2
40026c7c: f9001bf7 str x23, [sp, #48]
40026c80: aa0103f7 mov x23, x1
40026c84: d2800013 mov x19, #0x0 // #0
Heap_Block *allocated_blocks = NULL;
40026c88: d2800015 mov x21, #0x0 // #0
40026c8c: d503201f nop
* @retval pointer The starting address of the allocated memory area.
* @retval NULL No memory is available of the parameters are inconsistent.
*/
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
40026c90: f8737ae1 ldr x1, [x23, x19, lsl #3]
40026c94: aa1403e0 mov x0, x20
for (i = 0; i < block_count; ++i) {
40026c98: 91000673 add x19, x19, #0x1
40026c9c: d2800003 mov x3, #0x0 // #0
40026ca0: d2800002 mov x2, #0x0 // #0
40026ca4: 940013bf bl 4002bba0 <_Heap_Allocate_aligned_with_boundary>
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
40026ca8: b4000100 cbz x0, 40026cc8 <_Heap_Greedy_allocate+0x68>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
40026cac: f9401282 ldr x2, [x20, #32]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
40026cb0: d1004003 sub x3, x0, #0x10
return value - (value % alignment);
40026cb4: 9ac20801 udiv x1, x0, x2
40026cb8: 9b028020 msub x0, x1, x2, x0
- HEAP_BLOCK_HEADER_SIZE);
40026cbc: cb000060 sub x0, x3, x0
Heap_Block *next_block = _Heap_Block_of_alloc_area(
(uintptr_t) next,
heap->page_size
);
next_block->next = allocated_blocks;
40026cc0: f9000815 str x21, [x0, #16]
40026cc4: aa0003f5 mov x21, x0
for (i = 0; i < block_count; ++i) {
40026cc8: eb1302df cmp x22, x19
40026ccc: 54fffe21 b.ne 40026c90 <_Heap_Greedy_allocate+0x30> // b.any
return _Heap_Free_list_head(heap)->next;
40026cd0: f9400a93 ldr x19, [x20, #16]
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
40026cd4: eb13029f cmp x20, x19
40026cd8: 54000440 b.eq 40026d60 <_Heap_Greedy_allocate+0x100> // b.none
40026cdc: f9401bf7 ldr x23, [sp, #48]
Heap_Block *blocks = NULL;
40026ce0: d2800016 mov x22, #0x0 // #0
40026ce4: d503201f nop
*
* @return The block size.
*/
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40026ce8: f9400663 ldr x3, [x19, #8]
_Heap_Block_allocate(
40026cec: 91004262 add x2, x19, #0x10
40026cf0: aa1303e1 mov x1, x19
40026cf4: aa1403e0 mov x0, x20
40026cf8: 927ff863 and x3, x3, #0xfffffffffffffffe
40026cfc: d1004063 sub x3, x3, #0x10
40026d00: 940014dc bl 4002c070 <_Heap_Block_allocate>
current,
_Heap_Alloc_area_of_block( current ),
_Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE
);
current->next = blocks;
40026d04: f9000a76 str x22, [x19, #16]
return &heap->free_list;
40026d08: aa1303f6 mov x22, x19
return _Heap_Free_list_head(heap)->next;
40026d0c: f9400a93 ldr x19, [x20, #16]
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
40026d10: eb13029f cmp x20, x19
40026d14: 54fffea1 b.ne 40026ce8 <_Heap_Greedy_allocate+0x88> // b.any
blocks = current;
}
while ( allocated_blocks != NULL ) {
40026d18: b40000f5 cbz x21, 40026d34 <_Heap_Greedy_allocate+0xd4>
40026d1c: d503201f nop
current = allocated_blocks;
allocated_blocks = allocated_blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
40026d20: 910042a1 add x1, x21, #0x10
40026d24: aa1403e0 mov x0, x20
allocated_blocks = allocated_blocks->next;
40026d28: f9400ab5 ldr x21, [x21, #16]
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
40026d2c: 940015f5 bl 4002c500 <_Heap_Free>
while ( allocated_blocks != NULL ) {
40026d30: b5ffff95 cbnz x21, 40026d20 <_Heap_Greedy_allocate+0xc0>
}
return blocks;
}
40026d34: aa1603e0 mov x0, x22
40026d38: a94153f3 ldp x19, x20, [sp, #16]
40026d3c: a9425bf5 ldp x21, x22, [sp, #32]
40026d40: a8c47bfd ldp x29, x30, [sp], #64
40026d44: d65f03c0 ret
40026d48: f9400813 ldr x19, [x0, #16]
Heap_Block *allocated_blocks = NULL;
40026d4c: d2800015 mov x21, #0x0 // #0
Heap_Block *blocks = NULL;
40026d50: d2800016 mov x22, #0x0 // #0
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
40026d54: eb00027f cmp x19, x0
40026d58: 54fffc41 b.ne 40026ce0 <_Heap_Greedy_allocate+0x80> // b.any <== ALWAYS TAKEN
40026d5c: 17fffff6 b 40026d34 <_Heap_Greedy_allocate+0xd4> <== NOT EXECUTED
Heap_Block *blocks = NULL;
40026d60: d2800016 mov x22, #0x0 // #0
40026d64: f9401bf7 ldr x23, [sp, #48]
40026d68: 17ffffec b 40026d18 <_Heap_Greedy_allocate+0xb8>
40026d6c: 00000000 udf #0
0000000040028330 <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
40028330: a9bd7bfd stp x29, x30, [sp, #-48]!
40028334: 910003fd mov x29, sp
40028338: a90153f3 stp x19, x20, [sp, #16]
4002833c: a9025bf5 stp x21, x22, [sp, #32]
Heap_Block *current = heap->first_block; Heap_Block *end = heap->last_block;
40028340: a9445413 ldp x19, x21, [x0, #64]
bool stop = false;
while ( !stop && current != end ) {
40028344: eb15027f cmp x19, x21
40028348: 54000240 b.eq 40028390 <_Heap_Iterate+0x60> // b.none <== NEVER TAKEN
4002834c: aa0103f4 mov x20, x1
40028350: aa0203f6 mov x22, x2
40028354: d503201f nop
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40028358: f9400661 ldr x1, [x19, #8]
4002835c: aa1303e0 mov x0, x19
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 );
40028360: aa1603e3 mov x3, x22
40028364: 927ff821 and x1, x1, #0xfffffffffffffffe
return (Heap_Block *) ((uintptr_t) block + offset);
40028368: 8b010273 add x19, x19, x1
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4002836c: f9400662 ldr x2, [x19, #8]
40028370: 12000042 and w2, w2, #0x1
40028374: d63f0280 blr x20
while ( !stop && current != end ) {
40028378: eb1302bf cmp x21, x19
stop = (*visitor)( current, size, used, visitor_arg );
4002837c: 12001c00 and w0, w0, #0xff
while ( !stop && current != end ) {
40028380: 1a9f07e4 cset w4, ne // ne = any
40028384: 52000000 eor w0, w0, #0x1
40028388: 6a00009f tst w4, w0
4002838c: 54fffe61 b.ne 40028358 <_Heap_Iterate+0x28> // b.any
current = next;
}
}
40028390: a94153f3 ldp x19, x20, [sp, #16]
40028394: a9425bf5 ldp x21, x22, [sp, #32]
40028398: a8c37bfd ldp x29, x30, [sp], #48
4002839c: d65f03c0 ret
0000000040025be0 <_Heap_Size_of_alloc_area>:
return value - (value % alignment);
40025be0: f9401005 ldr x5, [x0, #32]
- HEAP_BLOCK_HEADER_SIZE);
40025be4: d1004023 sub x3, x1, #0x10
return (uintptr_t) block >= (uintptr_t) heap->first_block
40025be8: f9402006 ldr x6, [x0, #64]
return value - (value % alignment);
40025bec: 9ac50824 udiv x4, x1, x5
40025bf0: 9b058484 msub x4, x4, x5, x1
- HEAP_BLOCK_HEADER_SIZE);
40025bf4: cb040064 sub x4, x3, x4
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40025bf8: eb0400df cmp x6, x4
40025bfc: 54000248 b.hi 40025c44 <_Heap_Size_of_alloc_area+0x64> // b.pmore <== NEVER TAKEN
40025c00: f9402400 ldr x0, [x0, #72]
40025c04: eb04001f cmp x0, x4
40025c08: 540001e3 b.cc 40025c44 <_Heap_Size_of_alloc_area+0x64> // b.lo, b.ul, b.last<== NEVER TAKEN
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40025c0c: f9400483 ldr x3, [x4, #8]
40025c10: 927ff863 and x3, x3, #0xfffffffffffffffe
return (Heap_Block *) ((uintptr_t) block + offset);
40025c14: 8b040063 add x3, x3, x4
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40025c18: eb0300df cmp x6, x3
40025c1c: 54000148 b.hi 40025c44 <_Heap_Size_of_alloc_area+0x64> // b.pmore <== NEVER TAKEN
40025c20: eb03001f cmp x0, x3
40025c24: 54000103 b.cc 40025c44 <_Heap_Size_of_alloc_area+0x64> // b.lo, b.ul, b.last<== NEVER TAKEN
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40025c28: f9400464 ldr x4, [x3, #8]
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 )
40025c2c: 12000080 and w0, w4, #0x1
40025c30: 36000084 tbz w4, #0, 40025c40 <_Heap_Size_of_alloc_area+0x60> <== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
40025c34: cb010061 sub x1, x3, x1
40025c38: 91002021 add x1, x1, #0x8
40025c3c: f9000041 str x1, [x2]
return true;
}
40025c40: d65f03c0 ret
return false;
40025c44: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
}
40025c48: d65f03c0 ret <== NOT EXECUTED
40025c4c: 00000000 udf #0
0000000040024c80 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
40024c80: d10283ff sub sp, sp, #0xa0
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;
40024c84: 72001c5f tst w2, #0xff
{
40024c88: a9027bfd stp x29, x30, [sp, #32]
40024c8c: 910083fd add x29, sp, #0x20
return _System_state_Current;
40024c90: d0000703 adrp x3, 40106000 <_Thread_Objects+0x510>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
40024c94: b9427063 ldr w3, [x3, #624]
{
40024c98: a90353f3 stp x19, x20, [sp, #48]
_Heap_Walk_print : _Heap_Walk_print_nothing;
40024c9c: 90000014 adrp x20, 40024000 <IMFS_node_initialize_sym_link>
40024ca0: 912f0282 add x2, x20, #0xbc0
{
40024ca4: a9066bf9 stp x25, x26, [sp, #96]
_Heap_Walk_print : _Heap_Walk_print_nothing;
40024ca8: 90000014 adrp x20, 40024000 <IMFS_node_initialize_sym_link>
40024cac: 912f4294 add x20, x20, #0xbd0
40024cb0: 9a821294 csel x20, x20, x2, ne // ne = any
if ( !_System_state_Is_up( _System_state_Get() ) ) {
40024cb4: 7100087f cmp w3, #0x2
40024cb8: 54000100 b.eq 40024cd8 <_Heap_Walk+0x58> // b.none
return true;
40024cbc: 5280003a mov w26, #0x1 // #1
block = next_block;
} while ( block != first_block );
return true;
}
40024cc0: 2a1a03e0 mov w0, w26
40024cc4: a9427bfd ldp x29, x30, [sp, #32]
40024cc8: a94353f3 ldp x19, x20, [sp, #48]
40024ccc: a9466bf9 ldp x25, x26, [sp, #96]
40024cd0: 910283ff add sp, sp, #0xa0
40024cd4: d65f03c0 ret
40024cd8: a90563f7 stp x23, x24, [sp, #80]
40024cdc: aa0003f8 mov x24, x0
40024ce0: 2a0103f9 mov w25, w1
(*printer)(
40024ce4: 2a0103e0 mov w0, w1
40024ce8: a9045bf5 stp x21, x22, [sp, #64]
40024cec: f0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
40024cf0: 91042042 add x2, x2, #0x108
40024cf4: a90773fb stp x27, x28, [sp, #112]
40024cf8: f9400b01 ldr x1, [x24, #16]
uintptr_t const page_size = heap->page_size;
40024cfc: f9401316 ldr x22, [x24, #32]
(*printer)(
40024d00: a9431b05 ldp x5, x6, [x24, #48]
40024d04: f90007e1 str x1, [sp, #8]
40024d08: aa1603e3 mov x3, x22
40024d0c: f9400f01 ldr x1, [x24, #24]
40024d10: f9000be1 str x1, [sp, #16]
40024d14: 52800001 mov w1, #0x0 // #0
Heap_Block *const last_block = heap->last_block;
40024d18: a944571b ldp x27, x21, [x24, #64]
uintptr_t const min_block_size = heap->min_block_size;
40024d1c: f9401717 ldr x23, [x24, #40]
(*printer)(
40024d20: f90003f5 str x21, [sp]
40024d24: aa1703e4 mov x4, x23
40024d28: aa1b03e7 mov x7, x27
40024d2c: d63f0280 blr x20
if ( page_size == 0 ) {
40024d30: b4000596 cbz x22, 40024de0 <_Heap_Walk+0x160>
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
40024d34: f2400edf tst x22, #0xf
40024d38: 54000341 b.ne 40024da0 <_Heap_Walk+0x120> // b.any
return (value % alignment) == 0;
40024d3c: 9ad60ae1 udiv x1, x23, x22
40024d40: 9b16dc21 msub x1, x1, x22, x23
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
40024d44: b50007e1 cbnz x1, 40024e40 <_Heap_Walk+0x1c0>
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
40024d48: 91004362 add x2, x27, #0x10
return (value % alignment) == 0;
40024d4c: 9ad60841 udiv x1, x2, x22
40024d50: 9b168821 msub x1, x1, x22, x2
if (
40024d54: b5000821 cbnz x1, 40024e58 <_Heap_Walk+0x1d8>
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40024d58: f9400761 ldr x1, [x27, #8]
if ( !_Heap_Is_prev_used( first_block ) ) {
40024d5c: 1200003a and w26, w1, #0x1
40024d60: 360005e1 tbz w1, #0, 40024e1c <_Heap_Walk+0x19c>
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40024d64: f94006a0 ldr x0, [x21, #8]
40024d68: 927ff800 and x0, x0, #0xfffffffffffffffe
return (Heap_Block *) ((uintptr_t) block + offset);
40024d6c: 8b0002a0 add x0, x21, x0
40024d70: f90043e0 str x0, [sp, #128]
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40024d74: f9400413 ldr x19, [x0, #8]
40024d78: 1200026a and w10, w19, #0x1
if ( _Heap_Is_free( last_block ) ) {
40024d7c: 2a0a03fa mov w26, w10
40024d80: 36000793 tbz w19, #0, 40024e70 <_Heap_Walk+0x1f0>
if (
40024d84: f94043e0 ldr x0, [sp, #128]
40024d88: eb00037f cmp x27, x0
40024d8c: 540007a0 b.eq 40024e80 <_Heap_Walk+0x200> // b.none
(*printer)(
40024d90: f0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
40024d94: 910a0042 add x2, x2, #0x280
40024d98: 2a1903e0 mov w0, w25
40024d9c: 14000014 b 40024dec <_Heap_Walk+0x16c>
(*printer)(
40024da0: f0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
40024da4: aa1603e3 mov x3, x22
40024da8: 2a1903e0 mov w0, w25
40024dac: 9106e042 add x2, x2, #0x1b8
40024db0: 52800021 mov w1, #0x1 // #1
(*printer)(
40024db4: d63f0280 blr x20
return false;
40024db8: 5280001a mov w26, #0x0 // #0
}
40024dbc: 2a1a03e0 mov w0, w26
40024dc0: a9427bfd ldp x29, x30, [sp, #32]
40024dc4: a94353f3 ldp x19, x20, [sp, #48]
40024dc8: a9445bf5 ldp x21, x22, [sp, #64]
40024dcc: a94563f7 ldp x23, x24, [sp, #80]
40024dd0: a9466bf9 ldp x25, x26, [sp, #96]
40024dd4: a94773fb ldp x27, x28, [sp, #112]
40024dd8: 910283ff add sp, sp, #0xa0
40024ddc: d65f03c0 ret
(*printer)( source, true, "page size is zero\n" );
40024de0: f0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
40024de4: 91068042 add x2, x2, #0x1a0
40024de8: 2a1903e0 mov w0, w25
(*printer)(
40024dec: 52800021 mov w1, #0x1 // #1
return false;
40024df0: 5280001a mov w26, #0x0 // #0
(*printer)(
40024df4: d63f0280 blr x20
}
40024df8: 2a1a03e0 mov w0, w26
40024dfc: a9427bfd ldp x29, x30, [sp, #32]
40024e00: a94353f3 ldp x19, x20, [sp, #48]
40024e04: a9445bf5 ldp x21, x22, [sp, #64]
40024e08: a94563f7 ldp x23, x24, [sp, #80]
40024e0c: a9466bf9 ldp x25, x26, [sp, #96]
40024e10: a94773fb ldp x27, x28, [sp, #112]
40024e14: 910283ff add sp, sp, #0xa0
40024e18: d65f03c0 ret
(*printer)(
40024e1c: f0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
40024e20: 9108e042 add x2, x2, #0x238
40024e24: 2a1903e0 mov w0, w25
(*printer)(
40024e28: 52800021 mov w1, #0x1 // #1
40024e2c: d63f0280 blr x20
return false;
40024e30: a9445bf5 ldp x21, x22, [sp, #64]
40024e34: a94563f7 ldp x23, x24, [sp, #80]
40024e38: a94773fb ldp x27, x28, [sp, #112]
40024e3c: 17ffffa1 b 40024cc0 <_Heap_Walk+0x40>
(*printer)(
40024e40: f0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
40024e44: aa1703e3 mov x3, x23
40024e48: 2a1903e0 mov w0, w25
40024e4c: 91076042 add x2, x2, #0x1d8
40024e50: 52800021 mov w1, #0x1 // #1
40024e54: 17ffffd8 b 40024db4 <_Heap_Walk+0x134>
(*printer)(
40024e58: f0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
40024e5c: aa1b03e3 mov x3, x27
40024e60: 2a1903e0 mov w0, w25
40024e64: 91080042 add x2, x2, #0x200
40024e68: 52800021 mov w1, #0x1 // #1
40024e6c: 17ffffd2 b 40024db4 <_Heap_Walk+0x134>
(*printer)(
40024e70: f0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
40024e74: 9109a042 add x2, x2, #0x268
40024e78: 2a1903e0 mov w0, w25
40024e7c: 17ffffeb b 40024e28 <_Heap_Walk+0x1a8>
return _Heap_Free_list_head(heap)->next;
40024e80: f9400b03 ldr x3, [x24, #16]
uintptr_t const page_size = heap->page_size;
40024e84: f9401305 ldr x5, [x24, #32]
while ( free_block != free_list_tail ) {
40024e88: eb03031f cmp x24, x3
return (uintptr_t) block >= (uintptr_t) heap->first_block
40024e8c: f9402301 ldr x1, [x24, #64]
40024e90: 540003c0 b.eq 40024f08 <_Heap_Walk+0x288> // b.none
40024e94: aa1803e6 mov x6, x24
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40024e98: eb01007f cmp x3, x1
40024e9c: 540000c2 b.cs 40024eb4 <_Heap_Walk+0x234> // b.hs, b.nlast
(*printer)(
40024ea0: f0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
40024ea4: 2a1903e0 mov w0, w25
40024ea8: 9112e042 add x2, x2, #0x4b8
40024eac: 52800021 mov w1, #0x1 // #1
40024eb0: 17ffffc1 b 40024db4 <_Heap_Walk+0x134>
40024eb4: f9402702 ldr x2, [x24, #72]
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
40024eb8: 91004064 add x4, x3, #0x10
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40024ebc: eb03005f cmp x2, x3
40024ec0: 54ffff03 b.cc 40024ea0 <_Heap_Walk+0x220> // b.lo, b.ul, b.last <== NEVER TAKEN
return (value % alignment) == 0;
40024ec4: 9ac50882 udiv x2, x4, x5
40024ec8: 9b059042 msub x2, x2, x5, x4
if (
40024ecc: b5001962 cbnz x2, 400251f8 <_Heap_Walk+0x578>
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40024ed0: f9400462 ldr x2, [x3, #8]
40024ed4: 927ff842 and x2, x2, #0xfffffffffffffffe
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40024ed8: 8b030042 add x2, x2, x3
40024edc: f9400442 ldr x2, [x2, #8]
if ( _Heap_Is_used( free_block ) ) {
40024ee0: 1200005a and w26, w2, #0x1
40024ee4: 37001802 tbnz w2, #0, 400251e4 <_Heap_Walk+0x564>
if ( free_block->prev != prev_block ) {
40024ee8: f9400c64 ldr x4, [x3, #24]
40024eec: eb06009f cmp x4, x6
40024ef0: 540018e1 b.ne 4002520c <_Heap_Walk+0x58c> // b.any
free_block = free_block->next;
40024ef4: f9400862 ldr x2, [x3, #16]
while ( free_block != free_list_tail ) {
40024ef8: aa0303e6 mov x6, x3
40024efc: eb02031f cmp x24, x2
40024f00: aa0203e3 mov x3, x2
40024f04: 54fffca1 b.ne 40024e98 <_Heap_Walk+0x218> // b.any
40024f08: f94043fc ldr x28, [sp, #128]
(*printer)(
40024f0c: f0000080 adrp x0, 40037000 <IMFS_mknod_control_memfile+0x20>
40024f10: 91124000 add x0, x0, #0x490
40024f14: f9004be0 str x0, [sp, #144]
(*printer)(
40024f18: f0000080 adrp x0, 40037000 <IMFS_mknod_control_memfile+0x20>
40024f1c: 9111e000 add x0, x0, #0x478
40024f20: f9004fe0 str x0, [sp, #152]
40024f24: d503201f nop
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40024f28: 927ffa73 and x19, x19, #0xfffffffffffffffe
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40024f2c: 12001d4a and w10, w10, #0xff
return (Heap_Block *) ((uintptr_t) block + offset);
40024f30: 8b13039b add x27, x28, x19
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
40024f34: eb1b003f cmp x1, x27
40024f38: 540001a9 b.ls 40024f6c <_Heap_Walk+0x2ec> // b.plast <== ALWAYS TAKEN
(*printer)(
40024f3c: f0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
40024f40: aa1b03e4 mov x4, x27
40024f44: aa1c03e3 mov x3, x28
40024f48: 2a1903e0 mov w0, w25
40024f4c: 91142042 add x2, x2, #0x508
40024f50: 52800021 mov w1, #0x1 // #1
40024f54: d63f0280 blr x20
return false;
40024f58: 5280001a mov w26, #0x0 // #0
40024f5c: a9445bf5 ldp x21, x22, [sp, #64]
40024f60: a94563f7 ldp x23, x24, [sp, #80]
40024f64: a94773fb ldp x27, x28, [sp, #112]
40024f68: 17ffff56 b 40024cc0 <_Heap_Walk+0x40>
40024f6c: f9402701 ldr x1, [x24, #72]
40024f70: eb1b003f cmp x1, x27
40024f74: 54fffe43 b.cc 40024f3c <_Heap_Walk+0x2bc> // b.lo, b.ul, b.last
return (value % alignment) == 0;
40024f78: 9ad60a62 udiv x2, x19, x22
40024f7c: 9b16cc42 msub x2, x2, x22, x19
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
40024f80: b40002a2 cbz x2, 40024fd4 <_Heap_Walk+0x354>
40024f84: eb15039f cmp x28, x21
40024f88: 54001201 b.ne 400251c8 <_Heap_Walk+0x548> // b.any
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
40024f8c: f9400761 ldr x1, [x27, #8]
if ( !_Heap_Is_prev_used( next_block ) ) {
40024f90: 1200003a and w26, w1, #0x1
40024f94: 36000581 tbz w1, #0, 40025044 <_Heap_Walk+0x3c4>
} else if (prev_used) {
40024f98: 3400046a cbz w10, 40025024 <_Heap_Walk+0x3a4>
(*printer)(
40024f9c: f9404fe2 ldr x2, [sp, #152]
40024fa0: aa1303e4 mov x4, x19
40024fa4: aa1c03e3 mov x3, x28
40024fa8: 2a1903e0 mov w0, w25
40024fac: 52800001 mov w1, #0x0 // #0
40024fb0: d63f0280 blr x20
} while ( block != first_block );
40024fb4: f94043e0 ldr x0, [sp, #128]
40024fb8: eb00037f cmp x27, x0
40024fbc: 54000fe0 b.eq 400251b8 <_Heap_Walk+0x538> // b.none
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40024fc0: f9400773 ldr x19, [x27, #8]
40024fc4: aa1b03fc mov x28, x27
return (uintptr_t) block >= (uintptr_t) heap->first_block
40024fc8: f9402301 ldr x1, [x24, #64]
40024fcc: 1200026a and w10, w19, #0x1
40024fd0: 17ffffd6 b 40024f28 <_Heap_Walk+0x2a8>
bool const is_not_last_block = block != last_block;
40024fd4: eb15039f cmp x28, x21
40024fd8: 1a9f07e1 cset w1, ne // ne = any
if ( block_size < min_block_size && is_not_last_block ) {
40024fdc: eb1302ff cmp x23, x19
40024fe0: 1a9f97e9 cset w9, hi // hi = pmore
40024fe4: 6a09003a ands w26, w1, w9
40024fe8: 54000ce1 b.ne 40025184 <_Heap_Walk+0x504> // b.any
if ( next_block_begin <= block_begin && is_not_last_block ) {
40024fec: 7100003f cmp w1, #0x0
40024ff0: fa5b1380 ccmp x28, x27, #0x0, ne // ne = any
40024ff4: 54fffcc3 b.cc 40024f8c <_Heap_Walk+0x30c> // b.lo, b.ul, b.last
(*printer)(
40024ff8: aa1b03e4 mov x4, x27
40024ffc: aa1c03e3 mov x3, x28
40025000: 2a1903e0 mov w0, w25
40025004: d0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
40025008: 52800021 mov w1, #0x1 // #1
4002500c: 910e6042 add x2, x2, #0x398
40025010: d63f0280 blr x20
return false;
40025014: a9445bf5 ldp x21, x22, [sp, #64]
40025018: a94563f7 ldp x23, x24, [sp, #80]
4002501c: a94773fb ldp x27, x28, [sp, #112]
40025020: 17ffff28 b 40024cc0 <_Heap_Walk+0x40>
(*printer)(
40025024: f9400385 ldr x5, [x28]
40025028: aa1303e4 mov x4, x19
4002502c: f9404be2 ldr x2, [sp, #144]
40025030: aa1c03e3 mov x3, x28
40025034: 2a1903e0 mov w0, w25
40025038: 52800001 mov w1, #0x0 // #0
4002503c: d63f0280 blr x20
40025040: 17ffffdd b 40024fb4 <_Heap_Walk+0x334>
return _Heap_Free_list_tail(heap)->prev;
40025044: a9410b01 ldp x1, x2, [x24, #16]
(*printer)(
40025048: f9400f85 ldr x5, [x28, #24]
4002504c: eb05003f cmp x1, x5
40025050: 54000880 b.eq 40025160 <_Heap_Walk+0x4e0> // b.none
: (block->prev == free_list_head ? " (= head)" : ""),
40025054: d0000086 adrp x6, 40037000 <IMFS_mknod_control_memfile+0x20>
40025058: 911100c1 add x1, x6, #0x440
4002505c: eb05031f cmp x24, x5
40025060: d0000086 adrp x6, 40037000 <IMFS_mknod_control_memfile+0x20>
40025064: 910360c6 add x6, x6, #0xd8
40025068: 9a8100c6 csel x6, x6, x1, eq // eq = none
(*printer)(
4002506c: f9400b87 ldr x7, [x28, #16]
40025070: eb07005f cmp x2, x7
40025074: 54000700 b.eq 40025154 <_Heap_Walk+0x4d4> // b.none
: (block->next == free_list_tail ? " (= tail)" : "")
40025078: d0000081 adrp x1, 40037000 <IMFS_mknod_control_memfile+0x20>
4002507c: 91110022 add x2, x1, #0x440
40025080: eb07031f cmp x24, x7
40025084: d0000081 adrp x1, 40037000 <IMFS_mknod_control_memfile+0x20>
40025088: 9103e021 add x1, x1, #0xf8
4002508c: 9a820021 csel x1, x1, x2, eq // eq = none
(*printer)(
40025090: f90003e1 str x1, [sp]
40025094: d0000080 adrp x0, 40037000 <IMFS_mknod_control_memfile+0x20>
40025098: 910f4002 add x2, x0, #0x3d0
4002509c: aa1303e4 mov x4, x19
400250a0: aa1c03e3 mov x3, x28
400250a4: 2a1903e0 mov w0, w25
400250a8: 52800001 mov w1, #0x0 // #0
400250ac: b9008fea str w10, [sp, #140]
400250b0: d63f0280 blr x20
if ( block_size != next_block->prev_size ) {
400250b4: f9400365 ldr x5, [x27]
400250b8: b9408fea ldr w10, [sp, #140]
400250bc: eb05027f cmp x19, x5
400250c0: 54000240 b.eq 40025108 <_Heap_Walk+0x488> // b.none
(*printer)(
400250c4: aa1b03e6 mov x6, x27
400250c8: aa1303e4 mov x4, x19
400250cc: aa1c03e3 mov x3, x28
400250d0: 2a1903e0 mov w0, w25
400250d4: 52800021 mov w1, #0x1 // #1
400250d8: d0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
400250dc: 91102042 add x2, x2, #0x408
400250e0: d63f0280 blr x20
}
400250e4: 2a1a03e0 mov w0, w26
400250e8: a9427bfd ldp x29, x30, [sp, #32]
400250ec: a94353f3 ldp x19, x20, [sp, #48]
400250f0: a9445bf5 ldp x21, x22, [sp, #64]
400250f4: a94563f7 ldp x23, x24, [sp, #80]
400250f8: a9466bf9 ldp x25, x26, [sp, #96]
400250fc: a94773fb ldp x27, x28, [sp, #112]
40025100: 910283ff add sp, sp, #0xa0
40025104: d65f03c0 ret
if ( !prev_used ) {
40025108: 3400032a cbz w10, 4002516c <_Heap_Walk+0x4ec>
return _Heap_Free_list_head(heap)->next;
4002510c: f9400b02 ldr x2, [x24, #16]
while ( free_block != free_list_tail ) {
40025110: eb02031f cmp x24, x2
40025114: 540000c0 b.eq 4002512c <_Heap_Walk+0x4ac> // b.none <== NEVER TAKEN
if ( free_block == block ) {
40025118: eb02039f cmp x28, x2
4002511c: 54fff4c0 b.eq 40024fb4 <_Heap_Walk+0x334> // b.none
free_block = free_block->next;
40025120: f9400842 ldr x2, [x2, #16]
while ( free_block != free_list_tail ) {
40025124: eb02031f cmp x24, x2
40025128: 54ffff81 b.ne 40025118 <_Heap_Walk+0x498> // b.any
(*printer)(
4002512c: aa1c03e3 mov x3, x28
40025130: 2a1903e0 mov w0, w25
40025134: d0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
40025138: 52800021 mov w1, #0x1 // #1
4002513c: 91136042 add x2, x2, #0x4d8
40025140: d63f0280 blr x20
return false;
40025144: a9445bf5 ldp x21, x22, [sp, #64]
40025148: a94563f7 ldp x23, x24, [sp, #80]
4002514c: a94773fb ldp x27, x28, [sp, #112]
40025150: 17fffedc b 40024cc0 <_Heap_Walk+0x40>
(*printer)(
40025154: d0000081 adrp x1, 40037000 <IMFS_mknod_control_memfile+0x20>
40025158: 9103a021 add x1, x1, #0xe8
4002515c: 17ffffcd b 40025090 <_Heap_Walk+0x410>
40025160: d0000086 adrp x6, 40037000 <IMFS_mknod_control_memfile+0x20>
40025164: 910320c6 add x6, x6, #0xc8
40025168: 17ffffc1 b 4002506c <_Heap_Walk+0x3ec>
(*printer)(
4002516c: d0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
40025170: aa1c03e3 mov x3, x28
40025174: 2a1903e0 mov w0, w25
40025178: 91112042 add x2, x2, #0x448
4002517c: 52800021 mov w1, #0x1 // #1
40025180: 17ffff0d b 40024db4 <_Heap_Walk+0x134>
(*printer)(
40025184: aa1703e5 mov x5, x23
40025188: aa1c03e3 mov x3, x28
4002518c: aa1303e4 mov x4, x19
40025190: 2a1903e0 mov w0, w25
40025194: d0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
40025198: 52800021 mov w1, #0x1 // #1
4002519c: 910da042 add x2, x2, #0x368
return false;
400251a0: 5280001a mov w26, #0x0 // #0
(*printer)(
400251a4: d63f0280 blr x20
return false;
400251a8: a9445bf5 ldp x21, x22, [sp, #64]
400251ac: a94563f7 ldp x23, x24, [sp, #80]
400251b0: a94773fb ldp x27, x28, [sp, #112]
400251b4: 17fffec3 b 40024cc0 <_Heap_Walk+0x40>
400251b8: a9445bf5 ldp x21, x22, [sp, #64]
400251bc: a94563f7 ldp x23, x24, [sp, #80]
400251c0: a94773fb ldp x27, x28, [sp, #112]
400251c4: 17fffebe b 40024cbc <_Heap_Walk+0x3c>
(*printer)(
400251c8: d0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
400251cc: aa1303e4 mov x4, x19
400251d0: aa1c03e3 mov x3, x28
400251d4: 2a1903e0 mov w0, w25
400251d8: 910ce042 add x2, x2, #0x338
400251dc: 52800021 mov w1, #0x1 // #1
400251e0: 17ffff5d b 40024f54 <_Heap_Walk+0x2d4>
(*printer)(
400251e4: d0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
400251e8: 2a1903e0 mov w0, w25
400251ec: 910b8042 add x2, x2, #0x2e0
400251f0: 52800021 mov w1, #0x1 // #1
400251f4: 17fffef0 b 40024db4 <_Heap_Walk+0x134>
(*printer)(
400251f8: d0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
400251fc: 2a1903e0 mov w0, w25
40025200: 910ac042 add x2, x2, #0x2b0
40025204: 52800021 mov w1, #0x1 // #1
40025208: 17fffeeb b 40024db4 <_Heap_Walk+0x134>
(*printer)(
4002520c: 2a1903e0 mov w0, w25
40025210: d0000082 adrp x2, 40037000 <IMFS_mknod_control_memfile+0x20>
40025214: 52800021 mov w1, #0x1 // #1
40025218: 910c0042 add x2, x2, #0x300
4002521c: d63f0280 blr x20
return false;
40025220: a9445bf5 ldp x21, x22, [sp, #64]
40025224: a94563f7 ldp x23, x24, [sp, #80]
40025228: a94773fb ldp x27, x28, [sp, #112]
4002522c: 17fffea5 b 40024cc0 <_Heap_Walk+0x40>
000000004002a700 <_IO_Base64>:
}
int
_IO_Base64(IO_Put_char put_char, void *arg, const void *src, size_t srclen,
const char *wordbreak, int wordlen)
{
4002a700: a9ba7bfd stp x29, x30, [sp, #-96]!
4002a704: 710010bf cmp w5, #0x4
4002a708: 910003fd mov x29, sp
4002a70c: a90153f3 stp x19, x20, [sp, #16]
4002a710: aa0003f4 mov x20, x0
4002a714: aa0203f3 mov x19, x2
4002a718: a9025bf5 stp x21, x22, [sp, #32]
4002a71c: aa0103f5 mov x21, x1
4002a720: a90363f7 stp x23, x24, [sp, #48]
4002a724: a9046bf9 stp x25, x26, [sp, #64]
4002a728: 5280009a mov w26, #0x4 // #4
4002a72c: aa0303f9 mov x25, x3
4002a730: 1a9aa0ba csel w26, w5, w26, ge // ge = tcont
if (wordlen < 4) {
wordlen = 4;
}
while (srclen > 2) {
4002a734: f100087f cmp x3, #0x2
4002a738: 54000ea9 b.ls 4002a90c <_IO_Base64+0x20c> // b.plast
4002a73c: d00000d8 adrp x24, 40044000 <event_text+0x1bf0>
4002a740: 91146318 add x24, x24, #0x518
4002a744: a90573fb stp x27, x28, [sp, #80]
4002a748: aa0403fb mov x27, x4
4002a74c: 52800016 mov w22, #0x0 // #0
4002a750: 52800017 mov w23, #0x0 // #0
4002a754: d503201f nop
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
4002a758: 39400260 ldrb w0, [x19]
(*put_char)(c, arg);
4002a75c: aa1503e1 mov x1, x21
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
4002a760: d3421c00 ubfx x0, x0, #2, #6
(*put_char)(c, arg);
4002a764: 38786800 ldrb w0, [x0, x24]
4002a768: d63f0280 blr x20
_IO_Put(base64[((in[0]<<4)&0x30)|
4002a76c: 39400262 ldrb w2, [x19]
(*put_char)(c, arg);
4002a770: aa1503e1 mov x1, x21
((in[1]>>4)&0x0f)], arg, put_char);
4002a774: 39400660 ldrb w0, [x19, #1]
_IO_Put(base64[((in[0]<<4)&0x30)|
4002a778: 531c0442 ubfiz w2, w2, #4, #2
4002a77c: 2a401040 orr w0, w2, w0, lsr #4
4002a780: 3860cb00 ldrb w0, [x24, w0, sxtw]
(*put_char)(c, arg);
4002a784: d63f0280 blr x20
_IO_Put(base64[((in[1]<<2)&0x3c)|
4002a788: 39400662 ldrb w2, [x19, #1]
(*put_char)(c, arg);
4002a78c: aa1503e1 mov x1, x21
((in[2]>>6)&0x03)], arg, put_char);
4002a790: 39400a60 ldrb w0, [x19, #2]
_IO_Put(base64[((in[1]<<2)&0x3c)|
4002a794: 531e0c42 ubfiz w2, w2, #2, #4
4002a798: 2a401840 orr w0, w2, w0, lsr #6
4002a79c: 3860cb00 ldrb w0, [x24, w0, sxtw]
(*put_char)(c, arg);
4002a7a0: d63f0280 blr x20
_IO_Put(base64[in[2]&0x3f], arg, put_char);
4002a7a4: 39400a60 ldrb w0, [x19, #2]
(*put_char)(c, arg);
4002a7a8: aa1503e1 mov x1, x21
_IO_Put(base64[in[2]&0x3f], arg, put_char);
4002a7ac: 92401400 and x0, x0, #0x3f
(*put_char)(c, arg);
4002a7b0: 38786800 ldrb w0, [x0, x24]
4002a7b4: d63f0280 blr x20
in += 3;
srclen -= 3;
out += 4;
4002a7b8: 110012c1 add w1, w22, #0x4
loops++;
if (srclen != 0 &&
4002a7bc: f1000f39 subs x25, x25, #0x3
4002a7c0: 54000540 b.eq 4002a868 <_IO_Base64+0x168> // b.none
(int)((loops + 1) * 4) >= wordlen)
4002a7c4: 11000ae0 add w0, w23, #0x2
if (srclen != 0 &&
4002a7c8: 6b000b5f cmp w26, w0, lsl #2
4002a7cc: 540005ed b.le 4002a888 <_IO_Base64+0x188>
loops++;
4002a7d0: 110006f7 add w23, w23, #0x1
out += 4;
4002a7d4: 2a0103f6 mov w22, w1
in += 3;
4002a7d8: 91000e73 add x19, x19, #0x3
while (srclen > 2) {
4002a7dc: f1000b3f cmp x25, #0x2
4002a7e0: 54fffbc8 b.hi 4002a758 <_IO_Base64+0x58> // b.pmore
4002a7e4: a94573fb ldp x27, x28, [sp, #80]
++w;
++out;
}
}
}
if (srclen == 2) {
4002a7e8: f1000b3f cmp x25, #0x2
4002a7ec: 54000681 b.ne 4002a8bc <_IO_Base64+0x1bc> // b.any
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
4002a7f0: 39400260 ldrb w0, [x19]
4002a7f4: d00000d7 adrp x23, 40044000 <event_text+0x1bf0>
4002a7f8: 911462f7 add x23, x23, #0x518
(*put_char)(c, arg);
4002a7fc: aa1503e1 mov x1, x21
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
4002a800: d3421c00 ubfx x0, x0, #2, #6
(*put_char)(c, arg);
4002a804: 38776800 ldrb w0, [x0, x23]
4002a808: d63f0280 blr x20
_IO_Put(base64[((in[0]<<4)&0x30)|
4002a80c: 39400262 ldrb w2, [x19]
(*put_char)(c, arg);
4002a810: aa1503e1 mov x1, x21
((in[1]>>4)&0x0f)], arg, put_char);
4002a814: 39400660 ldrb w0, [x19, #1]
_IO_Put(base64[((in[0]<<4)&0x30)|
4002a818: 531c0442 ubfiz w2, w2, #4, #2
4002a81c: 2a401040 orr w0, w2, w0, lsr #4
4002a820: 3860cae0 ldrb w0, [x23, w0, sxtw]
(*put_char)(c, arg);
4002a824: d63f0280 blr x20
_IO_Put(base64[((in[1]<<2)&0x3c)], arg, put_char);
4002a828: 39400660 ldrb w0, [x19, #1]
(*put_char)(c, arg);
4002a82c: aa1503e1 mov x1, x21
_IO_Put(base64[((in[1]<<2)&0x3c)], arg, put_char);
4002a830: 531e0c00 ubfiz w0, w0, #2, #4
(*put_char)(c, arg);
4002a834: 38604ae0 ldrb w0, [x23, w0, uxtw]
4002a838: d63f0280 blr x20
4002a83c: aa1503e1 mov x1, x21
4002a840: 528007a0 mov w0, #0x3d // #61
4002a844: d63f0280 blr x20
} else if (srclen == 1) {
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
_IO_Put(base64[((in[0]<<4)&0x30)], arg, put_char);
_IO_Put('=', arg, put_char);
_IO_Put('=', arg, put_char);
out += 4;
4002a848: 110012c1 add w1, w22, #0x4
}
return out;
}
4002a84c: 2a0103e0 mov w0, w1
4002a850: a94153f3 ldp x19, x20, [sp, #16]
4002a854: a9425bf5 ldp x21, x22, [sp, #32]
4002a858: a94363f7 ldp x23, x24, [sp, #48]
4002a85c: a9446bf9 ldp x25, x26, [sp, #64]
4002a860: a8c67bfd ldp x29, x30, [sp], #96
4002a864: d65f03c0 ret
4002a868: a94573fb ldp x27, x28, [sp, #80]
4002a86c: 2a0103e0 mov w0, w1
4002a870: a94153f3 ldp x19, x20, [sp, #16]
4002a874: a9425bf5 ldp x21, x22, [sp, #32]
4002a878: a94363f7 ldp x23, x24, [sp, #48]
4002a87c: a9446bf9 ldp x25, x26, [sp, #64]
4002a880: a8c67bfd ldp x29, x30, [sp], #96
4002a884: d65f03c0 ret
while (*w != '\0') {
4002a888: 39400360 ldrb w0, [x27]
4002a88c: 340003a0 cbz w0, 4002a900 <_IO_Base64+0x200> <== NEVER TAKEN
4002a890: 4b1b02dc sub w28, w22, w27
4002a894: aa1b03f7 mov x23, x27
++w;
4002a898: 910006f7 add x23, x23, #0x1
(*put_char)(c, arg);
4002a89c: aa1503e1 mov x1, x21
4002a8a0: d63f0280 blr x20
++out;
4002a8a4: 110012f6 add w22, w23, #0x4
4002a8a8: 0b1c02d6 add w22, w22, w28
while (*w != '\0') {
4002a8ac: 394002e0 ldrb w0, [x23]
4002a8b0: 35ffff40 cbnz w0, 4002a898 <_IO_Base64+0x198> <== NEVER TAKEN
loops = 0;
4002a8b4: 52800017 mov w23, #0x0 // #0
4002a8b8: 17ffffc8 b 4002a7d8 <_IO_Base64+0xd8>
} else if (srclen == 1) {
4002a8bc: f100073f cmp x25, #0x1
4002a8c0: 540002a1 b.ne 4002a914 <_IO_Base64+0x214> // b.any
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
4002a8c4: 39400260 ldrb w0, [x19]
4002a8c8: d00000d7 adrp x23, 40044000 <event_text+0x1bf0>
4002a8cc: 911462f7 add x23, x23, #0x518
(*put_char)(c, arg);
4002a8d0: aa1503e1 mov x1, x21
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
4002a8d4: d3421c00 ubfx x0, x0, #2, #6
(*put_char)(c, arg);
4002a8d8: 38776800 ldrb w0, [x0, x23]
4002a8dc: d63f0280 blr x20
_IO_Put(base64[((in[0]<<4)&0x30)], arg, put_char);
4002a8e0: 39400260 ldrb w0, [x19]
(*put_char)(c, arg);
4002a8e4: aa1503e1 mov x1, x21
_IO_Put(base64[((in[0]<<4)&0x30)], arg, put_char);
4002a8e8: 531c0400 ubfiz w0, w0, #4, #2
(*put_char)(c, arg);
4002a8ec: 38604ae0 ldrb w0, [x23, w0, uxtw]
4002a8f0: d63f0280 blr x20
4002a8f4: aa1503e1 mov x1, x21
4002a8f8: 528007a0 mov w0, #0x3d // #61
4002a8fc: 17ffffcf b 4002a838 <_IO_Base64+0x138>
out += 4;
4002a900: 2a0103f6 mov w22, w1 <== NOT EXECUTED
loops = 0;
4002a904: 52800017 mov w23, #0x0 // #0 <== NOT EXECUTED
4002a908: 17ffffb4 b 4002a7d8 <_IO_Base64+0xd8> <== NOT EXECUTED
while (srclen > 2) {
4002a90c: 52800016 mov w22, #0x0 // #0
4002a910: 17ffffb6 b 4002a7e8 <_IO_Base64+0xe8>
4002a914: 2a1603e1 mov w1, w22
return out;
4002a918: 17ffffd5 b 4002a86c <_IO_Base64+0x16c>
4002a91c: 00000000 udf #0
000000004002c6b0 <_IO_Vprintf>:
return (p);
}
int
_IO_Vprintf(IO_Put_char put_char, void *arg, char const *fmt, va_list ap)
{
4002c6b0: a9b47bfd stp x29, x30, [sp, #-192]!
4002c6b4: 910003fd mov x29, sp
4002c6b8: a90153f3 stp x19, x20, [sp, #16]
4002c6bc: aa0003f3 mov x19, x0
4002c6c0: f9400060 ldr x0, [x3]
4002c6c4: f90033e0 str x0, [sp, #96]
4002c6c8: f9400460 ldr x0, [x3, #8]
4002c6cc: f9003fe0 str x0, [sp, #120]
4002c6d0: b9401860 ldr w0, [x3, #24]
4002c6d4: a9025bf5 stp x21, x22, [sp, #32]
4002c6d8: a90363f7 stp x23, x24, [sp, #48]
4002c6dc: a9046bf9 stp x25, x26, [sp, #64]
4002c6e0: a90573fb stp x27, x28, [sp, #80]
4002c6e4: aa0103fb mov x27, x1
4002c6e8: b90093e0 str w0, [sp, #144]
char padc;
int stop = 0, retval = 0;
num = 0;
if (fmt == NULL)
4002c6ec: b4000942 cbz x2, 4002c814 <_IO_Vprintf+0x164> <== NEVER TAKEN
fmt = "(fmt null)\n";
for (;;) {
padc = ' ';
width = 0;
while ((ch = (u_char)*fmt++) != '%' || stop) {
4002c6f0: 39400040 ldrb w0, [x2]
4002c6f4: aa0203f4 mov x20, x2
4002c6f8: b0000099 adrp x25, 4003d000 <access_modes_assoc+0x10>
4002c6fc: 91394321 add x1, x25, #0xe50
width -= n;
if (!ladjust && width > 0)
while (width--)
PCHAR(padc);
while (n--)
4002c700: 52800015 mov w21, #0x0 // #0
4002c704: 52800019 mov w25, #0x0 // #0
4002c708: f90043e1 str x1, [sp, #128]
4002c70c: b0000097 adrp x23, 4003d000 <access_modes_assoc+0x10>
4002c710: 913c02e1 add x1, x23, #0xf00
4002c714: f9003be1 str x1, [sp, #112]
while ((ch = (u_char)*fmt++) != '%' || stop) {
4002c718: aa1403f6 mov x22, x20
4002c71c: 4b140339 sub w25, w25, w20
4002c720: 14000006 b 4002c738 <_IO_Vprintf+0x88>
if (ch == '\0')
4002c724: 34000440 cbz w0, 4002c7ac <_IO_Vprintf+0xfc>
PCHAR(ch);
4002c728: aa1b03e1 mov x1, x27
4002c72c: d63f0260 blr x19
while ((ch = (u_char)*fmt++) != '%' || stop) {
4002c730: 394002e0 ldrb w0, [x23]
4002c734: aa1703f6 mov x22, x23
4002c738: 7100941f cmp w0, #0x25
4002c73c: 0b16033c add w28, w25, w22
4002c740: 910006d7 add x23, x22, #0x1
4002c744: 54ffff01 b.ne 4002c724 <_IO_Vprintf+0x74> // b.any
4002c748: 35ffff15 cbnz w21, 4002c728 <_IO_Vprintf+0x78> <== NEVER TAKEN
reswitch: switch (ch = (u_char)*fmt++) {
4002c74c: 394006c0 ldrb w0, [x22, #1]
sign = 0; dot = 0; dwidth = 0; upper = 0;
4002c750: 5280000a mov w10, #0x0 // #0
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
4002c754: 52800019 mov w25, #0x0 // #0
4002c758: 5280000b mov w11, #0x0 // #0
4002c75c: 5280000d mov w13, #0x0 // #0
sign = 0; dot = 0; dwidth = 0; upper = 0;
4002c760: 5280000e mov w14, #0x0 // #0
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
4002c764: 5280000c mov w12, #0x0 // #0
width = 0;
4002c768: 52800008 mov w8, #0x0 // #0
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
4002c76c: 52800007 mov w7, #0x0 // #0
padc = ' ';
4002c770: 52800418 mov w24, #0x20 // #32
n = n * 10 + ch - '0';
4002c774: 52800146 mov w6, #0xa // #10
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
4002c778: b9008bff str wzr, [sp, #136]
reswitch: switch (ch = (u_char)*fmt++) {
4002c77c: 51008c04 sub w4, w0, #0x23
4002c780: 910006f4 add x20, x23, #0x1
4002c784: 71015c9f cmp w4, #0x57
4002c788: 540003c9 b.ls 4002c800 <_IO_Vprintf+0x150> // b.plast <== ALWAYS TAKEN
while (width-- > 0)
PCHAR(' ');
break;
default:
while (percent < fmt)
4002c78c: eb1402df cmp x22, x20
4002c790: aa1603f5 mov x21, x22
4002c794: 528004a0 mov w0, #0x25 // #37
4002c798: 540001c3 b.cc 4002c7d0 <_IO_Vprintf+0x120> // b.lo, b.ul, b.last <== ALWAYS TAKEN
4002c79c: 2a1c03f9 mov w25, w28 <== NOT EXECUTED
* Since we ignore a formatting argument it is no
* longer safe to obey the remaining formatting
* arguments as the arguments will no longer match
* the format specs.
*/
stop = 1;
4002c7a0: 52800035 mov w21, #0x1 // #1 <== NOT EXECUTED
while ((ch = (u_char)*fmt++) != '%' || stop) {
4002c7a4: 394006e0 ldrb w0, [x23, #1]
4002c7a8: 17ffffdc b 4002c718 <_IO_Vprintf+0x68>
break;
}
}
#undef PCHAR
}
4002c7ac: 2a1c03e0 mov w0, w28
4002c7b0: a94153f3 ldp x19, x20, [sp, #16]
4002c7b4: a9425bf5 ldp x21, x22, [sp, #32]
4002c7b8: a94363f7 ldp x23, x24, [sp, #48]
4002c7bc: a9446bf9 ldp x25, x26, [sp, #64]
4002c7c0: a94573fb ldp x27, x28, [sp, #80]
4002c7c4: a8cc7bfd ldp x29, x30, [sp], #192
4002c7c8: d65f03c0 ret
PCHAR(*percent++);
4002c7cc: 394002a0 ldrb w0, [x21]
4002c7d0: 910006b5 add x21, x21, #0x1
4002c7d4: aa1b03e1 mov x1, x27
4002c7d8: d63f0260 blr x19
while (percent < fmt)
4002c7dc: eb15029f cmp x20, x21
4002c7e0: 54ffff61 b.ne 4002c7cc <_IO_Vprintf+0x11c> // b.any
PCHAR(*percent++);
4002c7e4: aa3603e0 mvn x0, x22
4002c7e8: 11000783 add w3, w28, #0x1
4002c7ec: 8b000280 add x0, x20, x0
stop = 1;
4002c7f0: 52800035 mov w21, #0x1 // #1
PCHAR(*percent++);
4002c7f4: 0b000079 add w25, w3, w0
while ((ch = (u_char)*fmt++) != '%' || stop) {
4002c7f8: 394006e0 ldrb w0, [x23, #1]
4002c7fc: 17ffffc7 b 4002c718 <_IO_Vprintf+0x68>
4002c800: f94043e1 ldr x1, [sp, #128]
4002c804: 78645821 ldrh w1, [x1, w4, uxtw #1]
4002c808: 10000062 adr x2, 4002c814 <_IO_Vprintf+0x164>
4002c80c: 8b21a841 add x1, x2, w1, sxth #2
4002c810: d61f0020 br x1
fmt = "(fmt null)\n";
4002c814: b0000094 adrp x20, 4003d000 <access_modes_assoc+0x10> <== NOT EXECUTED
4002c818: 9138e294 add x20, x20, #0xe38 <== NOT EXECUTED
4002c81c: 52800500 mov w0, #0x28 // #40 <== NOT EXECUTED
4002c820: 17ffffb6 b 4002c6f8 <_IO_Vprintf+0x48> <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
4002c824: 394006e0 ldrb w0, [x23, #1]
zflag = 1;
4002c828: 52800027 mov w7, #0x1 // #1
reswitch: switch (ch = (u_char)*fmt++) {
4002c82c: aa1403f7 mov x23, x20
goto reswitch;
4002c830: 17ffffd3 b 4002c77c <_IO_Vprintf+0xcc>
if (!dot) {
4002c834: 35004aee cbnz w14, 4002d190 <_IO_Vprintf+0xae0> <== NEVER TAKEN
padc = '0';
4002c838: 2a0003f8 mov w24, w0
reswitch: switch (ch = (u_char)*fmt++) {
4002c83c: 394006e0 ldrb w0, [x23, #1]
4002c840: aa1403f7 mov x23, x20
4002c844: 17ffffce b 4002c77c <_IO_Vprintf+0xcc>
n = n * 10 + ch - '0';
4002c848: 5100c004 sub w4, w0, #0x30
ch = *fmt;
4002c84c: 394006e0 ldrb w0, [x23, #1]
if (ch < '0' || ch > '9')
4002c850: 5100c002 sub w2, w0, #0x30
ch = *fmt;
4002c854: 2a0003e5 mov w5, w0
if (ch < '0' || ch > '9')
4002c858: 7100245f cmp w2, #0x9
4002c85c: 54002e68 b.hi 4002ce28 <_IO_Vprintf+0x778> // b.pmore
reswitch: switch (ch = (u_char)*fmt++) {
4002c860: aa1403f7 mov x23, x20
4002c864: d503201f nop
n = n * 10 + ch - '0';
4002c868: 1b061484 madd w4, w4, w6, w5
ch = *fmt;
4002c86c: 38401ee5 ldrb w5, [x23, #1]!
if (ch < '0' || ch > '9')
4002c870: 5100c0a0 sub w0, w5, #0x30
n = n * 10 + ch - '0';
4002c874: 5100c084 sub w4, w4, #0x30
if (ch < '0' || ch > '9')
4002c878: 7100241f cmp w0, #0x9
ch = *fmt;
4002c87c: 2a0503e0 mov w0, w5
if (ch < '0' || ch > '9')
4002c880: 54ffff49 b.ls 4002c868 <_IO_Vprintf+0x1b8> // b.plast <== NEVER TAKEN
if (dot)
4002c884: 710001df cmp w14, #0x0
4002c888: 1a841108 csel w8, w8, w4, ne // ne = any
4002c88c: 1a8a108a csel w10, w4, w10, ne // ne = any
4002c890: 17ffffbb b 4002c77c <_IO_Vprintf+0xcc>
reswitch: switch (ch = (u_char)*fmt++) {
4002c894: d2800144 mov x4, #0xa // #10
base = 10;
4002c898: b9009fe4 str w4, [sp, #156]
num = va_arg(ap, intmax_t);
4002c89c: b94093e0 ldr w0, [sp, #144]
if (jflag)
4002c8a0: 35003099 cbnz w25, 4002ceb0 <_IO_Vprintf+0x800>
else if (tflag)
4002c8a4: 35003067 cbnz w7, 4002ceb0 <_IO_Vprintf+0x800>
else if (hflag)
4002c8a8: 3400482b cbz w11, 4002d1ac <_IO_Vprintf+0xafc> <== ALWAYS TAKEN
num = (short)va_arg(ap, int);
4002c8ac: 37f85320 tbnz w0, #31, 4002d310 <_IO_Vprintf+0xc60> <== NOT EXECUTED
4002c8b0: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002c8b4: 91002c05 add x5, x0, #0xb <== NOT EXECUTED
4002c8b8: 927df0a1 and x1, x5, #0xfffffffffffffff8 <== NOT EXECUTED
4002c8bc: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002c8c0: 7980000d ldrsh x13, [x0] <== NOT EXECUTED
if (sign && (intmax_t)num < 0) {
4002c8c4: aa0d03e0 mov x0, x13 <== NOT EXECUTED
4002c8c8: b6f86200 tbz x0, #63, 4002d508 <_IO_Vprintf+0xe58>
num = -(intmax_t)num;
4002c8cc: cb0003ed neg x13, x0
neg = 1;
4002c8d0: 52800039 mov w25, #0x1 // #1
num = -(intmax_t)num;
4002c8d4: 52800000 mov w0, #0x0 // #0
*++p = hex2ascii_data[upper][num % base];
4002c8d8: f9403be1 ldr x1, [sp, #112]
4002c8dc: d37c0000 ubfiz x0, x0, #4, #1
p = nbuf;
4002c8e0: 9102a3eb add x11, sp, #0xa8
*p = '\0';
4002c8e4: 3902a3ff strb wzr, [sp, #168]
*++p = hex2ascii_data[upper][num % base];
4002c8e8: 8b000027 add x7, x1, x0
p = nbuf;
4002c8ec: aa0b03f6 mov x22, x11
*p = '\0';
4002c8f0: aa0d03e0 mov x0, x13
4002c8f4: d503201f nop
*++p = hex2ascii_data[upper][num % base];
4002c8f8: 9ac40805 udiv x5, x0, x4
} while (num /= base);
4002c8fc: eb00009f cmp x4, x0
*++p = hex2ascii_data[upper][num % base];
4002c900: 9b0480a6 msub x6, x5, x4, x0
} while (num /= base);
4002c904: aa0503e0 mov x0, x5
*++p = hex2ascii_data[upper][num % base];
4002c908: 386668fa ldrb w26, [x7, x6]
4002c90c: 38001eda strb w26, [x22, #1]!
} while (num /= base);
4002c910: 54ffff49 b.ls 4002c8f8 <_IO_Vprintf+0x248> // b.plast
if (sharpflag && num != 0) {
4002c914: f10001bf cmp x13, #0x0
*lenp = p - nbuf;
4002c918: cb0b02c0 sub x0, x22, x11
if (sharpflag && num != 0) {
4002c91c: 1a9f07e5 cset w5, ne // ne = any
tmp = 0;
4002c920: 52800004 mov w4, #0x0 // #0
if (sharpflag && num != 0) {
4002c924: 6a050181 ands w1, w12, w5
4002c928: b9009be1 str w1, [sp, #152]
4002c92c: 54000100 b.eq 4002c94c <_IO_Vprintf+0x29c> // b.none
if (base == 8)
4002c930: b9409fe1 ldr w1, [sp, #156]
tmp++;
4002c934: 52800024 mov w4, #0x1 // #1
if (base == 8)
4002c938: 7100203f cmp w1, #0x8
4002c93c: 54000080 b.eq 4002c94c <_IO_Vprintf+0x29c> // b.none <== NEVER TAKEN
tmp = 0;
4002c940: 7100403f cmp w1, #0x10
4002c944: 1a9f17e4 cset w4, eq // eq = none
4002c948: 531f7884 lsl w4, w4, #1
tmp++;
4002c94c: 7100033f cmp w25, #0x0
if (!ladjust && padc == '0')
4002c950: b9408be1 ldr w1, [sp, #136]
tmp++;
4002c954: 1a840484 cinc w4, w4, ne // ne = any
if (!ladjust && padc == '0')
4002c958: 7100c31f cmp w24, #0x30
4002c95c: 1a9f17e7 cset w7, eq // eq = none
4002c960: 52000025 eor w5, w1, #0x1
4002c964: 6a0700bf tst w5, w7
4002c968: 54002640 b.eq 4002ce30 <_IO_Vprintf+0x780> // b.none
dwidth = width - tmp;
4002c96c: 4b040105 sub w5, w8, w4
dwidth -= n;
4002c970: 6b0000a1 subs w1, w5, w0
4002c974: b90097e1 str w1, [sp, #148]
static inline int imax(int a, int b) { return (a > b ? a : b); }
4002c978: 1a80a0b8 csel w24, w5, w0, ge // ge = tcont
width -= tmp + imax(dwidth, n);
4002c97c: 0b040318 add w24, w24, w4
4002c980: 4b180100 sub w0, w8, w24
4002c984: b9006be0 str w0, [sp, #104]
while (width-- > 0)
4002c988: b9406be0 ldr w0, [sp, #104]
4002c98c: 51000418 sub w24, w0, #0x1
4002c990: b9006bf8 str w24, [sp, #104]
4002c994: 7100001f cmp w0, #0x0
4002c998: 540001ad b.le 4002c9cc <_IO_Vprintf+0x31c>
4002c99c: d503201f nop
4002c9a0: b9406be0 ldr w0, [sp, #104]
PCHAR(' ');
4002c9a4: aa1b03e1 mov x1, x27
while (width-- > 0)
4002c9a8: 51000400 sub w0, w0, #0x1
4002c9ac: b9006be0 str w0, [sp, #104]
PCHAR(' ');
4002c9b0: 52800400 mov w0, #0x20 // #32
4002c9b4: d63f0260 blr x19
while (width-- > 0)
4002c9b8: b9406be0 ldr w0, [sp, #104]
4002c9bc: 3100041f cmn w0, #0x1
4002c9c0: 54ffff01 b.ne 4002c9a0 <_IO_Vprintf+0x2f0> // b.any
PCHAR(' ');
4002c9c4: 11000783 add w3, w28, #0x1
4002c9c8: 0b18007c add w28, w3, w24
if (neg)
4002c9cc: 340000b9 cbz w25, 4002c9e0 <_IO_Vprintf+0x330>
PCHAR('-');
4002c9d0: 1100079c add w28, w28, #0x1
4002c9d4: aa1b03e1 mov x1, x27
4002c9d8: 528005a0 mov w0, #0x2d // #45
4002c9dc: d63f0260 blr x19
if (sharpflag && num != 0) {
4002c9e0: b9409be0 ldr w0, [sp, #152]
4002c9e4: 340001e0 cbz w0, 4002ca20 <_IO_Vprintf+0x370>
if (base == 8) {
4002c9e8: b9409fe0 ldr w0, [sp, #156]
4002c9ec: 7100201f cmp w0, #0x8
4002c9f0: 54002700 b.eq 4002ced0 <_IO_Vprintf+0x820> // b.none <== NEVER TAKEN
} else if (base == 16) {
4002c9f4: b9409fe0 ldr w0, [sp, #156]
4002c9f8: 7100401f cmp w0, #0x10
4002c9fc: 54000121 b.ne 4002ca20 <_IO_Vprintf+0x370> // b.any <== NEVER TAKEN
PCHAR('0');
4002ca00: aa1b03e1 mov x1, x27
4002ca04: 52800600 mov w0, #0x30 // #48
4002ca08: d63f0260 blr x19
PCHAR('x');
4002ca0c: 11000b9c add w28, w28, #0x2
4002ca10: aa1b03e1 mov x1, x27
4002ca14: 52800f00 mov w0, #0x78 // #120
4002ca18: d63f0260 blr x19
4002ca1c: d503201f nop
while (dwidth-- > 0)
4002ca20: b94097e0 ldr w0, [sp, #148]
4002ca24: 7100001f cmp w0, #0x0
4002ca28: 51000418 sub w24, w0, #0x1
4002ca2c: 5400016d b.le 4002ca58 <_IO_Vprintf+0x3a8>
4002ca30: 2a1803f9 mov w25, w24
4002ca34: d503201f nop
4002ca38: 51000739 sub w25, w25, #0x1
PCHAR('0');
4002ca3c: aa1b03e1 mov x1, x27
4002ca40: 52800600 mov w0, #0x30 // #48
4002ca44: d63f0260 blr x19
while (dwidth-- > 0)
4002ca48: 3100073f cmn w25, #0x1
4002ca4c: 54ffff61 b.ne 4002ca38 <_IO_Vprintf+0x388> // b.any
4002ca50: 11000783 add w3, w28, #0x1
PCHAR('0');
4002ca54: 0b03031c add w28, w24, w3
while (*p)
4002ca58: 340026da cbz w26, 4002cf30 <_IO_Vprintf+0x880> <== NEVER TAKEN
*++p = hex2ascii_data[upper][num % base];
4002ca5c: aa1603f8 mov x24, x22
PCHAR(*p--);
4002ca60: d1000718 sub x24, x24, #0x1
4002ca64: 2a1a03e0 mov w0, w26
4002ca68: aa1b03e1 mov x1, x27
4002ca6c: d63f0260 blr x19
4002ca70: 4b1802c4 sub w4, w22, w24
while (*p)
4002ca74: 3940031a ldrb w26, [x24]
4002ca78: 0b1c0099 add w25, w4, w28
4002ca7c: 35ffff3a cbnz w26, 4002ca60 <_IO_Vprintf+0x3b0>
if (ladjust)
4002ca80: b9408be0 ldr w0, [sp, #136]
4002ca84: 35001f80 cbnz w0, 4002ce74 <_IO_Vprintf+0x7c4>
while ((ch = (u_char)*fmt++) != '%' || stop) {
4002ca88: 394006e0 ldrb w0, [x23, #1]
4002ca8c: 52800015 mov w21, #0x0 // #0
4002ca90: 17ffff22 b 4002c718 <_IO_Vprintf+0x68>
PCHAR(ch);
4002ca94: 528004a0 mov w0, #0x25 // #37
4002ca98: aa1b03e1 mov x1, x27
4002ca9c: d63f0260 blr x19
4002caa0: 11000799 add w25, w28, #0x1
while ((ch = (u_char)*fmt++) != '%' || stop) {
4002caa4: 394006e0 ldrb w0, [x23, #1]
4002caa8: 17ffff1c b 4002c718 <_IO_Vprintf+0x68>
num = (uintptr_t)va_arg(ap, void *);
4002caac: b94093e0 ldr w0, [sp, #144]
sharpflag = (width == 0);
4002cab0: 7100011f cmp w8, #0x0
4002cab4: 1a9f17ec cset w12, eq // eq = none
num = (uintptr_t)va_arg(ap, void *);
4002cab8: 37f82d80 tbnz w0, #31, 4002d068 <_IO_Vprintf+0x9b8> <== ALWAYS TAKEN
4002cabc: f94033e5 ldr x5, [sp, #96] <== NOT EXECUTED
4002cac0: 91003ca0 add x0, x5, #0xf <== NOT EXECUTED
4002cac4: 927df000 and x0, x0, #0xfffffffffffffff8 <== NOT EXECUTED
4002cac8: f90033e0 str x0, [sp, #96] <== NOT EXECUTED
goto number;
4002cacc: d2800204 mov x4, #0x10 // #16
base = 16;
4002cad0: b9009fe4 str w4, [sp, #156]
sign = 0; dot = 0; dwidth = 0; upper = 0;
4002cad4: 52800000 mov w0, #0x0 // #0
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
4002cad8: 52800019 mov w25, #0x0 // #0
num = (uintptr_t)va_arg(ap, void *);
4002cadc: f94000ad ldr x13, [x5]
goto number;
4002cae0: 17ffff7e b 4002c8d8 <_IO_Vprintf+0x228>
p = va_arg(ap, char *);
4002cae4: b94093e0 ldr w0, [sp, #144]
4002cae8: 37f82900 tbnz w0, #31, 4002d008 <_IO_Vprintf+0x958>
4002caec: f94033e0 ldr x0, [sp, #96]
4002caf0: 91003c04 add x4, x0, #0xf
4002caf4: 927df081 and x1, x4, #0xfffffffffffffff8
4002caf8: f90033e1 str x1, [sp, #96]
4002cafc: f9400019 ldr x25, [x0]
p = "(null)";
4002cb00: b0000080 adrp x0, 4003d000 <access_modes_assoc+0x10>
4002cb04: 91392000 add x0, x0, #0xe48
if (!ladjust && width > 0)
4002cb08: b9408be1 ldr w1, [sp, #136]
p = "(null)";
4002cb0c: f100033f cmp x25, #0x0
if (!ladjust && width > 0)
4002cb10: 52000036 eor w22, w1, #0x1
p = "(null)";
4002cb14: 9a990019 csel x25, x0, x25, eq // eq = none
if (!ladjust && width > 0)
4002cb18: 120002d6 and w22, w22, #0x1
if (!dot)
4002cb1c: 3500304e cbnz w14, 4002d124 <_IO_Vprintf+0xa74>
n = strlen (p);
4002cb20: aa1903e0 mov x0, x25
4002cb24: b9006be8 str w8, [sp, #104]
4002cb28: 94000a9c bl 4002f598 <strlen>
4002cb2c: 2a0003e5 mov w5, w0
4002cb30: b9406be8 ldr w8, [sp, #104]
width -= n;
4002cb34: 4b050108 sub w8, w8, w5
while (n--)
4002cb38: 510004a0 sub w0, w5, #0x1
if (!ladjust && width > 0)
4002cb3c: 7100011f cmp w8, #0x0
while (n--)
4002cb40: b90097e0 str w0, [sp, #148]
if (!ladjust && width > 0)
4002cb44: 1a9fd7e0 cset w0, gt
4002cb48: 7100001f cmp w0, #0x0
4002cb4c: 7a401ac4 ccmp w22, #0x0, #0x4, ne // ne = any
4002cb50: 540034a1 b.ne 4002d1e4 <_IO_Vprintf+0xb34> // b.any
if (ladjust && width > 0)
4002cb54: b9408be1 ldr w1, [sp, #136]
4002cb58: 0a000020 and w0, w1, w0
4002cb5c: 2a0003fa mov w26, w0
while (n--)
4002cb60: 34004445 cbz w5, 4002d3e8 <_IO_Vprintf+0xd38>
4002cb64: b94097f6 ldr w22, [sp, #148]
4002cb68: 910006d6 add x22, x22, #0x1
4002cb6c: 8b160336 add x22, x25, x22
PCHAR(*p++);
4002cb70: 38401720 ldrb w0, [x25], #1
4002cb74: aa1b03e1 mov x1, x27
4002cb78: b9006be8 str w8, [sp, #104]
4002cb7c: d63f0260 blr x19
while (n--)
4002cb80: b9406be8 ldr w8, [sp, #104]
4002cb84: eb1902df cmp x22, x25
4002cb88: 54ffff41 b.ne 4002cb70 <_IO_Vprintf+0x4c0> // b.any
PCHAR(*p++);
4002cb8c: b94097e0 ldr w0, [sp, #148]
4002cb90: 11000783 add w3, w28, #0x1
4002cb94: 0b030019 add w25, w0, w3
if (ladjust && width > 0)
4002cb98: 34ffe07a cbz w26, 4002c7a4 <_IO_Vprintf+0xf4>
while (width--)
4002cb9c: 51000516 sub w22, w8, #0x1
4002cba0: 2a0803fa mov w26, w8
PCHAR(padc);
4002cba4: aa1b03e1 mov x1, x27
4002cba8: 2a1803e0 mov w0, w24
4002cbac: d63f0260 blr x19
while (width--)
4002cbb0: 7100075a subs w26, w26, #0x1
4002cbb4: 54ffff81 b.ne 4002cba4 <_IO_Vprintf+0x4f4> // b.any
4002cbb8: 11000724 add w4, w25, #0x1
while ((ch = (u_char)*fmt++) != '%' || stop) {
4002cbbc: 394006e0 ldrb w0, [x23, #1]
PCHAR(padc);
4002cbc0: 0b160099 add w25, w4, w22
4002cbc4: 17fffed5 b 4002c718 <_IO_Vprintf+0x68>
up = va_arg(ap, u_char *);
4002cbc8: b94093e0 ldr w0, [sp, #144] <== NOT EXECUTED
4002cbcc: 37f81f60 tbnz w0, #31, 4002cfb8 <_IO_Vprintf+0x908> <== NOT EXECUTED
4002cbd0: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002cbd4: 91003c00 add x0, x0, #0xf <== NOT EXECUTED
4002cbd8: 927df000 and x0, x0, #0xfffffffffffffff8 <== NOT EXECUTED
4002cbdc: f94033e1 ldr x1, [sp, #96] <== NOT EXECUTED
4002cbe0: f9400036 ldr x22, [x1] <== NOT EXECUTED
p = va_arg(ap, char *);
4002cbe4: 91003c1a add x26, x0, #0xf <== NOT EXECUTED
4002cbe8: 927df341 and x1, x26, #0xfffffffffffffff8 <== NOT EXECUTED
4002cbec: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002cbf0: f9400001 ldr x1, [x0] <== NOT EXECUTED
while(width--) {
4002cbf4: 7100011f cmp w8, #0x0 <== NOT EXECUTED
4002cbf8: 51000500 sub w0, w8, #0x1 <== NOT EXECUTED
4002cbfc: 528001e4 mov w4, #0xf // #15 <== NOT EXECUTED
4002cc00: 52800078 mov w24, #0x3 // #3 <== NOT EXECUTED
4002cc04: 1a841000 csel w0, w0, w4, ne // ne = any <== NOT EXECUTED
4002cc08: 4b010318 sub w24, w24, w1 <== NOT EXECUTED
4002cc0c: 8b0002c0 add x0, x22, x0 <== NOT EXECUTED
4002cc10: f90037e0 str x0, [sp, #104] <== NOT EXECUTED
p = va_arg(ap, char *);
4002cc14: f90047e1 str x1, [sp, #136] <== NOT EXECUTED
PCHAR(hex2ascii(*up >> 4));
4002cc18: 394002c0 ldrb w0, [x22] <== NOT EXECUTED
4002cc1c: aa1b03e1 mov x1, x27 <== NOT EXECUTED
4002cc20: f9403bfa ldr x26, [sp, #112] <== NOT EXECUTED
PCHAR(hex2ascii(*up & 0x0f));
4002cc24: 11000b99 add w25, w28, #0x2 <== NOT EXECUTED
PCHAR(hex2ascii(*up >> 4));
4002cc28: d3441c00 ubfx x0, x0, #4, #4 <== NOT EXECUTED
4002cc2c: 387a6800 ldrb w0, [x0, x26] <== NOT EXECUTED
4002cc30: d63f0260 blr x19 <== NOT EXECUTED
PCHAR(hex2ascii(*up & 0x0f));
4002cc34: 394002c0 ldrb w0, [x22] <== NOT EXECUTED
4002cc38: aa1b03e1 mov x1, x27 <== NOT EXECUTED
4002cc3c: 92400c00 and x0, x0, #0xf <== NOT EXECUTED
4002cc40: 387a6800 ldrb w0, [x0, x26] <== NOT EXECUTED
4002cc44: d63f0260 blr x19 <== NOT EXECUTED
if (width)
4002cc48: f94037e0 ldr x0, [sp, #104] <== NOT EXECUTED
4002cc4c: eb16001f cmp x0, x22 <== NOT EXECUTED
4002cc50: 54ffdaa0 b.eq 4002c7a4 <_IO_Vprintf+0xf4> // b.none <== NOT EXECUTED
for (q=p;*q;q++)
4002cc54: f94047fa ldr x26, [sp, #136] <== NOT EXECUTED
4002cc58: 39400340 ldrb w0, [x26] <== NOT EXECUTED
4002cc5c: 340000e0 cbz w0, 4002cc78 <_IO_Vprintf+0x5c8> <== NOT EXECUTED
PCHAR(*q);
4002cc60: aa1b03e1 mov x1, x27 <== NOT EXECUTED
4002cc64: d63f0260 blr x19 <== NOT EXECUTED
4002cc68: 0b1a0384 add w4, w28, w26 <== NOT EXECUTED
for (q=p;*q;q++)
4002cc6c: 38401f40 ldrb w0, [x26, #1]! <== NOT EXECUTED
4002cc70: 0b040319 add w25, w24, w4 <== NOT EXECUTED
4002cc74: 35ffff60 cbnz w0, 4002cc60 <_IO_Vprintf+0x5b0> <== NOT EXECUTED
up++;
4002cc78: 910006d6 add x22, x22, #0x1 <== NOT EXECUTED
4002cc7c: 2a1903fc mov w28, w25 <== NOT EXECUTED
4002cc80: 17ffffe6 b 4002cc18 <_IO_Vprintf+0x568> <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
4002cc84: d2800204 mov x4, #0x10 // #16
upper = 1;
4002cc88: 52800020 mov w0, #0x1 // #1
base = 16;
4002cc8c: b9009fe4 str w4, [sp, #156]
num = va_arg(ap, uintmax_t);
4002cc90: b94093e1 ldr w1, [sp, #144]
if (jflag)
4002cc94: 34000e19 cbz w25, 4002ce54 <_IO_Vprintf+0x7a4>
num = va_arg(ap, uintmax_t);
4002cc98: 37f81381 tbnz w1, #31, 4002cf08 <_IO_Vprintf+0x858> <== ALWAYS TAKEN
4002cc9c: f94033e5 ldr x5, [sp, #96] <== NOT EXECUTED
4002cca0: 91003ca6 add x6, x5, #0xf <== NOT EXECUTED
4002cca4: 927df0c1 and x1, x6, #0xfffffffffffffff8 <== NOT EXECUTED
4002cca8: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
4002ccac: 52800019 mov w25, #0x0 // #0
num = va_arg(ap, uintmax_t);
4002ccb0: f94000ad ldr x13, [x5]
4002ccb4: 17ffff09 b 4002c8d8 <_IO_Vprintf+0x228>
if (!ladjust && width > 0)
4002ccb8: b9408be0 ldr w0, [sp, #136]
4002ccbc: 7100051f cmp w8, #0x1
4002ccc0: 1a9fd7f6 cset w22, gt
4002ccc4: 52000000 eor w0, w0, #0x1
4002ccc8: 6a16001f tst w0, w22
4002cccc: 54002001 b.ne 4002d0cc <_IO_Vprintf+0xa1c> // b.any <== NEVER TAKEN
PCHAR(va_arg(ap, int));
4002ccd0: b94093e0 ldr w0, [sp, #144]
4002ccd4: 37f81e80 tbnz w0, #31, 4002d0a4 <_IO_Vprintf+0x9f4> <== ALWAYS TAKEN
4002ccd8: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002ccdc: 91002c04 add x4, x0, #0xb <== NOT EXECUTED
4002cce0: 927df081 and x1, x4, #0xfffffffffffffff8 <== NOT EXECUTED
4002cce4: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002cce8: b9400000 ldr w0, [x0]
4002ccec: aa1b03e1 mov x1, x27
4002ccf0: b9006be8 str w8, [sp, #104]
4002ccf4: 11000799 add w25, w28, #0x1
4002ccf8: d63f0260 blr x19
if (ladjust && width > 0)
4002ccfc: b9408be0 ldr w0, [sp, #136]
4002cd00: b9406be8 ldr w8, [sp, #104]
4002cd04: 6a16001f tst w0, w22
4002cd08: 54ffd4e0 b.eq 4002c7a4 <_IO_Vprintf+0xf4> // b.none <== ALWAYS TAKEN
while (width--)
4002cd0c: 51000919 sub w25, w8, #0x2 <== NOT EXECUTED
4002cd10: 51000916 sub w22, w8, #0x2 <== NOT EXECUTED
PCHAR(padc);
4002cd14: d280001a mov x26, #0x0 // #0 <== NOT EXECUTED
PCHAR(padc);
4002cd18: aa1b03e1 mov x1, x27 <== NOT EXECUTED
4002cd1c: 2a1803e0 mov w0, w24 <== NOT EXECUTED
4002cd20: d63f0260 blr x19 <== NOT EXECUTED
while (width--)
4002cd24: eb16035f cmp x26, x22 <== NOT EXECUTED
4002cd28: 9100075a add x26, x26, #0x1 <== NOT EXECUTED
4002cd2c: 54ffff61 b.ne 4002cd18 <_IO_Vprintf+0x668> // b.any <== NOT EXECUTED
PCHAR(padc);
4002cd30: 11000b83 add w3, w28, #0x2 <== NOT EXECUTED
while ((ch = (u_char)*fmt++) != '%' || stop) {
4002cd34: 394006e0 ldrb w0, [x23, #1] <== NOT EXECUTED
PCHAR(padc);
4002cd38: 0b190079 add w25, w3, w25 <== NOT EXECUTED
4002cd3c: 17fffe77 b 4002c718 <_IO_Vprintf+0x68> <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
4002cd40: 394006e0 ldrb w0, [x23, #1] <== NOT EXECUTED
sharpflag = 1;
4002cd44: 5280002c mov w12, #0x1 // #1 <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
4002cd48: aa1403f7 mov x23, x20 <== NOT EXECUTED
goto reswitch;
4002cd4c: 17fffe8c b 4002c77c <_IO_Vprintf+0xcc> <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
4002cd50: 394006e0 ldrb w0, [x23, #1]
if (hflag) {
4002cd54: 3500106b cbnz w11, 4002cf60 <_IO_Vprintf+0x8b0>
reswitch: switch (ch = (u_char)*fmt++) {
4002cd58: aa1403f7 mov x23, x20
hflag = 1;
4002cd5c: 5280002b mov w11, #0x1 // #1
4002cd60: 17fffe87 b 4002c77c <_IO_Vprintf+0xcc>
reswitch: switch (ch = (u_char)*fmt++) {
4002cd64: 394006e0 ldrb w0, [x23, #1]
jflag = 1;
4002cd68: 52800039 mov w25, #0x1 // #1
reswitch: switch (ch = (u_char)*fmt++) {
4002cd6c: aa1403f7 mov x23, x20
goto reswitch;
4002cd70: 17fffe83 b 4002c77c <_IO_Vprintf+0xcc>
width = va_arg(ap, int);
4002cd74: b94093e0 ldr w0, [sp, #144]
if (!dot) {
4002cd78: 350010ee cbnz w14, 4002cf94 <_IO_Vprintf+0x8e4> <== ALWAYS TAKEN
width = va_arg(ap, int);
4002cd7c: 37f826e0 tbnz w0, #31, 4002d258 <_IO_Vprintf+0xba8> <== NOT EXECUTED
4002cd80: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002cd84: 91002c04 add x4, x0, #0xb <== NOT EXECUTED
4002cd88: 927df081 and x1, x4, #0xfffffffffffffff8 <== NOT EXECUTED
4002cd8c: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002cd90: b9400008 ldr w8, [x0] <== NOT EXECUTED
if (width < 0) {
4002cd94: 36ffd548 tbz w8, #31, 4002c83c <_IO_Vprintf+0x18c> <== NOT EXECUTED
ladjust = !ladjust;
4002cd98: b9408be1 ldr w1, [sp, #136] <== NOT EXECUTED
width = -width;
4002cd9c: 4b0803e8 neg w8, w8 <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
4002cda0: 394006e0 ldrb w0, [x23, #1] <== NOT EXECUTED
4002cda4: aa1403f7 mov x23, x20 <== NOT EXECUTED
4002cda8: 52000021 eor w1, w1, #0x1 <== NOT EXECUTED
4002cdac: b9008be1 str w1, [sp, #136] <== NOT EXECUTED
width = -width;
4002cdb0: 17fffe73 b 4002c77c <_IO_Vprintf+0xcc> <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
4002cdb4: 394006e0 ldrb w0, [x23, #1]
ladjust = 1;
4002cdb8: 52800021 mov w1, #0x1 // #1
reswitch: switch (ch = (u_char)*fmt++) {
4002cdbc: aa1403f7 mov x23, x20
ladjust = 1;
4002cdc0: b9008be1 str w1, [sp, #136]
goto reswitch;
4002cdc4: 17fffe6e b 4002c77c <_IO_Vprintf+0xcc>
reswitch: switch (ch = (u_char)*fmt++) {
4002cdc8: 394006e0 ldrb w0, [x23, #1]
dot = 1;
4002cdcc: 5280002e mov w14, #0x1 // #1
reswitch: switch (ch = (u_char)*fmt++) {
4002cdd0: aa1403f7 mov x23, x20
4002cdd4: 17fffe6a b 4002c77c <_IO_Vprintf+0xcc>
if (lflag) {
4002cdd8: 34ffd267 cbz w7, 4002c824 <_IO_Vprintf+0x174>
reswitch: switch (ch = (u_char)*fmt++) {
4002cddc: 394006e0 ldrb w0, [x23, #1]
jflag = 1;
4002cde0: 2a0703f9 mov w25, w7
reswitch: switch (ch = (u_char)*fmt++) {
4002cde4: aa1403f7 mov x23, x20
4002cde8: 17fffe65 b 4002c77c <_IO_Vprintf+0xcc>
4002cdec: d2800104 mov x4, #0x8 // #8
sign = 0; dot = 0; dwidth = 0; upper = 0;
4002cdf0: 52800000 mov w0, #0x0 // #0
base = 8;
4002cdf4: b9009fe4 str w4, [sp, #156]
4002cdf8: 17ffffa6 b 4002cc90 <_IO_Vprintf+0x5e0>
reswitch: switch (ch = (u_char)*fmt++) {
4002cdfc: d2800144 mov x4, #0xa // #10
sign = 0; dot = 0; dwidth = 0; upper = 0;
4002ce00: 52800000 mov w0, #0x0 // #0
base = 10;
4002ce04: b9009fe4 str w4, [sp, #156]
4002ce08: 17ffffa2 b 4002cc90 <_IO_Vprintf+0x5e0>
reswitch: switch (ch = (u_char)*fmt++) {
4002ce0c: d2800204 mov x4, #0x10 // #16
4002ce10: 52800000 mov w0, #0x0 // #0
4002ce14: b9009fe4 str w4, [sp, #156]
4002ce18: 17ffff9e b 4002cc90 <_IO_Vprintf+0x5e0>
4002ce1c: d2800204 mov x4, #0x10 // #16 <== NOT EXECUTED
4002ce20: b9009fe4 str w4, [sp, #156] <== NOT EXECUTED
4002ce24: 17fffe9e b 4002c89c <_IO_Vprintf+0x1ec> <== NOT EXECUTED
4002ce28: aa1403f7 mov x23, x20
4002ce2c: 17fffe96 b 4002c884 <_IO_Vprintf+0x1d4>
dwidth -= n;
4002ce30: 6b000141 subs w1, w10, w0
4002ce34: b90097e1 str w1, [sp, #148]
static inline int imax(int a, int b) { return (a > b ? a : b); }
4002ce38: 1a80a158 csel w24, w10, w0, ge // ge = tcont
width -= tmp + imax(dwidth, n);
4002ce3c: 0b040318 add w24, w24, w4
4002ce40: 4b180100 sub w0, w8, w24
4002ce44: b9006be0 str w0, [sp, #104]
if (!ladjust)
4002ce48: b9408be0 ldr w0, [sp, #136]
4002ce4c: 35ffdc00 cbnz w0, 4002c9cc <_IO_Vprintf+0x31c>
4002ce50: 17fffece b 4002c988 <_IO_Vprintf+0x2d8>
else if (lflag)
4002ce54: 34000487 cbz w7, 4002cee4 <_IO_Vprintf+0x834>
num = va_arg(ap, u_long);
4002ce58: 37f80c21 tbnz w1, #31, 4002cfdc <_IO_Vprintf+0x92c>
4002ce5c: f94033e5 ldr x5, [sp, #96]
4002ce60: 91003ca6 add x6, x5, #0xf
4002ce64: 927df0c1 and x1, x6, #0xfffffffffffffff8
4002ce68: f90033e1 str x1, [sp, #96]
4002ce6c: f94000ad ldr x13, [x5]
4002ce70: 17fffe9a b 4002c8d8 <_IO_Vprintf+0x228>
while (width-- > 0)
4002ce74: b9406be0 ldr w0, [sp, #104]
4002ce78: 7100001f cmp w0, #0x0
4002ce7c: 51000418 sub w24, w0, #0x1
4002ce80: 54ffc92d b.le 4002c7a4 <_IO_Vprintf+0xf4>
4002ce84: 2a1803f6 mov w22, w24
4002ce88: 510006d6 sub w22, w22, #0x1
PCHAR(' ');
4002ce8c: aa1b03e1 mov x1, x27
4002ce90: 52800400 mov w0, #0x20 // #32
4002ce94: d63f0260 blr x19
while (width-- > 0)
4002ce98: 310006df cmn w22, #0x1
4002ce9c: 54ffff61 b.ne 4002ce88 <_IO_Vprintf+0x7d8> // b.any <== NEVER TAKEN
4002cea0: 11000724 add w4, w25, #0x1
while ((ch = (u_char)*fmt++) != '%' || stop) {
4002cea4: 394006e0 ldrb w0, [x23, #1]
PCHAR(' ');
4002cea8: 0b040319 add w25, w24, w4
4002ceac: 17fffe1b b 4002c718 <_IO_Vprintf+0x68>
num = va_arg(ap, ptrdiff_t);
4002ceb0: 37f80440 tbnz w0, #31, 4002cf38 <_IO_Vprintf+0x888> <== ALWAYS TAKEN
4002ceb4: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002ceb8: 91003c05 add x5, x0, #0xf <== NOT EXECUTED
4002cebc: 927df0a1 and x1, x5, #0xfffffffffffffff8 <== NOT EXECUTED
4002cec0: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002cec4: f9400000 ldr x0, [x0]
4002cec8: aa0003ed mov x13, x0
4002cecc: 17fffe7f b 4002c8c8 <_IO_Vprintf+0x218>
PCHAR('0');
4002ced0: 1100079c add w28, w28, #0x1 <== NOT EXECUTED
4002ced4: aa1b03e1 mov x1, x27 <== NOT EXECUTED
4002ced8: 52800600 mov w0, #0x30 // #48 <== NOT EXECUTED
4002cedc: d63f0260 blr x19 <== NOT EXECUTED
4002cee0: 17fffed0 b 4002ca20 <_IO_Vprintf+0x370> <== NOT EXECUTED
else if (hflag)
4002cee4: 3400046b cbz w11, 4002cf70 <_IO_Vprintf+0x8c0> <== ALWAYS TAKEN
num = (u_short)va_arg(ap, int);
4002cee8: 37f81f61 tbnz w1, #31, 4002d2d4 <_IO_Vprintf+0xc24> <== NOT EXECUTED
4002ceec: f94033e5 ldr x5, [sp, #96] <== NOT EXECUTED
4002cef0: 91002ca6 add x6, x5, #0xb <== NOT EXECUTED
4002cef4: 927df0c1 and x1, x6, #0xfffffffffffffff8 <== NOT EXECUTED
4002cef8: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002cefc: 794000ad ldrh w13, [x5] <== NOT EXECUTED
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
4002cf00: 52800019 mov w25, #0x0 // #0 <== NOT EXECUTED
4002cf04: 17fffe75 b 4002c8d8 <_IO_Vprintf+0x228> <== NOT EXECUTED
num = va_arg(ap, uintmax_t);
4002cf08: b94093e1 ldr w1, [sp, #144]
4002cf0c: 11002026 add w6, w1, #0x8
4002cf10: 710000df cmp w6, #0x0
4002cf14: 54000bed b.le 4002d090 <_IO_Vprintf+0x9e0> <== ALWAYS TAKEN
4002cf18: f94033e5 ldr x5, [sp, #96] <== NOT EXECUTED
4002cf1c: b90093e6 str w6, [sp, #144] <== NOT EXECUTED
4002cf20: 91003ca7 add x7, x5, #0xf <== NOT EXECUTED
4002cf24: 927df0e1 and x1, x7, #0xfffffffffffffff8 <== NOT EXECUTED
4002cf28: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002cf2c: 17ffff60 b 4002ccac <_IO_Vprintf+0x5fc> <== NOT EXECUTED
while (*p)
4002cf30: 2a1c03f9 mov w25, w28 <== NOT EXECUTED
4002cf34: 17fffed3 b 4002ca80 <_IO_Vprintf+0x3d0> <== NOT EXECUTED
num = va_arg(ap, ptrdiff_t);
4002cf38: b94093e0 ldr w0, [sp, #144]
4002cf3c: 11002005 add w5, w0, #0x8
4002cf40: 710000bf cmp w5, #0x0
4002cf44: 540011cd b.le 4002d17c <_IO_Vprintf+0xacc> <== ALWAYS TAKEN
4002cf48: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002cf4c: b90093e5 str w5, [sp, #144] <== NOT EXECUTED
4002cf50: 91003c06 add x6, x0, #0xf <== NOT EXECUTED
4002cf54: 927df0c1 and x1, x6, #0xfffffffffffffff8 <== NOT EXECUTED
4002cf58: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002cf5c: 17ffffda b 4002cec4 <_IO_Vprintf+0x814> <== NOT EXECUTED
cflag = 1;
4002cf60: 2a0b03ed mov w13, w11
reswitch: switch (ch = (u_char)*fmt++) {
4002cf64: aa1403f7 mov x23, x20
hflag = 0;
4002cf68: 5280000b mov w11, #0x0 // #0
4002cf6c: 17fffe04 b 4002c77c <_IO_Vprintf+0xcc>
else if (cflag)
4002cf70: 340015ed cbz w13, 4002d22c <_IO_Vprintf+0xb7c>
num = (u_char)va_arg(ap, int);
4002cf74: 37f81e21 tbnz w1, #31, 4002d338 <_IO_Vprintf+0xc88> <== ALWAYS TAKEN
4002cf78: f94033e5 ldr x5, [sp, #96] <== NOT EXECUTED
4002cf7c: 91002ca6 add x6, x5, #0xb <== NOT EXECUTED
4002cf80: 927df0c1 and x1, x6, #0xfffffffffffffff8 <== NOT EXECUTED
4002cf84: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002cf88: 394000ad ldrb w13, [x5]
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
4002cf8c: 52800019 mov w25, #0x0 // #0
4002cf90: 17fffe52 b 4002c8d8 <_IO_Vprintf+0x228>
dwidth = va_arg(ap, int);
4002cf94: 37f818c0 tbnz w0, #31, 4002d2ac <_IO_Vprintf+0xbfc> <== ALWAYS TAKEN
4002cf98: f94033e4 ldr x4, [sp, #96] <== NOT EXECUTED
4002cf9c: 91002c80 add x0, x4, #0xb <== NOT EXECUTED
4002cfa0: 927df000 and x0, x0, #0xfffffffffffffff8 <== NOT EXECUTED
4002cfa4: f90033e0 str x0, [sp, #96] <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
4002cfa8: 394006e0 ldrb w0, [x23, #1]
4002cfac: aa1403f7 mov x23, x20
dwidth = va_arg(ap, int);
4002cfb0: b940008a ldr w10, [x4]
4002cfb4: 17fffdf2 b 4002c77c <_IO_Vprintf+0xcc>
up = va_arg(ap, u_char *);
4002cfb8: b94093e0 ldr w0, [sp, #144] <== NOT EXECUTED
4002cfbc: 11002000 add w0, w0, #0x8 <== NOT EXECUTED
4002cfc0: 7100001f cmp w0, #0x0 <== NOT EXECUTED
4002cfc4: 5400036d b.le 4002d030 <_IO_Vprintf+0x980> <== NOT EXECUTED
4002cfc8: f94033e1 ldr x1, [sp, #96] <== NOT EXECUTED
4002cfcc: b90093e0 str w0, [sp, #144] <== NOT EXECUTED
4002cfd0: 91003c24 add x4, x1, #0xf <== NOT EXECUTED
4002cfd4: 927df080 and x0, x4, #0xfffffffffffffff8 <== NOT EXECUTED
4002cfd8: 17ffff01 b 4002cbdc <_IO_Vprintf+0x52c> <== NOT EXECUTED
num = va_arg(ap, u_long);
4002cfdc: b94093e1 ldr w1, [sp, #144]
4002cfe0: 11002026 add w6, w1, #0x8
4002cfe4: 710000df cmp w6, #0x0
4002cfe8: 5400156d b.le 4002d294 <_IO_Vprintf+0xbe4> <== ALWAYS TAKEN
4002cfec: f94033e5 ldr x5, [sp, #96] <== NOT EXECUTED
4002cff0: b90093e6 str w6, [sp, #144] <== NOT EXECUTED
4002cff4: 91003ca7 add x7, x5, #0xf <== NOT EXECUTED
4002cff8: 927df0e1 and x1, x7, #0xfffffffffffffff8 <== NOT EXECUTED
4002cffc: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002d000: f94000ad ldr x13, [x5] <== NOT EXECUTED
4002d004: 17fffe35 b 4002c8d8 <_IO_Vprintf+0x228> <== NOT EXECUTED
p = va_arg(ap, char *);
4002d008: b94093e0 ldr w0, [sp, #144]
4002d00c: 11002004 add w4, w0, #0x8
4002d010: 7100009f cmp w4, #0x0
4002d014: 5400174d b.le 4002d2fc <_IO_Vprintf+0xc4c> <== ALWAYS TAKEN
4002d018: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002d01c: b90093e4 str w4, [sp, #144] <== NOT EXECUTED
4002d020: 91003c05 add x5, x0, #0xf <== NOT EXECUTED
4002d024: 927df0a1 and x1, x5, #0xfffffffffffffff8 <== NOT EXECUTED
4002d028: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002d02c: 17fffeb4 b 4002cafc <_IO_Vprintf+0x44c> <== NOT EXECUTED
up = va_arg(ap, u_char *);
4002d030: b94093e2 ldr w2, [sp, #144] <== NOT EXECUTED
4002d034: f9403fe1 ldr x1, [sp, #120] <== NOT EXECUTED
4002d038: f862c836 ldr x22, [x1, w2, sxtw] <== NOT EXECUTED
p = va_arg(ap, char *);
4002d03c: 54002600 b.eq 4002d4fc <_IO_Vprintf+0xe4c> // b.none <== NOT EXECUTED
4002d040: b94093e1 ldr w1, [sp, #144] <== NOT EXECUTED
4002d044: 11004021 add w1, w1, #0x10 <== NOT EXECUTED
4002d048: b90093e1 str w1, [sp, #144] <== NOT EXECUTED
4002d04c: 7100003f cmp w1, #0x0 <== NOT EXECUTED
4002d050: 54000fed b.le 4002d24c <_IO_Vprintf+0xb9c> <== NOT EXECUTED
4002d054: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002d058: 91003c04 add x4, x0, #0xf <== NOT EXECUTED
4002d05c: 927df081 and x1, x4, #0xfffffffffffffff8 <== NOT EXECUTED
4002d060: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002d064: 17fffee3 b 4002cbf0 <_IO_Vprintf+0x540> <== NOT EXECUTED
num = (uintptr_t)va_arg(ap, void *);
4002d068: b94093e0 ldr w0, [sp, #144]
4002d06c: 11002000 add w0, w0, #0x8
4002d070: 7100001f cmp w0, #0x0
4002d074: 5400106d b.le 4002d280 <_IO_Vprintf+0xbd0> <== ALWAYS TAKEN
4002d078: f94033e5 ldr x5, [sp, #96] <== NOT EXECUTED
4002d07c: b90093e0 str w0, [sp, #144] <== NOT EXECUTED
4002d080: 91003ca4 add x4, x5, #0xf <== NOT EXECUTED
4002d084: 927df080 and x0, x4, #0xfffffffffffffff8 <== NOT EXECUTED
4002d088: f90033e0 str x0, [sp, #96] <== NOT EXECUTED
4002d08c: 17fffe90 b 4002cacc <_IO_Vprintf+0x41c> <== NOT EXECUTED
num = va_arg(ap, uintmax_t);
4002d090: f9403fe2 ldr x2, [sp, #120]
4002d094: b94093e1 ldr w1, [sp, #144]
4002d098: b90093e6 str w6, [sp, #144]
4002d09c: 8b21c045 add x5, x2, w1, sxtw
4002d0a0: 17ffff03 b 4002ccac <_IO_Vprintf+0x5fc>
PCHAR(va_arg(ap, int));
4002d0a4: b94093e0 ldr w0, [sp, #144]
4002d0a8: 11002004 add w4, w0, #0x8
4002d0ac: 7100009f cmp w4, #0x0
4002d0b0: 5400192d b.le 4002d3d4 <_IO_Vprintf+0xd24> <== ALWAYS TAKEN
4002d0b4: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002d0b8: b90093e4 str w4, [sp, #144] <== NOT EXECUTED
4002d0bc: 91002c05 add x5, x0, #0xb <== NOT EXECUTED
4002d0c0: 927df0a1 and x1, x5, #0xfffffffffffffff8 <== NOT EXECUTED
4002d0c4: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002d0c8: 17ffff08 b 4002cce8 <_IO_Vprintf+0x638> <== NOT EXECUTED
while (width--)
4002d0cc: 51000919 sub w25, w8, #0x2 <== NOT EXECUTED
4002d0d0: 51000916 sub w22, w8, #0x2 <== NOT EXECUTED
PCHAR(padc);
4002d0d4: d280001a mov x26, #0x0 // #0 <== NOT EXECUTED
4002d0d8: aa1b03e1 mov x1, x27 <== NOT EXECUTED
4002d0dc: 2a1803e0 mov w0, w24 <== NOT EXECUTED
4002d0e0: d63f0260 blr x19 <== NOT EXECUTED
while (width--)
4002d0e4: eb16035f cmp x26, x22 <== NOT EXECUTED
4002d0e8: 9100075a add x26, x26, #0x1 <== NOT EXECUTED
4002d0ec: 54ffff61 b.ne 4002d0d8 <_IO_Vprintf+0xa28> // b.any <== NOT EXECUTED
PCHAR(va_arg(ap, int));
4002d0f0: b94093e0 ldr w0, [sp, #144] <== NOT EXECUTED
4002d0f4: 0b1c0323 add w3, w25, w28 <== NOT EXECUTED
4002d0f8: 37f81340 tbnz w0, #31, 4002d360 <_IO_Vprintf+0xcb0> <== NOT EXECUTED
4002d0fc: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002d100: 91002c04 add x4, x0, #0xb <== NOT EXECUTED
4002d104: 927df081 and x1, x4, #0xfffffffffffffff8 <== NOT EXECUTED
4002d108: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002d10c: b9400000 ldr w0, [x0] <== NOT EXECUTED
4002d110: 11000879 add w25, w3, #0x2 <== NOT EXECUTED
4002d114: aa1b03e1 mov x1, x27 <== NOT EXECUTED
4002d118: d63f0260 blr x19 <== NOT EXECUTED
while ((ch = (u_char)*fmt++) != '%' || stop) {
4002d11c: 394006e0 ldrb w0, [x23, #1] <== NOT EXECUTED
4002d120: 17fffd7e b 4002c718 <_IO_Vprintf+0x68> <== NOT EXECUTED
for (n = 0; n < dwidth && p[n]; n++)
4002d124: 7100015f cmp w10, #0x0
4002d128: d2800006 mov x6, #0x0 // #0
4002d12c: 54001fad b.le 4002d520 <_IO_Vprintf+0xe70> <== NEVER TAKEN
4002d130: 38666b27 ldrb w7, [x25, x6]
4002d134: 2a0603e0 mov w0, w6
4002d138: 2a0603e5 mov w5, w6
4002d13c: 34ffcfc7 cbz w7, 4002cb34 <_IO_Vprintf+0x484>
4002d140: 110004c7 add w7, w6, #0x1
4002d144: 910004c6 add x6, x6, #0x1
4002d148: 6b06015f cmp w10, w6
4002d14c: 54ffff2c b.gt 4002d130 <_IO_Vprintf+0xa80>
width -= n;
4002d150: 4b070108 sub w8, w8, w7
if (!ladjust && width > 0)
4002d154: 7100011f cmp w8, #0x0
4002d158: 1a9fd7e6 cset w6, gt
4002d15c: 710002df cmp w22, #0x0
4002d160: 7a4018c4 ccmp w6, #0x0, #0x4, ne // ne = any
4002d164: 54001f21 b.ne 4002d548 <_IO_Vprintf+0xe98> // b.any <== NEVER TAKEN
if (ladjust && width > 0)
4002d168: b9408be1 ldr w1, [sp, #136]
4002d16c: b90097e0 str w0, [sp, #148]
4002d170: 0a060021 and w1, w1, w6
4002d174: 2a0103fa mov w26, w1
4002d178: 17fffe7b b 4002cb64 <_IO_Vprintf+0x4b4>
num = va_arg(ap, ptrdiff_t);
4002d17c: f9403fe1 ldr x1, [sp, #120]
4002d180: b94093e0 ldr w0, [sp, #144]
4002d184: b90093e5 str w5, [sp, #144]
4002d188: 8b20c020 add x0, x1, w0, sxtw
4002d18c: 17ffff4e b 4002cec4 <_IO_Vprintf+0x814>
ch = *fmt;
4002d190: 394006e5 ldrb w5, [x23, #1] <== NOT EXECUTED
if (ch < '0' || ch > '9')
4002d194: 5100c0a2 sub w2, w5, #0x30 <== NOT EXECUTED
ch = *fmt;
4002d198: 2a0503e0 mov w0, w5 <== NOT EXECUTED
if (ch < '0' || ch > '9')
4002d19c: 7100245f cmp w2, #0x9 <== NOT EXECUTED
4002d1a0: 54001ba8 b.hi 4002d514 <_IO_Vprintf+0xe64> // b.pmore <== NOT EXECUTED
n = n * 10 + ch - '0';
4002d1a4: 52800004 mov w4, #0x0 // #0 <== NOT EXECUTED
4002d1a8: 17fffdae b 4002c860 <_IO_Vprintf+0x1b0> <== NOT EXECUTED
else if (cflag)
4002d1ac: 34000eed cbz w13, 4002d388 <_IO_Vprintf+0xcd8> <== ALWAYS TAKEN
num = (char)va_arg(ap, int);
4002d1b0: 37f81480 tbnz w0, #31, 4002d440 <_IO_Vprintf+0xd90> <== NOT EXECUTED
4002d1b4: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002d1b8: 91002c00 add x0, x0, #0xb <== NOT EXECUTED
4002d1bc: 927df000 and x0, x0, #0xfffffffffffffff8 <== NOT EXECUTED
4002d1c0: f94033e1 ldr x1, [sp, #96] <== NOT EXECUTED
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
4002d1c4: 52800019 mov w25, #0x0 // #0 <== NOT EXECUTED
if (sharpflag && num != 0) {
4002d1c8: f90033e0 str x0, [sp, #96] <== NOT EXECUTED
4002d1cc: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
num = (char)va_arg(ap, int);
4002d1d0: 3940002d ldrb w13, [x1] <== NOT EXECUTED
if (sign && (intmax_t)num < 0) {
4002d1d4: 17fffdc1 b 4002c8d8 <_IO_Vprintf+0x228> <== NOT EXECUTED
if (!ladjust && width > 0)
4002d1d8: 12800000 mov w0, #0xffffffff // #-1 <== NOT EXECUTED
for (n = 0; n < dwidth && p[n]; n++)
4002d1dc: 52800005 mov w5, #0x0 // #0 <== NOT EXECUTED
if (!ladjust && width > 0)
4002d1e0: b90097e0 str w0, [sp, #148] <== NOT EXECUTED
while (width--)
4002d1e4: 51000516 sub w22, w8, #0x1
4002d1e8: 2a0803fa mov w26, w8
PCHAR(padc);
4002d1ec: b9006be5 str w5, [sp, #104]
4002d1f0: aa1b03e1 mov x1, x27
4002d1f4: 2a1803e0 mov w0, w24
4002d1f8: d63f0260 blr x19
while (width--)
4002d1fc: b9406be5 ldr w5, [sp, #104]
4002d200: 7100075a subs w26, w26, #0x1
4002d204: 54ffff41 b.ne 4002d1ec <_IO_Vprintf+0xb3c> // b.any
PCHAR(padc);
4002d208: 11000783 add w3, w28, #0x1
while (n--)
4002d20c: 5280001a mov w26, #0x0 // #0
PCHAR(padc);
4002d210: 0b16007c add w28, w3, w22
while (n--)
4002d214: 12800008 mov w8, #0xffffffff // #-1
4002d218: 35ffca65 cbnz w5, 4002cb64 <_IO_Vprintf+0x4b4> <== ALWAYS TAKEN
while ((ch = (u_char)*fmt++) != '%' || stop) {
4002d21c: 394006e0 ldrb w0, [x23, #1] <== NOT EXECUTED
PCHAR(padc);
4002d220: 2a1c03f9 mov w25, w28 <== NOT EXECUTED
while (n--)
4002d224: 52800015 mov w21, #0x0 // #0 <== NOT EXECUTED
4002d228: 17fffd3c b 4002c718 <_IO_Vprintf+0x68> <== NOT EXECUTED
num = va_arg(ap, u_int);
4002d22c: 37f80c01 tbnz w1, #31, 4002d3ac <_IO_Vprintf+0xcfc>
4002d230: f94033e5 ldr x5, [sp, #96]
4002d234: 91002ca6 add x6, x5, #0xb
4002d238: 927df0c1 and x1, x6, #0xfffffffffffffff8
4002d23c: f90033e1 str x1, [sp, #96]
4002d240: b94000ad ldr w13, [x5]
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
4002d244: 52800019 mov w25, #0x0 // #0
4002d248: 17fffda4 b 4002c8d8 <_IO_Vprintf+0x228>
p = va_arg(ap, char *);
4002d24c: f9403fe1 ldr x1, [sp, #120] <== NOT EXECUTED
4002d250: 8b20c020 add x0, x1, w0, sxtw <== NOT EXECUTED
4002d254: 17fffe67 b 4002cbf0 <_IO_Vprintf+0x540> <== NOT EXECUTED
width = va_arg(ap, int);
4002d258: b94093e0 ldr w0, [sp, #144] <== NOT EXECUTED
4002d25c: 11002004 add w4, w0, #0x8 <== NOT EXECUTED
4002d260: 7100009f cmp w4, #0x0 <== NOT EXECUTED
4002d264: 54000c6d b.le 4002d3f0 <_IO_Vprintf+0xd40> <== NOT EXECUTED
4002d268: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002d26c: b90093e4 str w4, [sp, #144] <== NOT EXECUTED
4002d270: 91002c05 add x5, x0, #0xb <== NOT EXECUTED
4002d274: 927df0a1 and x1, x5, #0xfffffffffffffff8 <== NOT EXECUTED
4002d278: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002d27c: 17fffec5 b 4002cd90 <_IO_Vprintf+0x6e0> <== NOT EXECUTED
num = (uintptr_t)va_arg(ap, void *);
4002d280: f9403fe2 ldr x2, [sp, #120]
4002d284: b94093e1 ldr w1, [sp, #144]
4002d288: b90093e0 str w0, [sp, #144]
4002d28c: 8b21c045 add x5, x2, w1, sxtw
4002d290: 17fffe0f b 4002cacc <_IO_Vprintf+0x41c>
num = va_arg(ap, u_long);
4002d294: f9403fe2 ldr x2, [sp, #120]
4002d298: b94093e1 ldr w1, [sp, #144]
4002d29c: b90093e6 str w6, [sp, #144]
4002d2a0: 8b21c045 add x5, x2, w1, sxtw
4002d2a4: f94000ad ldr x13, [x5]
4002d2a8: 17fffd8c b 4002c8d8 <_IO_Vprintf+0x228>
dwidth = va_arg(ap, int);
4002d2ac: b94093e0 ldr w0, [sp, #144]
4002d2b0: 11002000 add w0, w0, #0x8
4002d2b4: 7100001f cmp w0, #0x0
4002d2b8: 54000b0d b.le 4002d418 <_IO_Vprintf+0xd68> <== ALWAYS TAKEN
4002d2bc: f94033e4 ldr x4, [sp, #96] <== NOT EXECUTED
4002d2c0: b90093e0 str w0, [sp, #144] <== NOT EXECUTED
4002d2c4: 91002c85 add x5, x4, #0xb <== NOT EXECUTED
4002d2c8: 927df0a0 and x0, x5, #0xfffffffffffffff8 <== NOT EXECUTED
4002d2cc: f90033e0 str x0, [sp, #96] <== NOT EXECUTED
4002d2d0: 17ffff36 b 4002cfa8 <_IO_Vprintf+0x8f8> <== NOT EXECUTED
num = (u_short)va_arg(ap, int);
4002d2d4: b94093e1 ldr w1, [sp, #144] <== NOT EXECUTED
4002d2d8: 11002026 add w6, w1, #0x8 <== NOT EXECUTED
4002d2dc: 710000df cmp w6, #0x0 <== NOT EXECUTED
4002d2e0: 54000a6d b.le 4002d42c <_IO_Vprintf+0xd7c> <== NOT EXECUTED
4002d2e4: f94033e5 ldr x5, [sp, #96] <== NOT EXECUTED
4002d2e8: b90093e6 str w6, [sp, #144] <== NOT EXECUTED
4002d2ec: 91002ca7 add x7, x5, #0xb <== NOT EXECUTED
4002d2f0: 927df0e1 and x1, x7, #0xfffffffffffffff8 <== NOT EXECUTED
4002d2f4: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002d2f8: 17ffff01 b 4002cefc <_IO_Vprintf+0x84c> <== NOT EXECUTED
p = va_arg(ap, char *);
4002d2fc: f9403fe1 ldr x1, [sp, #120]
4002d300: b94093e0 ldr w0, [sp, #144]
4002d304: b90093e4 str w4, [sp, #144]
4002d308: 8b20c020 add x0, x1, w0, sxtw
4002d30c: 17fffdfc b 4002cafc <_IO_Vprintf+0x44c>
num = (short)va_arg(ap, int);
4002d310: b94093e0 ldr w0, [sp, #144] <== NOT EXECUTED
4002d314: 11002005 add w5, w0, #0x8 <== NOT EXECUTED
4002d318: 710000bf cmp w5, #0x0 <== NOT EXECUTED
4002d31c: 5400074d b.le 4002d404 <_IO_Vprintf+0xd54> <== NOT EXECUTED
4002d320: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002d324: b90093e5 str w5, [sp, #144] <== NOT EXECUTED
4002d328: 91002c06 add x6, x0, #0xb <== NOT EXECUTED
4002d32c: 927df0c1 and x1, x6, #0xfffffffffffffff8 <== NOT EXECUTED
4002d330: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002d334: 17fffd63 b 4002c8c0 <_IO_Vprintf+0x210> <== NOT EXECUTED
num = (u_char)va_arg(ap, int);
4002d338: b94093e1 ldr w1, [sp, #144]
4002d33c: 11002026 add w6, w1, #0x8
4002d340: 710000df cmp w6, #0x0
4002d344: 54000acd b.le 4002d49c <_IO_Vprintf+0xdec> <== ALWAYS TAKEN
4002d348: f94033e5 ldr x5, [sp, #96] <== NOT EXECUTED
4002d34c: b90093e6 str w6, [sp, #144] <== NOT EXECUTED
4002d350: 91002ca7 add x7, x5, #0xb <== NOT EXECUTED
4002d354: 927df0e1 and x1, x7, #0xfffffffffffffff8 <== NOT EXECUTED
4002d358: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002d35c: 17ffff0b b 4002cf88 <_IO_Vprintf+0x8d8> <== NOT EXECUTED
PCHAR(va_arg(ap, int));
4002d360: b94093e0 ldr w0, [sp, #144] <== NOT EXECUTED
4002d364: 11002004 add w4, w0, #0x8 <== NOT EXECUTED
4002d368: 7100009f cmp w4, #0x0 <== NOT EXECUTED
4002d36c: 540007cd b.le 4002d464 <_IO_Vprintf+0xdb4> <== NOT EXECUTED
4002d370: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002d374: b90093e4 str w4, [sp, #144] <== NOT EXECUTED
4002d378: 91002c05 add x5, x0, #0xb <== NOT EXECUTED
4002d37c: 927df0a1 and x1, x5, #0xfffffffffffffff8 <== NOT EXECUTED
4002d380: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002d384: 17ffff62 b 4002d10c <_IO_Vprintf+0xa5c> <== NOT EXECUTED
num = va_arg(ap, int);
4002d388: 37f80780 tbnz w0, #31, 4002d478 <_IO_Vprintf+0xdc8> <== ALWAYS TAKEN
4002d38c: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002d390: 91002c00 add x0, x0, #0xb <== NOT EXECUTED
4002d394: 927df000 and x0, x0, #0xfffffffffffffff8 <== NOT EXECUTED
4002d398: f94033e1 ldr x1, [sp, #96]
if (sign && (intmax_t)num < 0) {
4002d39c: f90033e0 str x0, [sp, #96]
num = va_arg(ap, int);
4002d3a0: b980002d ldrsw x13, [x1]
if (sign && (intmax_t)num < 0) {
4002d3a4: aa0d03e0 mov x0, x13
4002d3a8: 17fffd48 b 4002c8c8 <_IO_Vprintf+0x218>
num = va_arg(ap, u_int);
4002d3ac: b94093e1 ldr w1, [sp, #144]
4002d3b0: 11002026 add w6, w1, #0x8
4002d3b4: 710000df cmp w6, #0x0
4002d3b8: 540007cd b.le 4002d4b0 <_IO_Vprintf+0xe00> <== ALWAYS TAKEN
4002d3bc: f94033e5 ldr x5, [sp, #96] <== NOT EXECUTED
4002d3c0: b90093e6 str w6, [sp, #144] <== NOT EXECUTED
4002d3c4: 91002ca7 add x7, x5, #0xb <== NOT EXECUTED
4002d3c8: 927df0e1 and x1, x7, #0xfffffffffffffff8 <== NOT EXECUTED
4002d3cc: f90033e1 str x1, [sp, #96] <== NOT EXECUTED
4002d3d0: 17ffff9c b 4002d240 <_IO_Vprintf+0xb90> <== NOT EXECUTED
PCHAR(va_arg(ap, int));
4002d3d4: f9403fe1 ldr x1, [sp, #120]
4002d3d8: b94093e0 ldr w0, [sp, #144]
4002d3dc: b90093e4 str w4, [sp, #144]
4002d3e0: 8b20c020 add x0, x1, w0, sxtw
4002d3e4: 17fffe41 b 4002cce8 <_IO_Vprintf+0x638>
while (n--)
4002d3e8: 2a1c03f9 mov w25, w28
4002d3ec: 17fffdeb b 4002cb98 <_IO_Vprintf+0x4e8>
width = va_arg(ap, int);
4002d3f0: f9403fe1 ldr x1, [sp, #120] <== NOT EXECUTED
4002d3f4: b94093e0 ldr w0, [sp, #144] <== NOT EXECUTED
4002d3f8: b90093e4 str w4, [sp, #144] <== NOT EXECUTED
4002d3fc: 8b20c020 add x0, x1, w0, sxtw <== NOT EXECUTED
4002d400: 17fffe64 b 4002cd90 <_IO_Vprintf+0x6e0> <== NOT EXECUTED
num = (short)va_arg(ap, int);
4002d404: f9403fe1 ldr x1, [sp, #120] <== NOT EXECUTED
4002d408: b94093e0 ldr w0, [sp, #144] <== NOT EXECUTED
4002d40c: b90093e5 str w5, [sp, #144] <== NOT EXECUTED
4002d410: 8b20c020 add x0, x1, w0, sxtw <== NOT EXECUTED
4002d414: 17fffd2b b 4002c8c0 <_IO_Vprintf+0x210> <== NOT EXECUTED
dwidth = va_arg(ap, int);
4002d418: f9403fe2 ldr x2, [sp, #120]
4002d41c: b94093e1 ldr w1, [sp, #144]
4002d420: b90093e0 str w0, [sp, #144]
4002d424: 8b21c044 add x4, x2, w1, sxtw
4002d428: 17fffee0 b 4002cfa8 <_IO_Vprintf+0x8f8>
num = (u_short)va_arg(ap, int);
4002d42c: f9403fe2 ldr x2, [sp, #120] <== NOT EXECUTED
4002d430: b94093e1 ldr w1, [sp, #144] <== NOT EXECUTED
4002d434: b90093e6 str w6, [sp, #144] <== NOT EXECUTED
4002d438: 8b21c045 add x5, x2, w1, sxtw <== NOT EXECUTED
4002d43c: 17fffeb0 b 4002cefc <_IO_Vprintf+0x84c> <== NOT EXECUTED
num = (char)va_arg(ap, int);
4002d440: b94093e0 ldr w0, [sp, #144] <== NOT EXECUTED
4002d444: 11002005 add w5, w0, #0x8 <== NOT EXECUTED
4002d448: 710000bf cmp w5, #0x0 <== NOT EXECUTED
4002d44c: 540004ad b.le 4002d4e0 <_IO_Vprintf+0xe30> <== NOT EXECUTED
4002d450: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002d454: b90093e5 str w5, [sp, #144] <== NOT EXECUTED
4002d458: 91002c00 add x0, x0, #0xb <== NOT EXECUTED
4002d45c: 927df000 and x0, x0, #0xfffffffffffffff8 <== NOT EXECUTED
4002d460: 17ffff58 b 4002d1c0 <_IO_Vprintf+0xb10> <== NOT EXECUTED
PCHAR(va_arg(ap, int));
4002d464: f9403fe1 ldr x1, [sp, #120] <== NOT EXECUTED
4002d468: b94093e0 ldr w0, [sp, #144] <== NOT EXECUTED
4002d46c: b90093e4 str w4, [sp, #144] <== NOT EXECUTED
4002d470: 8b20c020 add x0, x1, w0, sxtw <== NOT EXECUTED
4002d474: 17ffff26 b 4002d10c <_IO_Vprintf+0xa5c> <== NOT EXECUTED
num = va_arg(ap, int);
4002d478: b94093e0 ldr w0, [sp, #144]
4002d47c: 11002005 add w5, w0, #0x8
4002d480: 710000bf cmp w5, #0x0
4002d484: 5400020d b.le 4002d4c4 <_IO_Vprintf+0xe14> <== ALWAYS TAKEN
4002d488: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002d48c: b90093e5 str w5, [sp, #144] <== NOT EXECUTED
4002d490: 91002c00 add x0, x0, #0xb <== NOT EXECUTED
4002d494: 927df000 and x0, x0, #0xfffffffffffffff8 <== NOT EXECUTED
4002d498: 17ffffc0 b 4002d398 <_IO_Vprintf+0xce8> <== NOT EXECUTED
num = (u_char)va_arg(ap, int);
4002d49c: f9403fe2 ldr x2, [sp, #120]
4002d4a0: b94093e1 ldr w1, [sp, #144]
4002d4a4: b90093e6 str w6, [sp, #144]
4002d4a8: 8b21c045 add x5, x2, w1, sxtw
4002d4ac: 17fffeb7 b 4002cf88 <_IO_Vprintf+0x8d8>
num = va_arg(ap, u_int);
4002d4b0: f9403fe2 ldr x2, [sp, #120]
4002d4b4: b94093e1 ldr w1, [sp, #144]
4002d4b8: b90093e6 str w6, [sp, #144]
4002d4bc: 8b21c045 add x5, x2, w1, sxtw
4002d4c0: 17ffff60 b 4002d240 <_IO_Vprintf+0xb90>
num = va_arg(ap, int);
4002d4c4: f9403fe1 ldr x1, [sp, #120]
4002d4c8: b94093e0 ldr w0, [sp, #144]
4002d4cc: b90093e5 str w5, [sp, #144]
4002d4d0: 8b20c026 add x6, x1, w0, sxtw
4002d4d4: f94033e0 ldr x0, [sp, #96]
4002d4d8: f90033e6 str x6, [sp, #96]
4002d4dc: 17ffffaf b 4002d398 <_IO_Vprintf+0xce8>
num = (char)va_arg(ap, int);
4002d4e0: f9403fe1 ldr x1, [sp, #120] <== NOT EXECUTED
4002d4e4: b94093e0 ldr w0, [sp, #144] <== NOT EXECUTED
4002d4e8: b90093e5 str w5, [sp, #144] <== NOT EXECUTED
4002d4ec: 8b20c026 add x6, x1, w0, sxtw <== NOT EXECUTED
4002d4f0: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002d4f4: f90033e6 str x6, [sp, #96] <== NOT EXECUTED
4002d4f8: 17ffff32 b 4002d1c0 <_IO_Vprintf+0xb10> <== NOT EXECUTED
up = va_arg(ap, u_char *);
4002d4fc: b90093ff str wzr, [sp, #144] <== NOT EXECUTED
p = va_arg(ap, char *);
4002d500: f94033e0 ldr x0, [sp, #96] <== NOT EXECUTED
4002d504: 17fffdb8 b 4002cbe4 <_IO_Vprintf+0x534> <== NOT EXECUTED
4002d508: 52800000 mov w0, #0x0 // #0
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
4002d50c: 52800019 mov w25, #0x0 // #0
4002d510: 17fffcf2 b 4002c8d8 <_IO_Vprintf+0x228>
reswitch: switch (ch = (u_char)*fmt++) {
4002d514: aa1403f7 mov x23, x20 <== NOT EXECUTED
n = n * 10 + ch - '0';
4002d518: 5280000a mov w10, #0x0 // #0 <== NOT EXECUTED
4002d51c: 17fffc98 b 4002c77c <_IO_Vprintf+0xcc> <== NOT EXECUTED
if (!ladjust && width > 0)
4002d520: 7100011f cmp w8, #0x0 <== NOT EXECUTED
4002d524: 1a9fd7e0 cset w0, gt <== NOT EXECUTED
4002d528: 710002df cmp w22, #0x0 <== NOT EXECUTED
4002d52c: 7a401804 ccmp w0, #0x0, #0x4, ne // ne = any <== NOT EXECUTED
4002d530: 54ffe541 b.ne 4002d1d8 <_IO_Vprintf+0xb28> // b.any <== NOT EXECUTED
if (ladjust && width > 0)
4002d534: b9408be1 ldr w1, [sp, #136] <== NOT EXECUTED
4002d538: 2a1c03f9 mov w25, w28 <== NOT EXECUTED
4002d53c: 0a000020 and w0, w1, w0 <== NOT EXECUTED
4002d540: 2a0003fa mov w26, w0 <== NOT EXECUTED
4002d544: 17fffd95 b 4002cb98 <_IO_Vprintf+0x4e8> <== NOT EXECUTED
if (!ladjust && width > 0)
4002d548: b90097e5 str w5, [sp, #148] <== NOT EXECUTED
4002d54c: 2a0703e5 mov w5, w7 <== NOT EXECUTED
4002d550: 17ffff25 b 4002d1e4 <_IO_Vprintf+0xb34> <== NOT EXECUTED
...
000000004002e390 <_Memory_Allocate>:
{
Memory_Area *area;
const Memory_Area *end;
uintptr_t alignment_mask;
area = &information->areas[ 0 ];
4002e390: a9400c06 ldp x6, x3, [x0]
end = &information->areas[ information->count ];
4002e394: d2800304 mov x4, #0x18 // #24
alignment_mask = alignment - 1;
4002e398: d1000447 sub x7, x2, #0x1
end = &information->areas[ information->count ];
4002e39c: 9b040cc6 madd x6, x6, x4, x3
while ( area != end ) {
4002e3a0: eb06007f cmp x3, x6
4002e3a4: 54000200 b.eq 4002e3e4 <_Memory_Allocate+0x54> // b.none <== NEVER TAKEN
4002e3a8: cb0203e5 neg x5, x2
4002e3ac: 14000004 b 4002e3bc <_Memory_Allocate+0x2c>
area->free = (void *) alloc_end;
return (void *) alloc_begin;
}
++area;
4002e3b0: 91006063 add x3, x3, #0x18 <== NOT EXECUTED
while ( area != end ) {
4002e3b4: eb0300df cmp x6, x3 <== NOT EXECUTED
4002e3b8: 54000160 b.eq 4002e3e4 <_Memory_Allocate+0x54> // b.none <== NOT EXECUTED
alloc_begin = (uintptr_t) area->free;
4002e3bc: f9400460 ldr x0, [x3, #8]
alloc_begin += alignment_mask;
4002e3c0: 8b0000e0 add x0, x7, x0
alloc_begin &= ~alignment_mask;
4002e3c4: 8a050000 and x0, x0, x5
alloc_end = alloc_begin + size;
4002e3c8: ab010002 adds x2, x0, x1
4002e3cc: 54ffff22 b.cs 4002e3b0 <_Memory_Allocate+0x20> // b.hs, b.nlast <== NEVER TAKEN
if ( alloc_begin <= alloc_end && alloc_end <= (uintptr_t) area->end ) {
4002e3d0: f9400864 ldr x4, [x3, #16]
4002e3d4: eb02009f cmp x4, x2
4002e3d8: 54fffec3 b.cc 4002e3b0 <_Memory_Allocate+0x20> // b.lo, b.ul, b.last<== NEVER TAKEN
area->free = (void *) alloc_end;
4002e3dc: f9000462 str x2, [x3, #8]
}
return NULL;
}
4002e3e0: d65f03c0 ret
return NULL;
4002e3e4: d2800000 mov x0, #0x0 // #0 <== NOT EXECUTED
}
4002e3e8: d65f03c0 ret <== NOT EXECUTED
4002e3ec: 00000000 udf #0
0000000040024470 <_Memory_Fill>:
#include <rtems/score/memory.h>
#include <string.h>
void _Memory_Fill( const Memory_Information *information, int c )
{
40024470: a9bd7bfd stp x29, x30, [sp, #-48]!
Memory_Area *area;
const Memory_Area *end;
area = &information->areas[ 0 ];
end = &information->areas[ information->count ];
40024474: d2800302 mov x2, #0x18 // #24
{
40024478: 910003fd mov x29, sp
4002447c: a90153f3 stp x19, x20, [sp, #16]
area = &information->areas[ 0 ];
40024480: a9404c14 ldp x20, x19, [x0]
end = &information->areas[ information->count ];
40024484: 9b024e94 madd x20, x20, x2, x19
while ( area != end ) {
40024488: eb14027f cmp x19, x20
4002448c: 54000160 b.eq 400244b8 <_Memory_Fill+0x48> // b.none <== NEVER TAKEN
40024490: f90013f5 str x21, [sp, #32]
40024494: 2a0103f5 mov w21, w1
*
* @return The free memory area size in bytes of the memory area.
*/
RTEMS_INLINE_ROUTINE uintptr_t _Memory_Get_free_size( const Memory_Area *area )
{
return (uintptr_t) area->end - (uintptr_t) area->free;
40024498: a9408a60 ldp x0, x2, [x19, #8]
memset( _Memory_Get_free_begin( area ), c, _Memory_Get_free_size( area ) );
4002449c: 2a1503e1 mov w1, w21
++area;
400244a0: 91006273 add x19, x19, #0x18
memset( _Memory_Get_free_begin( area ), c, _Memory_Get_free_size( area ) );
400244a4: cb000042 sub x2, x2, x0
400244a8: 94002413 bl 4002d4f4 <memset>
while ( area != end ) {
400244ac: eb13029f cmp x20, x19
400244b0: 54ffff41 b.ne 40024498 <_Memory_Fill+0x28> // b.any <== NEVER TAKEN
400244b4: f94013f5 ldr x21, [sp, #32]
} }
400244b8: a94153f3 ldp x19, x20, [sp, #16]
400244bc: a8c37bfd ldp x29, x30, [sp], #48
400244c0: d65f03c0 ret
...
0000000040028ee0 <_Objects_Extend_information>:
#include <string.h> /* for memcpy() */
Objects_Maximum _Objects_Extend_information(
Objects_Information *information
)
{
40028ee0: a9b97bfd stp x29, x30, [sp, #-112]!
40028ee4: 910003fd mov x29, sp
*/
do_extend = true;
index_base = extend_count;
block = 1;
if ( information->object_blocks == NULL ) {
40028ee8: f9402402 ldr x2, [x0, #72]
{
40028eec: a90363f7 stp x23, x24, [sp, #48]
*/
RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Extend_size(
const Objects_Information *information
)
{
return information->objects_per_block;
40028ef0: 79404417 ldrh w23, [x0, #34]
40028ef4: a9046bf9 stp x25, x26, [sp, #64]
*/
RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Get_maximum_index(
const Objects_Information *information
)
{
return _Objects_Get_index( information->maximum_id );
40028ef8: b9400019 ldr w25, [x0]
40028efc: a90153f3 stp x19, x20, [sp, #16]
40028f00: 0b1702f3 add w19, w23, w23
RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Get_index(
Objects_Id id
)
{
return
(Objects_Maximum)((id >> OBJECTS_INDEX_START_BIT) &
40028f04: 12003f23 and w3, w25, #0xffff
40028f08: a9025bf5 stp x21, x22, [sp, #32]
new_maximum = (uint32_t) old_maximum + extend_count;
40028f0c: 0b3922fa add w26, w23, w25, uxth
{
40028f10: aa0003f6 mov x22, x0
40028f14: a90573fb stp x27, x28, [sp, #80]
if ( information->object_blocks == NULL ) {
40028f18: b40009a2 cbz x2, 4002904c <_Objects_Extend_information+0x16c>
block_count = 1;
} else {
block_count = old_maximum / extend_count;
40028f1c: 1ad70878 udiv w24, w3, w23
for ( ; block < block_count; block++ ) {
40028f20: 7100071f cmp w24, #0x1
40028f24: 54001129 b.ls 40029148 <_Objects_Extend_information+0x268> // b.plast<== NEVER TAKEN
index_base = extend_count;
40028f28: 2a1703f3 mov w19, w23
for ( ; block < block_count; block++ ) {
40028f2c: d2800021 mov x1, #0x1 // #1
40028f30: 14000005 b 40028f44 <_Objects_Extend_information+0x64>
40028f34: 1100043c add w28, w1, #0x1
40028f38: 91000421 add x1, x1, #0x1
40028f3c: 6b01031f cmp w24, w1
40028f40: 540007e9 b.ls 4002903c <_Objects_Extend_information+0x15c> // b.plast
if ( information->object_blocks[ block ] == NULL ) {
40028f44: f8617840 ldr x0, [x2, x1, lsl #3]
40028f48: 2a1303f5 mov w21, w19
40028f4c: 2a0103fc mov w28, w1
do_extend = false;
break;
} else
index_base += extend_count;
40028f50: 0b170273 add w19, w19, w23
if ( information->object_blocks[ block ] == NULL ) {
40028f54: b5ffff00 cbnz x0, 40028f34 <_Objects_Extend_information+0x54>
do_extend = false;
40028f58: 5280001b mov w27, #0x0 // #0
/*
* 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 ) {
40028f5c: 529fffe0 mov w0, #0xffff // #65535
40028f60: 6b00035f cmp w26, w0
40028f64: 540005c8 b.hi 4002901c <_Objects_Extend_information+0x13c> // b.pmore
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
object_block_size = extend_count * information->object_size;
40028f68: 79404ac0 ldrh w0, [x22, #36]
40028f6c: b90063e3 str w3, [sp, #96]
40028f70: 1b177c00 mul w0, w0, w23
new_object_block = _Workspace_Allocate( object_block_size );
40028f74: 93407c00 sxtw x0, w0
40028f78: 94000b5e bl 4002bcf0 <_Workspace_Allocate>
40028f7c: aa0003f4 mov x20, x0
if ( new_object_block == NULL ) {
40028f80: b40004e0 cbz x0, 4002901c <_Objects_Extend_information+0x13c> <== NEVER TAKEN
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
40028f84: b94063e3 ldr w3, [sp, #96]
api_class_and_node = information->maximum_id & ~OBJECTS_INDEX_MASK;
40028f88: 12103f39 and w25, w25, #0xffff0000
if ( do_extend ) {
40028f8c: 350006bb cbnz w27, 40029060 <_Objects_Extend_information+0x180>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
40028f90: a9440ec1 ldp x1, x3, [x22, #64]
40028f94: 2a1c03e0 mov w0, w28
information->inactive_per_block[ block ] = information->objects_per_block;
40028f98: 794046c2 ldrh w2, [x22, #34]
/*
* Append to inactive chain.
*/
the_object = new_object_block;
for ( index = index_base ; index < index_end ; ++index ) {
40028f9c: 6b1302bf cmp w21, w19
information->object_blocks[ block ] = new_object_block;
40028fa0: f8207874 str x20, [x3, x0, lsl #3]
information->inactive_per_block[ block ] = information->objects_per_block;
40028fa4: 78207822 strh w2, [x1, x0, lsl #1]
information->inactive += information->objects_per_block;
40028fa8: 794042c0 ldrh w0, [x22, #32]
40028fac: 794046c1 ldrh w1, [x22, #34]
40028fb0: 0b010000 add w0, w0, w1
40028fb4: 790042c0 strh w0, [x22, #32]
for ( index = index_base ; index < index_end ; ++index ) {
40028fb8: 540001e2 b.cs 40028ff4 <_Objects_Extend_information+0x114> // b.hs, b.nlast<== NEVER TAKEN
| ( ( index + OBJECTS_INDEX_MINIMUM ) << OBJECTS_INDEX_START_BIT );
_Chain_Initialize_node( &the_object->Node );
_Chain_Append_unprotected( &information->Inactive, &the_object->Node );
the_object = _Addresses_Add_offset( the_object, information->object_size );
40028fbc: 79404ac3 ldrh w3, [x22, #36]
return &the_chain->Tail.Node;
40028fc0: 9100c2c0 add x0, x22, #0x30
40028fc4: d503201f nop
old_last = tail->previous;
40028fc8: f9400401 ldr x1, [x0, #8]
| ( ( index + OBJECTS_INDEX_MINIMUM ) << OBJECTS_INDEX_START_BIT );
40028fcc: 110006b5 add w21, w21, #0x1
40028fd0: 2a1902a2 orr w2, w21, w25
the_node->next = tail;
40028fd4: f9000280 str x0, [x20]
the_object->id = api_class_and_node
40028fd8: b9001282 str w2, [x20, #16]
for ( index = index_base ; index < index_end ; ++index ) {
40028fdc: 6b1302bf cmp w21, w19
tail->previous = the_node;
40028fe0: f9000414 str x20, [x0, #8]
old_last->next = the_node;
40028fe4: f9000034 str x20, [x1]
the_node->previous = old_last;
40028fe8: f9000681 str x1, [x20, #8]
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
40028fec: 8b030294 add x20, x20, x3
40028ff0: 54fffec1 b.ne 40028fc8 <_Objects_Extend_information+0xe8> // b.any
}
return block;
40028ff4: 12003f80 and w0, w28, #0xffff
}
40028ff8: a94153f3 ldp x19, x20, [sp, #16]
40028ffc: a9425bf5 ldp x21, x22, [sp, #32]
40029000: a94363f7 ldp x23, x24, [sp, #48]
40029004: a9446bf9 ldp x25, x26, [sp, #64]
40029008: a94573fb ldp x27, x28, [sp, #80]
4002900c: a8c77bfd ldp x29, x30, [sp], #112
40029010: d65f03c0 ret
_Workspace_Free( new_object_block );
40029014: aa1403e0 mov x0, x20 <== NOT EXECUTED
40029018: 94000b3e bl 4002bd10 <_Workspace_Free> <== NOT EXECUTED
return 0;
4002901c: 52800000 mov w0, #0x0 // #0
}
40029020: a94153f3 ldp x19, x20, [sp, #16]
40029024: a9425bf5 ldp x21, x22, [sp, #32]
40029028: a94363f7 ldp x23, x24, [sp, #48]
4002902c: a9446bf9 ldp x25, x26, [sp, #64]
40029030: a94573fb ldp x27, x28, [sp, #80]
40029034: a8c77bfd ldp x29, x30, [sp], #112
40029038: d65f03c0 ret
index_base += extend_count;
4002903c: 2a1303f5 mov w21, w19
do_extend = true;
40029040: 5280003b mov w27, #0x1 // #1
index_end = index_base + extend_count;
40029044: 0b1302f3 add w19, w23, w19
40029048: 17ffffc5 b 40028f5c <_Objects_Extend_information+0x7c>
do_extend = true;
4002904c: 5280003b mov w27, #0x1 // #1
index_base = extend_count;
40029050: 2a1703f5 mov w21, w23
block = 1;
40029054: 2a1b03fc mov w28, w27
block_count = 1;
40029058: 2a1b03f8 mov w24, w27
4002905c: 17ffffc0 b 40028f5c <_Objects_Extend_information+0x7c>
local_table_size = new_maximum * sizeof( *local_table );
40029060: d37d4341 ubfiz x1, x26, #3, #17
block_count++;
40029064: 11000700 add w0, w24, #0x1
table_size = object_blocks_size
40029068: 52800142 mov w2, #0xa // #10
object_blocks = _Workspace_Allocate( table_size );
4002906c: f90033e1 str x1, [sp, #96]
object_blocks_size = block_count * sizeof( *object_blocks );
40029070: d37d401b ubfiz x27, x0, #3, #17
object_blocks = _Workspace_Allocate( table_size );
40029074: b9006fe3 str w3, [sp, #108]
40029078: 9ba20400 umaddl x0, w0, w2, x1
4002907c: 94000b1d bl 4002bcf0 <_Workspace_Allocate>
40029080: aa0003e4 mov x4, x0
if ( object_blocks == NULL ) {
40029084: b9406fe3 ldr w3, [sp, #108]
40029088: f94033e1 ldr x1, [sp, #96]
4002908c: b4fffc40 cbz x0, 40029014 <_Objects_Extend_information+0x134> <== NEVER TAKEN
40029090: 8b1b001b add x27, x0, x27
if ( old_maximum > extend_count ) {
40029094: 6b0302ff cmp w23, w3
40029098: 8b1b0037 add x23, x1, x27
4002909c: 540003e3 b.cc 40029118 <_Objects_Extend_information+0x238> // b.lo, b.ul, b.last
object_blocks[ 0 ] = NULL;
400290a0: f900001f str xzr, [x0]
inactive_per_block[ 0 ] = 0;
400290a4: 783b683f strh wzr, [x1, x27]
memcpy(
400290a8: f94006c1 ldr x1, [x22, #8]
400290ac: d37d3c62 ubfiz x2, x3, #3, #16
400290b0: aa1b03e0 mov x0, x27
400290b4: f90033e4 str x4, [sp, #96]
400290b8: 940048da bl 4003b420 <memcpy>
for ( index = index_base ; index < index_end ; ++index ) {
400290bc: 6b1302bf cmp w21, w19
400290c0: f94033e4 ldr x4, [sp, #96]
400290c4: 54000142 b.cs 400290ec <_Objects_Extend_information+0x20c> // b.hs, b.nlast<== NEVER TAKEN
local_table[ index ] = NULL;
400290c8: 51000662 sub w2, w19, #0x1
400290cc: 8b354f60 add x0, x27, w21, uxtw #3
400290d0: 4b150042 sub w2, w2, w21
400290d4: 52800001 mov w1, #0x0 // #0
400290d8: 91000442 add x2, x2, #0x1
400290dc: f90033e4 str x4, [sp, #96]
400290e0: d37df042 lsl x2, x2, #3
400290e4: 940048ea bl 4003b48c <memset>
400290e8: f94033e4 ldr x4, [sp, #96]
__asm__ volatile (
400290ec: d53b4221 mrs x1, daif
400290f0: d50342df msr daifset, #0x2
| (new_maximum << OBJECTS_INDEX_START_BIT);
400290f4: 2a19035a orr w26, w26, w25
information->maximum_id = api_class_and_node
400290f8: b90002da str w26, [x22]
information->local_table = local_table;
400290fc: f90006db str x27, [x22, #8]
old_tables = information->object_blocks;
40029100: f94026c0 ldr x0, [x22, #72]
information->object_blocks = object_blocks;
40029104: a90412d7 stp x23, x4, [x22, #64]
__asm__ volatile (
40029108: 92407c21 and x1, x1, #0xffffffff
4002910c: d51b4221 msr daif, x1
_Workspace_Free( old_tables );
40029110: 94000b00 bl 4002bd10 <_Workspace_Free>
block_count++;
40029114: 17ffff9f b 40028f90 <_Objects_Extend_information+0xb0>
memcpy(
40029118: f94026c1 ldr x1, [x22, #72]
4002911c: d37d3f02 ubfiz x2, x24, #3, #16
40029120: f90033e0 str x0, [sp, #96]
40029124: b9006fe3 str w3, [sp, #108]
40029128: 940048be bl 4003b420 <memcpy>
memcpy(
4002912c: f94022c1 ldr x1, [x22, #64]
40029130: d37ffb02 lsl x2, x24, #1
40029134: aa1703e0 mov x0, x23
40029138: 940048ba bl 4003b420 <memcpy>
4002913c: b9406fe3 ldr w3, [sp, #108]
40029140: f94033e4 ldr x4, [sp, #96]
40029144: 17ffffd9 b 400290a8 <_Objects_Extend_information+0x1c8>
do_extend = true;
40029148: 5280003b mov w27, #0x1 // #1 <== NOT EXECUTED
index_base = extend_count;
4002914c: 2a1703f5 mov w21, w23 <== NOT EXECUTED
block = 1;
40029150: 2a1b03fc mov w28, w27 <== NOT EXECUTED
40029154: 17ffff82 b 40028f5c <_Objects_Extend_information+0x7c> <== NOT EXECUTED
...
00000000400291f0 <_Objects_Free_objects_block>:
void _Objects_Free_objects_block(
Objects_Information *information,
Objects_Maximum block
)
{
400291f0: a9bd7bfd stp x29, x30, [sp, #-48]!
400291f4: 12003c21 and w1, w1, #0xffff
return &the_chain->Tail.Node;
400291f8: 9100c004 add x4, x0, #0x30
400291fc: 910003fd mov x29, sp
return _Chain_Immutable_head( the_chain )->next;
40029200: f9401402 ldr x2, [x0, #40]
40029204: f90013f5 str x21, [sp, #32]
Objects_Maximum index_base;
Objects_Maximum index_end;
Chain_Node *node;
const Chain_Node *tail;
objects_per_block = information->objects_per_block;
40029208: 79404415 ldrh w21, [x0, #34]
{
4002920c: a90153f3 stp x19, x20, [sp, #16]
index_base = block * objects_per_block;
index_end = index_base + objects_per_block;
node = _Chain_First( &information->Inactive );
tail = _Chain_Immutable_tail( &information->Inactive );
while ( node != tail ) {
40029210: eb04005f cmp x2, x4
{
40029214: aa0003f3 mov x19, x0
index_base = block * objects_per_block;
40029218: 1b017ea5 mul w5, w21, w1
4002921c: 12003ca6 and w6, w5, #0xffff
index_end = index_base + objects_per_block;
40029220: 0b2522a5 add w5, w21, w5, uxth
while ( node != tail ) {
40029224: 54000200 b.eq 40029264 <_Objects_Free_objects_block+0x74> // b.none<== NEVER TAKEN
40029228: 12003ca5 and w5, w5, #0xffff
4002922c: d503201f nop
Objects_Control *object;
uint32_t index;
object = (Objects_Control *) node;
index = _Objects_Get_index( object->id ) - OBJECTS_INDEX_MINIMUM;
40029230: 79402043 ldrh w3, [x2, #16]
40029234: aa0203e0 mov x0, x2
return the_node->next;
40029238: f9400042 ldr x2, [x2]
4002923c: 51000463 sub w3, w3, #0x1
/*
* Get the next node before the node is extracted
*/
node = _Chain_Next( node );
if ( index >= index_base && index < index_end ) {
40029240: 6b06007f cmp w3, w6
40029244: 540000c3 b.cc 4002925c <_Objects_Free_objects_block+0x6c> // b.lo, b.ul, b.last
40029248: 6b0300bf cmp w5, w3
4002924c: 54000089 b.ls 4002925c <_Objects_Free_objects_block+0x6c> // b.plast
previous = the_node->previous;
40029250: f9400400 ldr x0, [x0, #8]
next->previous = previous;
40029254: f9000440 str x0, [x2, #8]
previous->next = next;
40029258: f9000002 str x2, [x0]
while ( node != tail ) {
4002925c: eb04005f cmp x2, x4
40029260: 54fffe81 b.ne 40029230 <_Objects_Free_objects_block+0x40> // b.any
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
40029264: f9402660 ldr x0, [x19, #72]
40029268: 2a0103f4 mov w20, w1
4002926c: f8747800 ldr x0, [x0, x20, lsl #3]
40029270: 94000aa8 bl 4002bd10 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
40029274: a9440660 ldp x0, x1, [x19, #64]
40029278: f834783f str xzr, [x1, x20, lsl #3]
information->inactive_per_block[ block ] = 0;
4002927c: 7834781f strh wzr, [x0, x20, lsl #1]
information->inactive -= objects_per_block;
40029280: 79404260 ldrh w0, [x19, #32]
40029284: 4b150015 sub w21, w0, w21
40029288: 79004275 strh w21, [x19, #32]
}
4002928c: a94153f3 ldp x19, x20, [sp, #16]
40029290: f94013f5 ldr x21, [sp, #32]
40029294: a8c37bfd ldp x29, x30, [sp], #48
40029298: d65f03c0 ret
4002929c: 00000000 udf #0
0000000040029160 <_Objects_Free_unlimited>:
old_last = tail->previous;
40029160: f9401c05 ldr x5, [x0, #56]
40029164: 9100c003 add x3, x0, #0x30
*/
RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Is_auto_extend(
const Objects_Information *information
)
{
return information->objects_per_block != 0;
40029168: 79404404 ldrh w4, [x0, #34]
the_node->next = tail;
4002916c: f9000023 str x3, [x1]
tail->previous = the_node;
40029170: f9001c01 str x1, [x0, #56]
old_last->next = the_node;
40029174: f90000a1 str x1, [x5]
the_node->previous = old_last;
40029178: f9000425 str x5, [x1, #8]
Objects_Control *the_object
)
{
_Chain_Append_unprotected( &information->Inactive, &the_object->Node );
if ( _Objects_Is_auto_extend( information ) ) {
4002917c: 34000264 cbz w4, 400291c8 <_Objects_Free_unlimited+0x68> <== NEVER TAKEN
40029180: b9401021 ldr w1, [x1, #16]
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;
40029184: 51000421 sub w1, w1, #0x1
40029188: 12003c23 and w3, w1, #0xffff
if ( block > objects_per_block ) {
4002918c: 6b21209f cmp w4, w1, uxth
40029190: 540001c2 b.cs 400291c8 <_Objects_Free_unlimited+0x68> // b.hs, b.nlast
block /= objects_per_block;
++information->inactive_per_block[ block ];
40029194: 1ac40861 udiv w1, w3, w4
/*
* 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 ) ) ) {
40029198: 0b440484 add w4, w4, w4, lsr #1
++information->inactive_per_block[ block ];
4002919c: f9402005 ldr x5, [x0, #64]
400291a0: d37f3c21 ubfiz x1, x1, #1, #16
400291a4: 786168a3 ldrh w3, [x5, x1]
400291a8: 11000463 add w3, w3, #0x1
400291ac: 782168a3 strh w3, [x5, x1]
inactive = information->inactive;
400291b0: 79404001 ldrh w1, [x0, #32]
++inactive;
400291b4: 11000421 add w1, w1, #0x1
400291b8: 12003c21 and w1, w1, #0xffff
information->inactive = inactive;
400291bc: 79004001 strh w1, [x0, #32]
if ( inactive > ( objects_per_block + ( objects_per_block >> 1 ) ) ) {
400291c0: 6b04003f cmp w1, w4
400291c4: 5400004c b.gt 400291cc <_Objects_Free_unlimited+0x6c>
_Objects_Shrink_information( information );
}
}
}
}
400291c8: d65f03c0 ret
_Objects_Shrink_information( information );
400291cc: 14000035 b 400292a0 <_Objects_Shrink_information>
000000004002aef0 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
4002aef0: a9be7bfd stp x29, x30, [sp, #-32]!
4002aef4: 910003fd mov x29, sp
4002aef8: a90153f3 stp x19, x20, [sp, #16]
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
4002aefc: 72003c34 ands w20, w1, #0xffff
4002af00: 54000200 b.eq 4002af40 <_Objects_Get_information+0x50> // b.none
/*
* 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 );
4002af04: 2a0003f3 mov w19, w0
4002af08: 9400019e bl 4002b580 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
4002af0c: 340001a0 cbz w0, 4002af40 <_Objects_Get_information+0x50>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
4002af10: 6b14001f cmp w0, w20
4002af14: 54000163 b.cc 4002af40 <_Objects_Get_information+0x50> // b.lo, b.ul, b.last
return NULL;
if ( !_Objects_Information_table[ the_api ] )
4002af18: d0000080 adrp x0, 4003c000 <_Scheduler_Table+0x48>
4002af1c: 913be000 add x0, x0, #0xef8
4002af20: f8735800 ldr x0, [x0, w19, uxtw #3]
4002af24: b40000e0 cbz x0, 4002af40 <_Objects_Get_information+0x50> <== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
4002af28: 2a1403f4 mov w20, w20
4002af2c: f8747800 ldr x0, [x0, x20, lsl #3]
if ( !info )
4002af30: b4000080 cbz x0, 4002af40 <_Objects_Get_information+0x50>
* 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 )
4002af34: 79400001 ldrh w1, [x0]
4002af38: 35000061 cbnz w1, 4002af44 <_Objects_Get_information+0x54>
4002af3c: d503201f nop
return NULL;
4002af40: d2800000 mov x0, #0x0 // #0
#endif
return info;
}
4002af44: a94153f3 ldp x19, x20, [sp, #16]
4002af48: a8c27bfd ldp x29, x30, [sp], #32
4002af4c: d65f03c0 ret
0000000040029110 <_Objects_Get_name_as_string>:
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
40029110: f100003f cmp x1, #0x0
40029114: fa401844 ccmp x2, #0x0, #0x4, ne // ne = any
40029118: 54000580 b.eq 400291c8 <_Objects_Get_name_as_string+0xb8> // b.none
{
4002911c: a9bc7bfd stp x29, x30, [sp, #-64]!
40029120: 910003fd mov x29, sp
40029124: a90153f3 stp x19, x20, [sp, #16]
40029128: aa0203f3 mov x19, x2
4002912c: 2a0003f4 mov w20, w0
40029130: a9025bf5 stp x21, x22, [sp, #32]
40029134: aa0103f5 mov x21, x1
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id;
40029138: 34000300 cbz w0, 40029198 <_Objects_Get_name_as_string+0x88>
information = _Objects_Get_information_id( tmpId );
4002913c: 2a1403e0 mov w0, w20
40029140: 940016a4 bl 4002ebd0 <_Objects_Get_information_id>
40029144: aa0003f6 mov x22, x0
if ( !information )
40029148: b4000360 cbz x0, 400291b4 <_Objects_Get_name_as_string+0xa4>
return NULL;
the_object = _Objects_Get( tmpId, &lock_context, information );
4002914c: 2a1403e0 mov w0, w20
40029150: aa1603e2 mov x2, x22
40029154: 9100e3e1 add x1, sp, #0x38
40029158: 97ffff9e bl 40028fd0 <_Objects_Get>
if ( the_object == NULL ) {
4002915c: b40002c0 cbz x0, 400291b4 <_Objects_Get_name_as_string+0xa4>
return information->name_length > 0;
40029160: 79404ec1 ldrh w1, [x22, #38]
return NULL;
}
_Objects_Name_to_string(
40029164: aa1503e3 mov x3, x21
40029168: f9400c00 ldr x0, [x0, #24]
4002916c: 7100003f cmp w1, #0x0
40029170: 1a9f07e1 cset w1, ne // ne = any
40029174: aa1303e2 mov x2, x19
40029178: 97ffffaa bl 40029020 <_Objects_Name_to_string>
_Objects_Has_string_name( information ),
name,
length
);
_ISR_lock_ISR_enable( &lock_context );
4002917c: b9403be0 ldr w0, [sp, #56]
40029180: d51b4220 msr daif, x0
return name;
40029184: aa1303e0 mov x0, x19
}
40029188: a94153f3 ldp x19, x20, [sp, #16]
4002918c: a9425bf5 ldp x21, x22, [sp, #32]
40029190: a8c47bfd ldp x29, x30, [sp], #64
40029194: d65f03c0 ret
40029198: 900006e0 adrp x0, 40105000 <rtems_libio_iops+0x58>
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id;
4002919c: f9411000 ldr x0, [x0, #544]
400291a0: b9401014 ldr w20, [x0, #16]
information = _Objects_Get_information_id( tmpId );
400291a4: 2a1403e0 mov w0, w20
400291a8: 9400168a bl 4002ebd0 <_Objects_Get_information_id>
400291ac: aa0003f6 mov x22, x0
if ( !information )
400291b0: b5fffce0 cbnz x0, 4002914c <_Objects_Get_name_as_string+0x3c> <== ALWAYS TAKEN
return NULL;
400291b4: d2800000 mov x0, #0x0 // #0
}
400291b8: a94153f3 ldp x19, x20, [sp, #16]
400291bc: a9425bf5 ldp x21, x22, [sp, #32]
400291c0: a8c47bfd ldp x29, x30, [sp], #64
400291c4: d65f03c0 ret
return NULL;
400291c8: d2800000 mov x0, #0x0 // #0
}
400291cc: d65f03c0 ret
00000000400291d0 <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
400291d0: a9bd7bfd stp x29, x30, [sp, #-48]!
400291d4: 910003fd mov x29, sp
400291d8: a90153f3 stp x19, x20, [sp, #16]
400291dc: aa0103f4 mov x20, x1
400291e0: 2a0003f3 mov w19, w0
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id;
400291e4: 35000080 cbnz w0, 400291f4 <_Objects_Id_to_name+0x24>
400291e8: 900006e0 adrp x0, 40105000 <rtems_libio_iops+0x58>
400291ec: f9411000 ldr x0, [x0, #544]
400291f0: b9401013 ldr w19, [x0, #16]
information = _Objects_Get_information_id( tmpId );
400291f4: 2a1303e0 mov w0, w19
400291f8: 94001676 bl 4002ebd0 <_Objects_Get_information_id>
400291fc: aa0003e2 mov x2, x0
if ( !information )
40029200: b40001e0 cbz x0, 4002923c <_Objects_Id_to_name+0x6c>
return OBJECTS_INVALID_ID;
if ( _Objects_Has_string_name( information ) )
40029204: 79404c00 ldrh w0, [x0, #38]
40029208: 350001a0 cbnz w0, 4002923c <_Objects_Id_to_name+0x6c> <== NEVER TAKEN
return OBJECTS_INVALID_ID;
the_object = _Objects_Get(
4002920c: 2a1303e0 mov w0, w19
40029210: 9100a3e1 add x1, sp, #0x28
40029214: 97ffff6f bl 40028fd0 <_Objects_Get>
tmpId,
&lock_context,
information
);
if ( !the_object )
40029218: b4000120 cbz x0, 4002923c <_Objects_Id_to_name+0x6c>
return OBJECTS_INVALID_ID;
*name = the_object->name;
4002921c: f9400c00 ldr x0, [x0, #24]
40029220: f9000280 str x0, [x20]
_ISR_lock_ISR_enable( &lock_context );
40029224: b9402be0 ldr w0, [sp, #40]
40029228: d51b4220 msr daif, x0
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
4002922c: 52800000 mov w0, #0x0 // #0
}
40029230: a94153f3 ldp x19, x20, [sp, #16]
40029234: a8c37bfd ldp x29, x30, [sp], #48
40029238: d65f03c0 ret
return OBJECTS_INVALID_ID;
4002923c: 52800060 mov w0, #0x3 // #3
}
40029240: a94153f3 ldp x19, x20, [sp, #16]
40029244: a8c37bfd ldp x29, x30, [sp], #48
40029248: d65f03c0 ret
4002924c: 00000000 udf #0
000000004002e770 <_Objects_Name_to_string>:
char lname[ 5 ];
const char *s;
char *d;
size_t i;
if ( is_string ) {
4002e770: 72001c3f tst w1, #0xff
4002e774: 54000320 b.eq 4002e7d8 <_Objects_Name_to_string+0x68> // b.none <== ALWAYS TAKEN
}
d = buffer;
i = 1;
if ( s != NULL ) {
4002e778: b50000a0 cbnz x0, 4002e78c <_Objects_Name_to_string+0x1c> <== NOT EXECUTED
while ( *s != '\0' ) {
if ( i < buffer_size ) {
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
4002e77c: d2800000 mov x0, #0x0 // #0 <== NOT EXECUTED
++s;
++i;
}
}
if ( buffer_size > 0 ) {
4002e780: b40002a3 cbz x3, 4002e7d4 <_Objects_Name_to_string+0x64> <== NOT EXECUTED
*d = '\0';
4002e784: 3900005f strb wzr, [x2] <== NOT EXECUTED
}
return i - 1;
4002e788: d65f03c0 ret <== NOT EXECUTED
while ( *s != '\0' ) {
4002e78c: 39400001 ldrb w1, [x0] <== NOT EXECUTED
4002e790: 34ffff61 cbz w1, 4002e77c <_Objects_Name_to_string+0xc> <== NOT EXECUTED
4002e794: d1000406 sub x6, x0, #0x1 <== NOT EXECUTED
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
4002e798: 52800547 mov w7, #0x2a // #42 <== NOT EXECUTED
while ( *s != '\0' ) {
4002e79c: d2800020 mov x0, #0x1 // #1 <== NOT EXECUTED
4002e7a0: 14000002 b 4002e7a8 <_Objects_Name_to_string+0x38> <== NOT EXECUTED
++i;
4002e7a4: aa0503e0 mov x0, x5 <== NOT EXECUTED
return uc >= ' ' && uc <= '~';
4002e7a8: 51008024 sub w4, w1, #0x20 <== NOT EXECUTED
++i;
4002e7ac: 91000405 add x5, x0, #0x1 <== NOT EXECUTED
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
4002e7b0: 12001c84 and w4, w4, #0xff <== NOT EXECUTED
if ( i < buffer_size ) {
4002e7b4: eb00007f cmp x3, x0 <== NOT EXECUTED
4002e7b8: 54000089 b.ls 4002e7c8 <_Objects_Name_to_string+0x58> // b.plast <== NOT EXECUTED
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
4002e7bc: 71017c9f cmp w4, #0x5f <== NOT EXECUTED
4002e7c0: 1a873021 csel w1, w1, w7, cc // cc = lo, ul, last <== NOT EXECUTED
4002e7c4: 38001441 strb w1, [x2], #1 <== NOT EXECUTED
while ( *s != '\0' ) {
4002e7c8: 386568c1 ldrb w1, [x6, x5] <== NOT EXECUTED
4002e7cc: 35fffec1 cbnz w1, 4002e7a4 <_Objects_Name_to_string+0x34> <== NOT EXECUTED
if ( buffer_size > 0 ) {
4002e7d0: b5fffda3 cbnz x3, 4002e784 <_Objects_Name_to_string+0x14> <== NOT EXECUTED
}
4002e7d4: d65f03c0 ret <== NOT EXECUTED
{
4002e7d8: d10043ff sub sp, sp, #0x10
lname[ 0 ] = (name.name_u32 >> 24) & 0xff;
4002e7dc: 53187c01 lsr w1, w0, #24
lname[ 1 ] = (name.name_u32 >> 16) & 0xff;
4002e7e0: 53107c05 lsr w5, w0, #16
lname[ 2 ] = (name.name_u32 >> 8) & 0xff;
4002e7e4: 53087c04 lsr w4, w0, #8
s = lname;
4002e7e8: 910023e6 add x6, sp, #0x8
lname[ 0 ] = (name.name_u32 >> 24) & 0xff;
4002e7ec: 390023e1 strb w1, [sp, #8]
lname[ 1 ] = (name.name_u32 >> 16) & 0xff;
4002e7f0: 390027e5 strb w5, [sp, #9]
lname[ 2 ] = (name.name_u32 >> 8) & 0xff;
4002e7f4: 39002be4 strb w4, [sp, #10]
lname[ 3 ] = (name.name_u32 >> 0) & 0xff;
4002e7f8: 39002fe0 strb w0, [sp, #11]
lname[ 4 ] = '\0';
4002e7fc: 390033ff strb wzr, [sp, #12]
while ( *s != '\0' ) {
4002e800: 34000281 cbz w1, 4002e850 <_Objects_Name_to_string+0xe0>
4002e804: d10004c6 sub x6, x6, #0x1
4002e808: d2800020 mov x0, #0x1 // #1
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
4002e80c: 52800547 mov w7, #0x2a // #42
4002e810: 14000002 b 4002e818 <_Objects_Name_to_string+0xa8>
++i;
4002e814: aa0503e0 mov x0, x5
return uc >= ' ' && uc <= '~';
4002e818: 51008024 sub w4, w1, #0x20
++i;
4002e81c: 91000405 add x5, x0, #0x1
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
4002e820: 12001c84 and w4, w4, #0xff
if ( i < buffer_size ) {
4002e824: eb00007f cmp x3, x0
4002e828: 54000089 b.ls 4002e838 <_Objects_Name_to_string+0xc8> // b.plast
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
4002e82c: 71017c9f cmp w4, #0x5f
4002e830: 1a873021 csel w1, w1, w7, cc // cc = lo, ul, last
4002e834: 38001441 strb w1, [x2], #1
while ( *s != '\0' ) {
4002e838: 386568c1 ldrb w1, [x6, x5]
4002e83c: 35fffec1 cbnz w1, 4002e814 <_Objects_Name_to_string+0xa4>
if ( buffer_size > 0 ) {
4002e840: b4000043 cbz x3, 4002e848 <_Objects_Name_to_string+0xd8>
*d = '\0';
4002e844: 3900005f strb wzr, [x2]
}
4002e848: 910043ff add sp, sp, #0x10
4002e84c: d65f03c0 ret
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
4002e850: d2800000 mov x0, #0x0 // #0
4002e854: 17fffffb b 4002e840 <_Objects_Name_to_string+0xd0>
...
0000000040024a10 <_Objects_Set_name>:
Status_Control _Objects_Set_name(
const Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
40024a10: a9bd7bfd stp x29, x30, [sp, #-48]!
40024a14: 910003fd mov x29, sp
40024a18: a90153f3 stp x19, x20, [sp, #16]
40024a1c: aa0103f4 mov x20, x1
40024a20: 79404c01 ldrh w1, [x0, #38]
40024a24: aa0203f3 mov x19, x2
if ( _Objects_Has_string_name( information ) ) {
40024a28: 34000201 cbz w1, 40024a68 <_Objects_Set_name+0x58>
size_t length;
char *dup;
length = strnlen( name, information->name_length );
40024a2c: 92403c21 and x1, x1, #0xffff
40024a30: aa0203e0 mov x0, x2
40024a34: 9400292d bl 4002eee8 <strnlen>
dup = _Workspace_String_duplicate( name, length );
40024a38: aa0003e1 mov x1, x0
40024a3c: aa1303e0 mov x0, x19
40024a40: 94000938 bl 40026f20 <_Workspace_String_duplicate>
40024a44: aa0003f3 mov x19, x0
if ( dup == NULL ) {
40024a48: b4000360 cbz x0, 40024ab4 <_Objects_Set_name+0xa4> <== ALWAYS TAKEN
return STATUS_NO_MEMORY;
}
_Workspace_Free( RTEMS_DECONST( char *, the_object->name.name_p ) );
40024a4c: f9400e80 ldr x0, [x20, #24] <== NOT EXECUTED
40024a50: 94000930 bl 40026f10 <_Workspace_Free> <== NOT EXECUTED
the_object->name.name_p = dup;
40024a54: f9000e93 str x19, [x20, #24] <== NOT EXECUTED
the_object->name.name_u32 =
_Objects_Build_name( c[ 0 ], c[ 1 ], c[ 2 ], c[ 3 ] );
}
return STATUS_SUCCESSFUL;
40024a58: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
}
40024a5c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40024a60: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
40024a64: d65f03c0 ret <== NOT EXECUTED
memset( c, ' ', sizeof( c ) );
40024a68: d1000453 sub x19, x2, #0x1
40024a6c: 3203c3e0 mov w0, #0x20202020 // #538976288
40024a70: d2800023 mov x3, #0x1 // #1
40024a74: b9002be0 str w0, [sp, #40]
c[ i ] = name[ i ];
40024a78: 9100a3e0 add x0, sp, #0x28
40024a7c: 8b000061 add x1, x3, x0
if ( name[ i ] == '\0') {
40024a80: 38636a60 ldrb w0, [x19, x3]
for ( i = 0; i < 4; ++i ) {
40024a84: 91000463 add x3, x3, #0x1
40024a88: f100147f cmp x3, #0x5
if ( name[ i ] == '\0') {
40024a8c: 34000060 cbz w0, 40024a98 <_Objects_Set_name+0x88>
c[ i ] = name[ i ];
40024a90: 381ff020 sturb w0, [x1, #-1]
for ( i = 0; i < 4; ++i ) {
40024a94: 54ffff21 b.ne 40024a78 <_Objects_Set_name+0x68> // b.any
the_object->name.name_u32 =
40024a98: b9402be1 ldr w1, [sp, #40]
return STATUS_SUCCESSFUL;
40024a9c: 52800000 mov w0, #0x0 // #0
40024aa0: 5ac00821 rev w1, w1
the_object->name.name_u32 =
40024aa4: b9001a81 str w1, [x20, #24]
}
40024aa8: a94153f3 ldp x19, x20, [sp, #16]
40024aac: a8c37bfd ldp x29, x30, [sp], #48
40024ab0: d65f03c0 ret
return STATUS_NO_MEMORY;
40024ab4: 5282c340 mov w0, #0x161a // #5658
40024ab8: 17fffffc b 40024aa8 <_Objects_Set_name+0x98>
40024abc: 00000000 udf #0
00000000400292a0 <_Objects_Shrink_information>:
/*
* Search the list to find block or chunk with all objects inactive.
*/
objects_per_block = information->objects_per_block;
400292a0: 79404405 ldrh w5, [x0, #34]
block_count = _Objects_Get_maximum_index( information ) / objects_per_block;
400292a4: 79400004 ldrh w4, [x0]
400292a8: 1ac50884 udiv w4, w4, w5
for ( block = 1; block < block_count; block++ ) {
400292ac: 7100049f cmp w4, #0x1
400292b0: 540001a9 b.ls 400292e4 <_Objects_Shrink_information+0x44> // b.plast<== NEVER TAKEN
if ( information->inactive_per_block[ block ] == objects_per_block ) {
400292b4: d2800022 mov x2, #0x1 // #1
400292b8: 2a0203e1 mov w1, w2
400292bc: f9402006 ldr x6, [x0, #64]
400292c0: 14000004 b 400292d0 <_Objects_Shrink_information+0x30>
for ( block = 1; block < block_count; block++ ) {
400292c4: 6b22209f cmp w4, w2, uxth
400292c8: 12003c41 and w1, w2, #0xffff
400292cc: 540000c9 b.ls 400292e4 <_Objects_Shrink_information+0x44> // b.plast<== NEVER TAKEN
if ( information->inactive_per_block[ block ] == objects_per_block ) {
400292d0: 786278c3 ldrh w3, [x6, x2, lsl #1]
for ( block = 1; block < block_count; block++ ) {
400292d4: 91000442 add x2, x2, #0x1
if ( information->inactive_per_block[ block ] == objects_per_block ) {
400292d8: 6b05007f cmp w3, w5
400292dc: 54ffff41 b.ne 400292c4 <_Objects_Shrink_information+0x24> // b.any
_Objects_Free_objects_block( information, block );
400292e0: 17ffffc4 b 400291f0 <_Objects_Free_objects_block>
return;
}
}
}
400292e4: d65f03c0 ret <== NOT EXECUTED
...
0000000040025980 <_Once>:
.Mutex = RTEMS_MUTEX_INITIALIZER( "_Once" ),
.State = RTEMS_CONDITION_VARIABLE_INITIALIZER( "_Once" )
};
int _Once( unsigned char *once_state, void ( *init_routine )( void ) )
{
40025980: a9bd7bfd stp x29, x30, [sp, #-48]!
40025984: 910003fd mov x29, sp
40025988: a90153f3 stp x19, x20, [sp, #16]
4002598c: aa0003f3 mov x19, x0
_Atomic_Fence( ATOMIC_ORDER_ACQUIRE );
if ( RTEMS_PREDICT_FALSE( *once_state != ONCE_STATE_COMPLETE ) ) {
40025990: 39400000 ldrb w0, [x0]
40025994: 7100081f cmp w0, #0x2
40025998: 540000a1 b.ne 400259ac <_Once+0x2c> // b.any
_Once_Unlock( thread_life_state );
}
return 0;
}
4002599c: 52800000 mov w0, #0x0 // #0
400259a0: a94153f3 ldp x19, x20, [sp, #16]
400259a4: a8c37bfd ldp x29, x30, [sp], #48
400259a8: d65f03c0 ret
Thread_Life_state _Once_Lock( void )
{
Thread_Life_state thread_life_state;
thread_life_state = _Thread_Set_life_protection( THREAD_LIFE_PROTECTED );
400259ac: aa0103f4 mov x20, x1
400259b0: 52800020 mov w0, #0x1 // #1
400259b4: a9025bf5 stp x21, x22, [sp, #32]
400259b8: 940006f2 bl 40027580 <_Thread_Set_life_protection>
mutex->_Queue._name = name;
}
static __inline void rtems_mutex_lock( rtems_mutex *mutex )
{
_Mutex_Acquire( mutex );
400259bc: f00006d5 adrp x21, 40100000 <_RTEMS_tasks_Information>
400259c0: 910e02b5 add x21, x21, #0x380
400259c4: 2a0003f6 mov w22, w0
400259c8: aa1503e0 mov x0, x21
400259cc: 97ffff69 bl 40025770 <_Mutex_Acquire>
if ( *once_state == ONCE_STATE_INIT ) {
400259d0: 39400260 ldrb w0, [x19]
400259d4: 34000280 cbz w0, 40025a24 <_Once+0xa4> <== ALWAYS TAKEN
while ( *once_state != ONCE_STATE_COMPLETE ) {
400259d8: 7100081f cmp w0, #0x2 <== NOT EXECUTED
static __inline void rtems_condition_variable_wait(
rtems_condition_variable *condition_variable,
rtems_mutex *mutex
)
{
_Condition_Wait( condition_variable, mutex );
400259dc: 910082b4 add x20, x21, #0x20 <== NOT EXECUTED
400259e0: 54000100 b.eq 40025a00 <_Once+0x80> // b.none <== NOT EXECUTED
400259e4: d503201f nop <== NOT EXECUTED
400259e8: aa1503e1 mov x1, x21 <== NOT EXECUTED
400259ec: aa1403e0 mov x0, x20 <== NOT EXECUTED
400259f0: 94000d4c bl 40028f20 <_Condition_Wait> <== NOT EXECUTED
400259f4: 39400261 ldrb w1, [x19] <== NOT EXECUTED
400259f8: 7100083f cmp w1, #0x2 <== NOT EXECUTED
400259fc: 54ffff61 b.ne 400259e8 <_Once+0x68> // b.any <== NOT EXECUTED
_Mutex_Release( mutex );
40025a00: aa1503e0 mov x0, x21
40025a04: 97ffff77 bl 400257e0 <_Mutex_Release>
}
void _Once_Unlock( Thread_Life_state thread_life_state )
{
rtems_mutex_unlock( &_Once_Information.Mutex );
_Thread_Set_life_protection( thread_life_state );
40025a08: 2a1603e0 mov w0, w22
40025a0c: 940006dd bl 40027580 <_Thread_Set_life_protection>
}
40025a10: 52800000 mov w0, #0x0 // #0
40025a14: a94153f3 ldp x19, x20, [sp, #16]
_Thread_Set_life_protection( thread_life_state );
40025a18: a9425bf5 ldp x21, x22, [sp, #32]
}
40025a1c: a8c37bfd ldp x29, x30, [sp], #48
40025a20: d65f03c0 ret
*once_state = ONCE_STATE_RUNNING;
40025a24: 52800020 mov w0, #0x1 // #1
40025a28: 39000260 strb w0, [x19]
40025a2c: aa1503e0 mov x0, x21
40025a30: 97ffff6c bl 400257e0 <_Mutex_Release>
_Thread_Set_life_protection( thread_life_state );
40025a34: 52800020 mov w0, #0x1 // #1
40025a38: 940006d2 bl 40027580 <_Thread_Set_life_protection>
( *init_routine )();
40025a3c: d63f0280 blr x20
thread_life_state = _Thread_Set_life_protection( THREAD_LIFE_PROTECTED );
40025a40: 52800020 mov w0, #0x1 // #1
40025a44: 940006cf bl 40027580 <_Thread_Set_life_protection>
_Mutex_Acquire( mutex );
40025a48: aa1503e0 mov x0, x21
40025a4c: 97ffff49 bl 40025770 <_Mutex_Acquire>
*once_state = ONCE_STATE_COMPLETE;
40025a50: 52800040 mov w0, #0x2 // #2
40025a54: 39000260 strb w0, [x19]
static __inline void rtems_condition_variable_broadcast(
rtems_condition_variable *condition_variable
)
{
_Condition_Broadcast( condition_variable );
40025a58: 910082a0 add x0, x21, #0x20
40025a5c: 94000d4d bl 40028f90 <_Condition_Broadcast>
}
40025a60: 17ffffe8 b 40025a00 <_Once+0x80>
...
000000004002c410 <_Processor_mask_Copy>:
)
{
long inclusive = 0;
long exclusive = 0;
if ( ( dst_size | src_size ) % sizeof( long ) != 0 ) {
4002c410: aa030024 orr x4, x1, x3
4002c414: f240089f tst x4, #0x7
4002c418: 54000401 b.ne 4002c498 <_Processor_mask_Copy+0x88> // b.any
return PROCESSOR_MASK_COPY_INVALID_SIZE;
}
while ( dst_size > 0 && src_size > 0 ) {
4002c41c: f100007f cmp x3, #0x0
long inclusive = 0;
4002c420: d2800005 mov x5, #0x0 // #0
while ( dst_size > 0 && src_size > 0 ) {
4002c424: fa401824 ccmp x1, #0x0, #0x4, ne // ne = any
4002c428: 54000120 b.eq 4002c44c <_Processor_mask_Copy+0x3c> // b.none
4002c42c: d503201f nop
long bits = *src;
4002c430: f8408444 ldr x4, [x2], #8
inclusive |= bits;
*dst = bits;
4002c434: f8008404 str x4, [x0], #8
++dst;
++src;
dst_size -= sizeof( long );
src_size -= sizeof( long );
4002c438: d1002063 sub x3, x3, #0x8
while ( dst_size > 0 && src_size > 0 ) {
4002c43c: f1002021 subs x1, x1, #0x8
4002c440: fa401864 ccmp x3, #0x0, #0x4, ne // ne = any
inclusive |= bits;
4002c444: aa0400a5 orr x5, x5, x4
while ( dst_size > 0 && src_size > 0 ) {
4002c448: 54ffff41 b.ne 4002c430 <_Processor_mask_Copy+0x20> // b.any <== NEVER TAKEN
}
while ( dst_size > 0 ) {
4002c44c: b40000c1 cbz x1, 4002c464 <_Processor_mask_Copy+0x54>
4002c450: 8b010001 add x1, x0, x1
4002c454: d503201f nop
*dst = 0;
4002c458: f800841f str xzr, [x0], #8
while ( dst_size > 0 ) {
4002c45c: eb01001f cmp x0, x1
4002c460: 54ffffc1 b.ne 4002c458 <_Processor_mask_Copy+0x48> // b.any <== NEVER TAKEN
++dst;
dst_size -= sizeof( long );
}
while ( src_size > 0 ) {
4002c464: b40001e3 cbz x3, 4002c4a0 <_Processor_mask_Copy+0x90>
4002c468: 8b030043 add x3, x2, x3
long exclusive = 0;
4002c46c: d2800001 mov x1, #0x0 // #0
exclusive |= *src;
4002c470: f8408440 ldr x0, [x2], #8
4002c474: aa000021 orr x1, x1, x0
while ( src_size > 0 ) {
4002c478: eb03005f cmp x2, x3
4002c47c: 54ffffa1 b.ne 4002c470 <_Processor_mask_Copy+0x60> // b.any <== NEVER TAKEN
} else {
return PROCESSOR_MASK_COPY_COMPLETE_LOSS;
}
}
return PROCESSOR_MASK_COPY_LOSSLESS;
4002c480: 52800000 mov w0, #0x0 // #0
if ( exclusive != 0 ) {
4002c484: b4000081 cbz x1, 4002c494 <_Processor_mask_Copy+0x84>
return PROCESSOR_MASK_COPY_COMPLETE_LOSS;
4002c488: f10000bf cmp x5, #0x0
4002c48c: 1a9f17e0 cset w0, eq // eq = none
4002c490: 11000400 add w0, w0, #0x1
}
4002c494: d65f03c0 ret
return PROCESSOR_MASK_COPY_INVALID_SIZE;
4002c498: 52800060 mov w0, #0x3 // #3
}
4002c49c: d65f03c0 ret
return PROCESSOR_MASK_COPY_LOSSLESS;
4002c4a0: 52800000 mov w0, #0x0 // #0
}
4002c4a4: d65f03c0 ret
...
0000000040029610 <_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 )
40029610: a9400823 ldp x3, x2, [x1]
40029614: b40012e3 cbz x3, 40029870 <_RBTree_Extract+0x260>
40029618: b4000542 cbz x2, 400296c0 <_RBTree_Extract+0xb0>
4002961c: d503201f nop
40029620: aa0203e4 mov x4, x2
40029624: f9400042 ldr x2, [x2]
40029628: b5ffffc2 cbnz x2, 40029620 <_RBTree_Extract+0x10>
4002962c: a9408c82 ldp x2, x3, [x4, #8]
40029630: b9401885 ldr w5, [x4, #24]
40029634: aa0303e6 mov x6, x3
40029638: b4000062 cbz x2, 40029644 <_RBTree_Extract+0x34>
4002963c: f9000843 str x3, [x2, #16]
40029640: f9400886 ldr x6, [x4, #16]
40029644: b40013c3 cbz x3, 400298bc <_RBTree_Extract+0x2ac> <== NEVER TAKEN
40029648: f9400067 ldr x7, [x3]
4002964c: eb07009f cmp x4, x7
40029650: 54001240 b.eq 40029898 <_RBTree_Extract+0x288> // b.none
40029654: f9000462 str x2, [x3, #8]
40029658: f9400027 ldr x7, [x1]
4002965c: f9000087 str x7, [x4]
40029660: eb06003f cmp x1, x6
40029664: f9400426 ldr x6, [x1, #8]
40029668: f9000486 str x6, [x4, #8]
4002966c: 9a841063 csel x3, x3, x4, ne // ne = any
40029670: f9400826 ldr x6, [x1, #16]
40029674: f9000886 str x6, [x4, #16]
40029678: a9411c26 ldp x6, x7, [x1, #16]
4002967c: f9000c87 str x7, [x4, #24]
40029680: b40011a6 cbz x6, 400298b4 <_RBTree_Extract+0x2a4>
40029684: f94000c7 ldr x7, [x6]
40029688: eb07003f cmp x1, x7
4002968c: 54001200 b.eq 400298cc <_RBTree_Extract+0x2bc> // b.none
40029690: f90004c4 str x4, [x6, #8]
40029694: a9400426 ldp x6, x1, [x1]
40029698: f90008c4 str x4, [x6, #16]
4002969c: b4000041 cbz x1, 400296a4 <_RBTree_Extract+0x94>
400296a0: f9000824 str x4, [x1, #16]
400296a4: b40000a3 cbz x3, 400296b8 <_RBTree_Extract+0xa8> <== NEVER TAKEN
400296a8: aa0303e1 mov x1, x3
400296ac: d503201f nop
400296b0: f9400821 ldr x1, [x1, #16]
400296b4: b5ffffe1 cbnz x1, 400296b0 <_RBTree_Extract+0xa0>
400296b8: 34000185 cbz w5, 400296e8 <_RBTree_Extract+0xd8>
)
{
_Assert( _RBTree_Find_root( the_node ) == _RBTree_Root( the_rbtree ) );
RB_REMOVE( RBTree_Control, the_rbtree, the_node );
_RBTree_Initialize_node( the_node );
}
400296bc: d65f03c0 ret
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
400296c0: aa0303e2 mov x2, x3
400296c4: b9401825 ldr w5, [x1, #24]
400296c8: f9400823 ldr x3, [x1, #16]
400296cc: f9000843 str x3, [x2, #16]
400296d0: b4000d83 cbz x3, 40029880 <_RBTree_Extract+0x270>
400296d4: f9400064 ldr x4, [x3]
400296d8: eb04003f cmp x1, x4
400296dc: 54000e60 b.eq 400298a8 <_RBTree_Extract+0x298> // b.none
400296e0: f9000462 str x2, [x3, #8]
400296e4: 35fffec5 cbnz w5, 400296bc <_RBTree_Extract+0xac>
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
400296e8: 52800025 mov w5, #0x1 // #1
400296ec: d503201f nop
400296f0: b4000062 cbz x2, 400296fc <_RBTree_Extract+0xec>
400296f4: b9401841 ldr w1, [x2, #24]
400296f8: 35000ee1 cbnz w1, 400298d4 <_RBTree_Extract+0x2c4>
400296fc: f9400001 ldr x1, [x0]
40029700: eb01005f cmp x2, x1
40029704: 54000660 b.eq 400297d0 <_RBTree_Extract+0x1c0> // b.none
40029708: f9400061 ldr x1, [x3]
4002970c: eb02003f cmp x1, x2
40029710: 54000220 b.eq 40029754 <_RBTree_Extract+0x144> // b.none
40029714: b9401822 ldr w2, [x1, #24]
40029718: 7100045f cmp w2, #0x1
4002971c: 54000840 b.eq 40029824 <_RBTree_Extract+0x214> // b.none
40029720: f9400022 ldr x2, [x1]
40029724: b4000062 cbz x2, 40029730 <_RBTree_Extract+0x120>
40029728: b9401844 ldr w4, [x2, #24]
4002972c: 35000e04 cbnz w4, 400298ec <_RBTree_Extract+0x2dc>
40029730: f9400424 ldr x4, [x1, #8]
40029734: b4000064 cbz x4, 40029740 <_RBTree_Extract+0x130>
40029738: b9401886 ldr w6, [x4, #24]
4002973c: 35000d26 cbnz w6, 400298e0 <_RBTree_Extract+0x2d0>
40029740: b9001825 str w5, [x1, #24]
40029744: aa0303e2 mov x2, x3
40029748: f9400861 ldr x1, [x3, #16]
4002974c: aa0103e3 mov x3, x1
40029750: 17ffffe8 b 400296f0 <_RBTree_Extract+0xe0>
40029754: f9400461 ldr x1, [x3, #8]
40029758: b9401824 ldr w4, [x1, #24]
4002975c: f9400022 ldr x2, [x1]
40029760: 7100049f cmp w4, #0x1
40029764: 540003c0 b.eq 400297dc <_RBTree_Extract+0x1cc> // b.none
40029768: b4000062 cbz x2, 40029774 <_RBTree_Extract+0x164>
4002976c: b9401844 ldr w4, [x2, #24]
40029770: 35001224 cbnz w4, 400299b4 <_RBTree_Extract+0x3a4>
40029774: f9400424 ldr x4, [x1, #8]
40029778: b4fffe44 cbz x4, 40029740 <_RBTree_Extract+0x130>
4002977c: b9401882 ldr w2, [x4, #24]
40029780: 34fffe02 cbz w2, 40029740 <_RBTree_Extract+0x130>
40029784: b9401865 ldr w5, [x3, #24]
40029788: f9400462 ldr x2, [x3, #8]
4002978c: b9001825 str w5, [x1, #24]
40029790: b900187f str wzr, [x3, #24]
40029794: b900189f str wzr, [x4, #24]
40029798: f9400041 ldr x1, [x2]
4002979c: f9000461 str x1, [x3, #8]
400297a0: b4000041 cbz x1, 400297a8 <_RBTree_Extract+0x198>
400297a4: f9000823 str x3, [x1, #16]
400297a8: f9400861 ldr x1, [x3, #16]
400297ac: f9000841 str x1, [x2, #16]
400297b0: b4001421 cbz x1, 40029a34 <_RBTree_Extract+0x424>
400297b4: f9400024 ldr x4, [x1]
400297b8: eb04007f cmp x3, x4
400297bc: 54001420 b.eq 40029a40 <_RBTree_Extract+0x430> // b.none
400297c0: f9000422 str x2, [x1, #8]
400297c4: f9400001 ldr x1, [x0]
400297c8: f9000043 str x3, [x2]
400297cc: f9000862 str x2, [x3, #16]
400297d0: b4fff761 cbz x1, 400296bc <_RBTree_Extract+0xac>
400297d4: b900183f str wzr, [x1, #24]
}
400297d8: d65f03c0 ret
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
400297dc: b900183f str wzr, [x1, #24]
400297e0: f9000462 str x2, [x3, #8]
400297e4: b9001864 str w4, [x3, #24]
400297e8: b4000042 cbz x2, 400297f0 <_RBTree_Extract+0x1e0> <== NEVER TAKEN
400297ec: f9000843 str x3, [x2, #16]
400297f0: f9400864 ldr x4, [x3, #16]
400297f4: f9000824 str x4, [x1, #16]
400297f8: b4000544 cbz x4, 400298a0 <_RBTree_Extract+0x290>
400297fc: f9400086 ldr x6, [x4]
40029800: eb06007f cmp x3, x6
40029804: 54000600 b.eq 400298c4 <_RBTree_Extract+0x2b4> // b.none
40029808: f9000481 str x1, [x4, #8]
4002980c: f9400462 ldr x2, [x3, #8]
40029810: f9000023 str x3, [x1]
40029814: f9000861 str x1, [x3, #16]
40029818: aa0203e1 mov x1, x2
4002981c: f9400042 ldr x2, [x2]
40029820: 17ffffd2 b 40029768 <_RBTree_Extract+0x158>
40029824: f9400424 ldr x4, [x1, #8]
40029828: b900183f str wzr, [x1, #24]
4002982c: f9000064 str x4, [x3]
40029830: b9001862 str w2, [x3, #24]
40029834: b4000044 cbz x4, 4002983c <_RBTree_Extract+0x22c> <== NEVER TAKEN
40029838: f9000883 str x3, [x4, #16]
4002983c: f9400862 ldr x2, [x3, #16]
40029840: f9000822 str x2, [x1, #16]
40029844: b4000122 cbz x2, 40029868 <_RBTree_Extract+0x258>
40029848: f9400046 ldr x6, [x2]
4002984c: eb06007f cmp x3, x6
40029850: 540001e0 b.eq 4002988c <_RBTree_Extract+0x27c> // b.none
40029854: f9000441 str x1, [x2, #8]
40029858: f9000423 str x3, [x1, #8]
4002985c: f9000861 str x1, [x3, #16]
40029860: aa0403e1 mov x1, x4
40029864: 17ffffaf b 40029720 <_RBTree_Extract+0x110>
40029868: f9000001 str x1, [x0]
4002986c: 17fffffb b 40029858 <_RBTree_Extract+0x248>
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
40029870: b9401825 ldr w5, [x1, #24]
40029874: f9400823 ldr x3, [x1, #16]
40029878: b5fff2a2 cbnz x2, 400296cc <_RBTree_Extract+0xbc>
4002987c: b5fff2c3 cbnz x3, 400296d4 <_RBTree_Extract+0xc4>
40029880: f9000002 str x2, [x0]
40029884: 35fff1c5 cbnz w5, 400296bc <_RBTree_Extract+0xac> <== NEVER TAKEN
40029888: 17ffff98 b 400296e8 <_RBTree_Extract+0xd8>
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
4002988c: f9000041 str x1, [x2]
40029890: f9400064 ldr x4, [x3]
40029894: 17fffff1 b 40029858 <_RBTree_Extract+0x248>
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
40029898: f9000062 str x2, [x3]
4002989c: 17ffff6f b 40029658 <_RBTree_Extract+0x48>
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
400298a0: f9000001 str x1, [x0]
400298a4: 17ffffdb b 40029810 <_RBTree_Extract+0x200>
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
400298a8: f9000062 str x2, [x3]
400298ac: 35fff085 cbnz w5, 400296bc <_RBTree_Extract+0xac>
400298b0: 17ffff8e b 400296e8 <_RBTree_Extract+0xd8>
400298b4: f9000004 str x4, [x0]
400298b8: 17ffff77 b 40029694 <_RBTree_Extract+0x84>
400298bc: f9000002 str x2, [x0] <== NOT EXECUTED
400298c0: 17ffff66 b 40029658 <_RBTree_Extract+0x48> <== NOT EXECUTED
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
400298c4: f9000081 str x1, [x4]
400298c8: 17ffffd2 b 40029810 <_RBTree_Extract+0x200>
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
400298cc: f90000c4 str x4, [x6]
400298d0: 17ffff71 b 40029694 <_RBTree_Extract+0x84>
400298d4: aa0203e1 mov x1, x2
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
400298d8: b900183f str wzr, [x1, #24]
(void) the_node;
400298dc: 17ffffbf b 400297d8 <_RBTree_Extract+0x1c8>
400298e0: b4000322 cbz x2, 40029944 <_RBTree_Extract+0x334>
400298e4: b9401845 ldr w5, [x2, #24]
400298e8: 340002e5 cbz w5, 40029944 <_RBTree_Extract+0x334> <== ALWAYS TAKEN
400298ec: b9401865 ldr w5, [x3, #24]
400298f0: f9400064 ldr x4, [x3]
400298f4: b9001825 str w5, [x1, #24]
400298f8: b900187f str wzr, [x3, #24]
400298fc: b900185f str wzr, [x2, #24]
40029900: f9400481 ldr x1, [x4, #8]
40029904: f9000061 str x1, [x3]
40029908: b4000041 cbz x1, 40029910 <_RBTree_Extract+0x300>
4002990c: f9000823 str x3, [x1, #16]
40029910: f9400861 ldr x1, [x3, #16]
40029914: f9000881 str x1, [x4, #16]
40029918: b4000481 cbz x1, 400299a8 <_RBTree_Extract+0x398>
4002991c: f9400862 ldr x2, [x3, #16]
40029920: f9400042 ldr x2, [x2]
40029924: eb02007f cmp x3, x2
40029928: 540007c0 b.eq 40029a20 <_RBTree_Extract+0x410> // b.none
4002992c: f9000424 str x4, [x1, #8]
40029930: f9400001 ldr x1, [x0]
40029934: f9000483 str x3, [x4, #8]
40029938: f9000864 str x4, [x3, #16]
4002993c: b5fff4c1 cbnz x1, 400297d4 <_RBTree_Extract+0x1c4> <== ALWAYS TAKEN
40029940: 17ffff5f b 400296bc <_RBTree_Extract+0xac> <== NOT EXECUTED
40029944: f9400082 ldr x2, [x4]
40029948: b900189f str wzr, [x4, #24]
4002994c: 52800025 mov w5, #0x1 // #1
40029950: f9000422 str x2, [x1, #8]
40029954: b9001825 str w5, [x1, #24]
40029958: b4000042 cbz x2, 40029960 <_RBTree_Extract+0x350>
4002995c: f9000841 str x1, [x2, #16]
40029960: f9400822 ldr x2, [x1, #16]
40029964: f9000882 str x2, [x4, #16]
40029968: b40001c2 cbz x2, 400299a0 <_RBTree_Extract+0x390> <== NEVER TAKEN
4002996c: f9400045 ldr x5, [x2]
40029970: eb05003f cmp x1, x5
40029974: 540005c0 b.eq 40029a2c <_RBTree_Extract+0x41c> // b.none <== ALWAYS TAKEN
40029978: f9000444 str x4, [x2, #8] <== NOT EXECUTED
4002997c: f9000081 str x1, [x4]
40029980: f9000824 str x4, [x1, #16]
40029984: f9400064 ldr x4, [x3]
40029988: b9401861 ldr w1, [x3, #24]
4002998c: f9400082 ldr x2, [x4]
40029990: b9001881 str w1, [x4, #24]
40029994: b900187f str wzr, [x3, #24]
40029998: b4fffb42 cbz x2, 40029900 <_RBTree_Extract+0x2f0> <== NEVER TAKEN
4002999c: 17ffffd8 b 400298fc <_RBTree_Extract+0x2ec>
400299a0: f9000004 str x4, [x0] <== NOT EXECUTED
400299a4: 17fffff6 b 4002997c <_RBTree_Extract+0x36c> <== NOT EXECUTED
400299a8: aa0403e1 mov x1, x4
400299ac: f9000004 str x4, [x0]
400299b0: 17ffffe1 b 40029934 <_RBTree_Extract+0x324>
400299b4: f9400424 ldr x4, [x1, #8]
400299b8: b4000064 cbz x4, 400299c4 <_RBTree_Extract+0x3b4>
400299bc: b9401885 ldr w5, [x4, #24]
400299c0: 35ffee25 cbnz w5, 40029784 <_RBTree_Extract+0x174>
400299c4: f9400444 ldr x4, [x2, #8]
400299c8: b900185f str wzr, [x2, #24]
400299cc: 52800025 mov w5, #0x1 // #1
400299d0: f9000024 str x4, [x1]
400299d4: b9001825 str w5, [x1, #24]
400299d8: b4000044 cbz x4, 400299e0 <_RBTree_Extract+0x3d0>
400299dc: f9000881 str x1, [x4, #16]
400299e0: f9400824 ldr x4, [x1, #16]
400299e4: f9000844 str x4, [x2, #16]
400299e8: b4000324 cbz x4, 40029a4c <_RBTree_Extract+0x43c> <== NEVER TAKEN
400299ec: f9400085 ldr x5, [x4]
400299f0: eb05003f cmp x1, x5
400299f4: 54000300 b.eq 40029a54 <_RBTree_Extract+0x444> // b.none <== NEVER TAKEN
400299f8: f9000482 str x2, [x4, #8]
400299fc: f9000441 str x1, [x2, #8]
40029a00: f9000822 str x2, [x1, #16]
40029a04: f9400462 ldr x2, [x3, #8]
40029a08: b9401861 ldr w1, [x3, #24]
40029a0c: f9400444 ldr x4, [x2, #8]
40029a10: b9001841 str w1, [x2, #24]
40029a14: b900187f str wzr, [x3, #24]
40029a18: b4ffec04 cbz x4, 40029798 <_RBTree_Extract+0x188> <== NEVER TAKEN
40029a1c: 17ffff5e b 40029794 <_RBTree_Extract+0x184>
40029a20: f9000024 str x4, [x1]
40029a24: f9400001 ldr x1, [x0]
40029a28: 17ffffc3 b 40029934 <_RBTree_Extract+0x324>
40029a2c: f9000044 str x4, [x2]
40029a30: 17ffffd3 b 4002997c <_RBTree_Extract+0x36c>
40029a34: aa0203e1 mov x1, x2
40029a38: f9000002 str x2, [x0]
40029a3c: 17ffff63 b 400297c8 <_RBTree_Extract+0x1b8>
40029a40: f9000022 str x2, [x1]
40029a44: f9400001 ldr x1, [x0]
40029a48: 17ffff60 b 400297c8 <_RBTree_Extract+0x1b8>
40029a4c: f9000002 str x2, [x0] <== NOT EXECUTED
40029a50: 17ffffeb b 400299fc <_RBTree_Extract+0x3ec> <== NOT EXECUTED
40029a54: f9000082 str x2, [x4] <== NOT EXECUTED
40029a58: 17ffffe9 b 400299fc <_RBTree_Extract+0x3ec> <== NOT EXECUTED
40029a5c: 00000000 udf #0
0000000040029a60 <_RBTree_Insert_color>:
#include "config.h"
#endif
#include <rtems/score/rbtreeimpl.h>
RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline )
40029a60: 52800026 mov w6, #0x1 // #1
40029a64: f9400822 ldr x2, [x1, #16]
40029a68: b4000422 cbz x2, 40029aec <_RBTree_Insert_color+0x8c>
40029a6c: b9401843 ldr w3, [x2, #24]
40029a70: 7100047f cmp w3, #0x1
40029a74: 540003c1 b.ne 40029aec <_RBTree_Insert_color+0x8c> // b.any
40029a78: f9400843 ldr x3, [x2, #16]
40029a7c: f9400064 ldr x4, [x3]
40029a80: eb02009f cmp x4, x2
40029a84: 540003a0 b.eq 40029af8 <_RBTree_Insert_color+0x98> // b.none
40029a88: b4000084 cbz x4, 40029a98 <_RBTree_Insert_color+0x38>
40029a8c: b9401885 ldr w5, [x4, #24]
40029a90: 710004bf cmp w5, #0x1
40029a94: 540008a0 b.eq 40029ba8 <_RBTree_Insert_color+0x148> // b.none
40029a98: f9400044 ldr x4, [x2]
40029a9c: eb01009f cmp x4, x1
40029aa0: 54000620 b.eq 40029b64 <_RBTree_Insert_color+0x104> // b.none
40029aa4: f9400464 ldr x4, [x3, #8]
40029aa8: b900185f str wzr, [x2, #24]
40029aac: f9400082 ldr x2, [x4]
40029ab0: f9000462 str x2, [x3, #8]
40029ab4: b9001866 str w6, [x3, #24]
40029ab8: b4000042 cbz x2, 40029ac0 <_RBTree_Insert_color+0x60>
40029abc: f9000843 str x3, [x2, #16]
40029ac0: f9400862 ldr x2, [x3, #16]
40029ac4: f9000882 str x2, [x4, #16]
40029ac8: b40004a2 cbz x2, 40029b5c <_RBTree_Insert_color+0xfc>
40029acc: f9400045 ldr x5, [x2]
40029ad0: eb05007f cmp x3, x5
40029ad4: 54000740 b.eq 40029bbc <_RBTree_Insert_color+0x15c> // b.none
40029ad8: f9000444 str x4, [x2, #8]
40029adc: f9000083 str x3, [x4]
40029ae0: f9000864 str x4, [x3, #16]
40029ae4: f9400822 ldr x2, [x1, #16]
40029ae8: b5fffc22 cbnz x2, 40029a6c <_RBTree_Insert_color+0xc> <== ALWAYS TAKEN
40029aec: f9400000 ldr x0, [x0]
40029af0: b900181f str wzr, [x0, #24]
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Control_RB_INSERT_COLOR( the_rbtree, the_node );
}
40029af4: d65f03c0 ret
RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline )
40029af8: f9400464 ldr x4, [x3, #8]
40029afc: b4000084 cbz x4, 40029b0c <_RBTree_Insert_color+0xac>
40029b00: b9401885 ldr w5, [x4, #24]
40029b04: 710004bf cmp w5, #0x1
40029b08: 54000500 b.eq 40029ba8 <_RBTree_Insert_color+0x148> // b.none
40029b0c: f9400445 ldr x5, [x2, #8]
40029b10: aa0203e4 mov x4, x2
40029b14: eb0100bf cmp x5, x1
40029b18: 54000560 b.eq 40029bc4 <_RBTree_Insert_color+0x164> // b.none
40029b1c: f9400485 ldr x5, [x4, #8]
40029b20: b900185f str wzr, [x2, #24]
40029b24: f9000065 str x5, [x3]
40029b28: b9001866 str w6, [x3, #24]
40029b2c: b4000045 cbz x5, 40029b34 <_RBTree_Insert_color+0xd4>
40029b30: f90008a3 str x3, [x5, #16]
40029b34: f9400862 ldr x2, [x3, #16]
40029b38: f9000882 str x2, [x4, #16]
40029b3c: b4000682 cbz x2, 40029c0c <_RBTree_Insert_color+0x1ac>
40029b40: f9400045 ldr x5, [x2]
40029b44: eb05007f cmp x3, x5
40029b48: 54000660 b.eq 40029c14 <_RBTree_Insert_color+0x1b4> // b.none
40029b4c: f9000444 str x4, [x2, #8]
40029b50: f9000483 str x3, [x4, #8]
40029b54: f9000864 str x4, [x3, #16]
40029b58: 17ffffc3 b 40029a64 <_RBTree_Insert_color+0x4>
40029b5c: f9000004 str x4, [x0]
40029b60: 17ffffdf b 40029adc <_RBTree_Insert_color+0x7c>
40029b64: f9400424 ldr x4, [x1, #8]
40029b68: f9000044 str x4, [x2]
40029b6c: b40005c4 cbz x4, 40029c24 <_RBTree_Insert_color+0x1c4>
40029b70: f9000882 str x2, [x4, #16]
40029b74: f9400844 ldr x4, [x2, #16]
40029b78: f9000824 str x4, [x1, #16]
40029b7c: b4000504 cbz x4, 40029c1c <_RBTree_Insert_color+0x1bc> <== NEVER TAKEN
40029b80: f9400085 ldr x5, [x4]
40029b84: eb0200bf cmp x5, x2
40029b88: 54000580 b.eq 40029c38 <_RBTree_Insert_color+0x1d8> // b.none <== NEVER TAKEN
40029b8c: f9000481 str x1, [x4, #8]
40029b90: aa0103e4 mov x4, x1
40029b94: f9000422 str x2, [x1, #8]
40029b98: f9000841 str x1, [x2, #16]
40029b9c: aa0203e1 mov x1, x2
40029ba0: aa0403e2 mov x2, x4
40029ba4: 17ffffc0 b 40029aa4 <_RBTree_Insert_color+0x44>
40029ba8: b900189f str wzr, [x4, #24]
40029bac: aa0303e1 mov x1, x3
40029bb0: b900185f str wzr, [x2, #24]
40029bb4: b9001865 str w5, [x3, #24]
40029bb8: 17ffffab b 40029a64 <_RBTree_Insert_color+0x4>
40029bbc: f9000044 str x4, [x2]
40029bc0: 17ffffc7 b 40029adc <_RBTree_Insert_color+0x7c>
40029bc4: f9400024 ldr x4, [x1]
40029bc8: f9000444 str x4, [x2, #8]
40029bcc: b40003a4 cbz x4, 40029c40 <_RBTree_Insert_color+0x1e0>
40029bd0: f9000882 str x2, [x4, #16]
40029bd4: f9400844 ldr x4, [x2, #16]
40029bd8: f9000824 str x4, [x1, #16]
40029bdc: b40003a4 cbz x4, 40029c50 <_RBTree_Insert_color+0x1f0> <== NEVER TAKEN
40029be0: f9400085 ldr x5, [x4]
40029be4: eb0200bf cmp x5, x2
40029be8: 54000300 b.eq 40029c48 <_RBTree_Insert_color+0x1e8> // b.none <== ALWAYS TAKEN
40029bec: f9000481 str x1, [x4, #8] <== NOT EXECUTED
40029bf0: f9000022 str x2, [x1]
40029bf4: aa0103e5 mov x5, x1
40029bf8: f9400064 ldr x4, [x3]
40029bfc: f9000841 str x1, [x2, #16]
40029c00: aa0203e1 mov x1, x2
40029c04: aa0503e2 mov x2, x5
40029c08: 17ffffc5 b 40029b1c <_RBTree_Insert_color+0xbc>
40029c0c: f9000004 str x4, [x0]
40029c10: 17ffffd0 b 40029b50 <_RBTree_Insert_color+0xf0>
40029c14: f9000044 str x4, [x2]
40029c18: 17ffffce b 40029b50 <_RBTree_Insert_color+0xf0>
40029c1c: f9000001 str x1, [x0] <== NOT EXECUTED
40029c20: 17ffffdc b 40029b90 <_RBTree_Insert_color+0x130> <== NOT EXECUTED
40029c24: aa0303e4 mov x4, x3
40029c28: f9000823 str x3, [x1, #16]
40029c2c: f9400085 ldr x5, [x4]
40029c30: eb0200bf cmp x5, x2
40029c34: 54fffac1 b.ne 40029b8c <_RBTree_Insert_color+0x12c> // b.any <== ALWAYS TAKEN
40029c38: f9000081 str x1, [x4] <== NOT EXECUTED
40029c3c: 17ffffd5 b 40029b90 <_RBTree_Insert_color+0x130> <== NOT EXECUTED
40029c40: aa0303e4 mov x4, x3
40029c44: f9000823 str x3, [x1, #16]
40029c48: f9000081 str x1, [x4]
40029c4c: 17ffffe9 b 40029bf0 <_RBTree_Insert_color+0x190>
40029c50: f9000001 str x1, [x0] <== NOT EXECUTED
40029c54: 17ffffe7 b 40029bf0 <_RBTree_Insert_color+0x190> <== NOT EXECUTED
...
0000000040026430 <_RBTree_Postorder_first>:
return RB_ROOT( the_rbtree );
40026430: f9400000 ldr x0, [x0]
)
{
const RBTree_Node *the_node;
the_node = _RBTree_Root( the_rbtree );
if ( the_node == NULL ) {
40026434: b40000e0 cbz x0, 40026450 <_RBTree_Postorder_first+0x20>
return RB_LEFT( the_node, Node );
40026438: aa0003e2 mov x2, x0
4002643c: f9400000 ldr x0, [x0]
if ( _RBTree_Left( the_node ) != NULL ) {
40026440: b5ffffc0 cbnz x0, 40026438 <_RBTree_Postorder_first+0x8> <== NEVER TAKEN
return RB_RIGHT( the_node, Node );
40026444: f9400440 ldr x0, [x2, #8]
} else if ( _RBTree_Right( the_node ) != NULL ) {
40026448: b5ffff80 cbnz x0, 40026438 <_RBTree_Postorder_first+0x8> <== NEVER TAKEN
return (void *) ( (uintptr_t) the_node - offset );
4002644c: cb010040 sub x0, x2, x1
return NULL;
}
return _RBTree_Postorder_dive_left( the_node, offset );
}
40026450: d65f03c0 ret
...
0000000040025c20 <_RBTree_Predecessor>:
RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static )
40025c20: f9400001 ldr x1, [x0]
RBTree_Node *_RBTree_Predecessor( const RBTree_Node *node )
{
40025c24: aa0003e2 mov x2, x0
RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static )
40025c28: b40000c1 cbz x1, 40025c40 <_RBTree_Predecessor+0x20>
40025c2c: d503201f nop
40025c30: aa0103e0 mov x0, x1
40025c34: f9400421 ldr x1, [x1, #8]
40025c38: b5ffffc1 cbnz x1, 40025c30 <_RBTree_Predecessor+0x10>
return RB_PREV( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
}
40025c3c: d65f03c0 ret
RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static )
40025c40: f9400800 ldr x0, [x0, #16]
40025c44: b4ffffc0 cbz x0, 40025c3c <_RBTree_Predecessor+0x1c>
40025c48: f9400401 ldr x1, [x0, #8]
40025c4c: eb01005f cmp x2, x1
40025c50: 54ffff60 b.eq 40025c3c <_RBTree_Predecessor+0x1c> // b.none
40025c54: f9400001 ldr x1, [x0]
40025c58: eb02003f cmp x1, x2
40025c5c: 54ffff01 b.ne 40025c3c <_RBTree_Predecessor+0x1c> // b.any <== NEVER TAKEN
40025c60: f9400801 ldr x1, [x0, #16]
40025c64: aa0003e2 mov x2, x0
40025c68: aa0103e0 mov x0, x1
40025c6c: b40000a1 cbz x1, 40025c80 <_RBTree_Predecessor+0x60> <== NEVER TAKEN
40025c70: f9400001 ldr x1, [x0]
40025c74: eb02003f cmp x1, x2
40025c78: 54ffff40 b.eq 40025c60 <_RBTree_Predecessor+0x40> // b.none <== NEVER TAKEN
}
40025c7c: d65f03c0 ret
40025c80: d2800000 mov x0, #0x0 // #0 <== NOT EXECUTED
40025c84: d65f03c0 ret <== NOT EXECUTED
...
0000000040025bb0 <_RBTree_Successor>:
RB_GENERATE_NEXT( RBTree_Control, RBTree_Node, Node, static )
40025bb0: f9400401 ldr x1, [x0, #8]
{
return RB_MAX( RBTree_Control, RTEMS_DECONST( RBTree_Control *, tree ) );
}
RBTree_Node *_RBTree_Successor( const RBTree_Node *node )
{
40025bb4: aa0003e2 mov x2, x0
RB_GENERATE_NEXT( RBTree_Control, RBTree_Node, Node, static )
40025bb8: b40000c1 cbz x1, 40025bd0 <_RBTree_Successor+0x20>
40025bbc: d503201f nop
40025bc0: aa0103e0 mov x0, x1
40025bc4: f9400021 ldr x1, [x1]
40025bc8: b5ffffc1 cbnz x1, 40025bc0 <_RBTree_Successor+0x10>
return RB_NEXT( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
}
40025bcc: d65f03c0 ret
RB_GENERATE_NEXT( RBTree_Control, RBTree_Node, Node, static )
40025bd0: f9400800 ldr x0, [x0, #16]
40025bd4: b4ffffc0 cbz x0, 40025bcc <_RBTree_Successor+0x1c>
40025bd8: f9400001 ldr x1, [x0]
40025bdc: eb01005f cmp x2, x1
40025be0: 54ffff60 b.eq 40025bcc <_RBTree_Successor+0x1c> // b.none
40025be4: f9400401 ldr x1, [x0, #8]
40025be8: eb02003f cmp x1, x2
40025bec: 54ffff01 b.ne 40025bcc <_RBTree_Successor+0x1c> // b.any <== NEVER TAKEN
40025bf0: f9400801 ldr x1, [x0, #16]
40025bf4: aa0003e2 mov x2, x0
40025bf8: aa0103e0 mov x0, x1
40025bfc: b40000a1 cbz x1, 40025c10 <_RBTree_Successor+0x60>
40025c00: f9400401 ldr x1, [x0, #8]
40025c04: eb02003f cmp x1, x2
40025c08: 54ffff40 b.eq 40025bf0 <_RBTree_Successor+0x40> // b.none
}
40025c0c: d65f03c0 ret
40025c10: d2800000 mov x0, #0x0 // #0
40025c14: d65f03c0 ret
...
000000004002d720 <_SMP_barrier_Wait>:
SMP_barrier_Control *control,
SMP_barrier_State *state,
unsigned int count
)
{
unsigned int sense = ~state->sense;
4002d720: b9400024 ldr w4, [x1]
{
4002d724: aa0003e3 mov x3, x0
unsigned int sense = ~state->sense;
4002d728: 2a2403e4 mvn w4, w4
unsigned int previous_value;
bool performed_release;
state->sense = sense;
4002d72c: b9000024 str w4, [x1]
__asm__ volatile (
4002d730: d53b4221 mrs x1, daif
4002d734: d50342df msr daifset, #0x2
*obj = val + arg;
4002d738: b9400000 ldr w0, [x0]
4002d73c: 11000400 add w0, w0, #0x1
4002d740: b9000060 str w0, [x3]
__asm__ volatile (
4002d744: 92407c21 and x1, x1, #0xffffffff
4002d748: d51b4221 msr daif, x1
&control->value,
1U,
ATOMIC_ORDER_RELAXED
);
if ( previous_value + 1U == count ) {
4002d74c: 6b00005f cmp w2, w0
4002d750: 540000e0 b.eq 4002d76c <_SMP_barrier_Wait+0x4c> // b.none <== ALWAYS TAKEN
4002d754: d503201f nop
val = *obj;
4002d758: b9400461 ldr w1, [x3, #4] <== NOT EXECUTED
_Atomic_Store_uint( &control->value, 0U, ATOMIC_ORDER_RELAXED );
_Atomic_Store_uint( &control->sense, sense, ATOMIC_ORDER_RELEASE );
performed_release = true;
} else {
while (
4002d75c: 6b01009f cmp w4, w1 <== NOT EXECUTED
4002d760: 54ffffc1 b.ne 4002d758 <_SMP_barrier_Wait+0x38> // b.any <== NOT EXECUTED
_Atomic_Load_uint( &control->sense, ATOMIC_ORDER_ACQUIRE ) != sense
) {
/* Wait */
}
performed_release = false;
4002d764: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
}
return performed_release;
}
4002d768: d65f03c0 ret <== NOT EXECUTED
*obj = desired;
4002d76c: b900007f str wzr, [x3]
performed_release = true;
4002d770: 52800020 mov w0, #0x1 // #1
4002d774: b9000464 str w4, [x3, #4]
}
4002d778: d65f03c0 ret
4002d77c: 00000000 udf #0
0000000040025c30 <_Scheduler_CBS_Attach_thread>:
Scheduler_CBS_Server *server;
ISR_lock_Context lock_context;
Thread_Control *the_thread;
Scheduler_CBS_Node *node;
if ( server_id >= _Scheduler_CBS_Maximum_servers ) {
40025c30: f0000082 adrp x2, 40038000 <_Heap_Resize_block+0xf0>
40025c34: b9487042 ldr w2, [x2, #2160]
40025c38: 6b00005f cmp w2, w0
40025c3c: 54000689 b.ls 40025d0c <_Scheduler_CBS_Attach_thread+0xdc> // b.plast
{
40025c40: a9bc7bfd stp x29, x30, [sp, #-64]!
40025c44: 910003fd mov x29, sp
40025c48: a9025bf5 stp x21, x22, [sp, #32]
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
}
server = &_Scheduler_CBS_Server_list[ server_id ];
if ( !server->initialized ) {
40025c4c: 2a0003f5 mov w21, w0
40025c50: 2a0103f6 mov w22, w1
40025c54: d2800501 mov x1, #0x28 // #40
{
40025c58: a90153f3 stp x19, x20, [sp, #16]
server = &_Scheduler_CBS_Server_list[ server_id ];
40025c5c: b00006f4 adrp x20, 40102000 <_Rate_monotonic_Objects+0x120>
40025c60: 911fc294 add x20, x20, #0x7f0
if ( !server->initialized ) {
40025c64: 9b017eb5 mul x21, x21, x1
server = &_Scheduler_CBS_Server_list[ server_id ];
40025c68: 52800513 mov w19, #0x28 // #40
40025c6c: 9bb35013 umaddl x19, w0, w19, x20
if ( !server->initialized ) {
40025c70: 8b150280 add x0, x20, x21
40025c74: 39408000 ldrb w0, [x0, #32]
40025c78: 34000460 cbz w0, 40025d04 <_Scheduler_CBS_Attach_thread+0xd4>
return SCHEDULER_CBS_ERROR_NOSERVER;
}
if ( server->task_id != -1 ) {
40025c7c: b8756a80 ldr w0, [x20, x21]
40025c80: 3100041f cmn w0, #0x1
40025c84: 54000301 b.ne 40025ce4 <_Scheduler_CBS_Attach_thread+0xb4> // b.any
return SCHEDULER_CBS_ERROR_FULL;
}
the_thread = _Thread_Get( task_id, &lock_context );
40025c88: 9100e3e1 add x1, sp, #0x38
40025c8c: 2a1603e0 mov w0, w22
40025c90: 94000508 bl 400270b0 <_Thread_Get>
if ( the_thread == NULL ) {
40025c94: b4000340 cbz x0, 40025cfc <_Scheduler_CBS_Attach_thread+0xcc>
return the_thread->Scheduler.nodes;
40025c98: f9403401 ldr x1, [x0, #104]
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
}
node = _Scheduler_CBS_Thread_get_node( the_thread );
if ( node->cbs_server != NULL ) {
40025c9c: f9403c22 ldr x2, [x1, #120]
40025ca0: b5000262 cbnz x2, 40025cec <_Scheduler_CBS_Attach_thread+0xbc> <== NEVER TAKEN
_ISR_lock_ISR_enable( &lock_context );
return SCHEDULER_CBS_ERROR_FULL;
}
node->cbs_server = server;
40025ca4: f9003c33 str x19, [x1, #120]
server->task_id = task_id;
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
40025ca8: 52800062 mov w2, #0x3 // #3
server->task_id = task_id;
40025cac: b8356a96 str w22, [x20, x21]
the_thread->is_preemptible = true;
40025cb0: 52800023 mov w3, #0x1 // #1
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
40025cb4: 90000001 adrp x1, 40025000 <_Rate_monotonic_Timeout+0x80>
40025cb8: 91348021 add x1, x1, #0xd20
the_thread->is_preemptible = true;
40025cbc: 3903a403 strb w3, [x0, #233]
the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
40025cc0: b900f002 str w2, [x0, #240]
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
40025cc4: f9007c01 str x1, [x0, #248]
_ISR_lock_ISR_enable( &lock_context );
40025cc8: b9403be0 ldr w0, [sp, #56]
40025ccc: d51b4220 msr daif, x0
return SCHEDULER_CBS_OK;
40025cd0: 52800000 mov w0, #0x0 // #0
}
40025cd4: a94153f3 ldp x19, x20, [sp, #16]
40025cd8: a9425bf5 ldp x21, x22, [sp, #32]
40025cdc: a8c47bfd ldp x29, x30, [sp], #64
40025ce0: d65f03c0 ret
return SCHEDULER_CBS_ERROR_FULL;
40025ce4: 12800320 mov w0, #0xffffffe6 // #-26
40025ce8: 17fffffb b 40025cd4 <_Scheduler_CBS_Attach_thread+0xa4>
_ISR_lock_ISR_enable( &lock_context );
40025cec: b9403be0 ldr w0, [sp, #56] <== NOT EXECUTED
40025cf0: d51b4220 msr daif, x0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_FULL;
40025cf4: 12800320 mov w0, #0xffffffe6 // #-26 <== NOT EXECUTED
40025cf8: 17fffff7 b 40025cd4 <_Scheduler_CBS_Attach_thread+0xa4> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
40025cfc: 12800220 mov w0, #0xffffffee // #-18
40025d00: 17fffff5 b 40025cd4 <_Scheduler_CBS_Attach_thread+0xa4>
return SCHEDULER_CBS_ERROR_NOSERVER;
40025d04: 12800300 mov w0, #0xffffffe7 // #-25
40025d08: 17fffff3 b 40025cd4 <_Scheduler_CBS_Attach_thread+0xa4>
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
40025d0c: 12800220 mov w0, #0xffffffee // #-18
}
40025d10: d65f03c0 ret
...
0000000040025d20 <_Scheduler_CBS_Budget_callout>:
#include <rtems/score/schedulercbsimpl.h>
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
40025d20: a9b97bfd stp x29, x30, [sp, #-112]!
40025d24: aa0003e1 mov x1, x0
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(
40025d28: d2800000 mov x0, #0x0 // #0
{
40025d2c: 910003fd mov x29, sp
40025d30: f9000bf3 str x19, [sp, #16]
_Scheduler_CBS_Cancel_job(
40025d34: 9100c3e3 add x3, sp, #0x30
40025d38: f9403433 ldr x19, [x1, #104]
queue_context->Priority.update_count = 0;
40025d3c: f9002bff str xzr, [sp, #80]
40025d40: f9404262 ldr x2, [x19, #128]
40025d44: 94000163 bl 400262d0 <_Scheduler_CBS_Cancel_job>
NULL,
the_thread,
node->deadline_node,
&queue_context
);
_Thread_Priority_update( &queue_context );
40025d48: 9100c3e0 add x0, sp, #0x30
40025d4c: 94000419 bl 40026db0 <_Thread_Priority_update>
/* Invoke callback function if any. */
if ( node->cbs_server->cbs_budget_overrun ) {
40025d50: f9403e60 ldr x0, [x19, #120]
40025d54: f9400c01 ldr x1, [x0, #24]
40025d58: b4000101 cbz x1, 40025d78 <_Scheduler_CBS_Budget_callout+0x58> <== NEVER TAKEN
_Scheduler_CBS_Get_server_id(
40025d5c: b9400000 ldr w0, [x0]
40025d60: 9100b3e1 add x1, sp, #0x2c
40025d64: 94000133 bl 40026230 <_Scheduler_CBS_Get_server_id>
node->cbs_server->task_id,
&server_id
);
node->cbs_server->cbs_budget_overrun( server_id );
40025d68: f9403e61 ldr x1, [x19, #120]
40025d6c: b9402fe0 ldr w0, [sp, #44]
40025d70: f9400c21 ldr x1, [x1, #24]
40025d74: d63f0020 blr x1
} }
40025d78: f9400bf3 ldr x19, [sp, #16]
40025d7c: a8c77bfd ldp x29, x30, [sp], #112
40025d80: d65f03c0 ret
...
0000000040025da0 <_Scheduler_CBS_Cleanup>:
#include <rtems/score/schedulercbs.h>
#include <rtems/score/wkspace.h>
int _Scheduler_CBS_Cleanup (void)
{
40025da0: a9bd7bfd stp x29, x30, [sp, #-48]!
40025da4: 910003fd mov x29, sp
40025da8: f90013f5 str x21, [sp, #32]
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
40025dac: f0000080 adrp x0, 40038000 <_Heap_Resize_block+0xf0>
40025db0: b9487015 ldr w21, [x0, #2160]
40025db4: 34000255 cbz w21, 40025dfc <_Scheduler_CBS_Cleanup+0x5c> <== NEVER TAKEN
40025db8: a90153f3 stp x19, x20, [sp, #16]
40025dbc: b00006f4 adrp x20, 40102000 <_Rate_monotonic_Objects+0x120>
40025dc0: 911fc294 add x20, x20, #0x7f0
40025dc4: 52800013 mov w19, #0x0 // #0
40025dc8: 14000004 b 40025dd8 <_Scheduler_CBS_Cleanup+0x38>
40025dcc: 11000673 add w19, w19, #0x1
40025dd0: 6b15027f cmp w19, w21
40025dd4: 54000120 b.eq 40025df8 <_Scheduler_CBS_Cleanup+0x58> // b.none
if ( _Scheduler_CBS_Server_list[ i ].initialized )
40025dd8: 39408280 ldrb w0, [x20, #32]
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
40025ddc: 9100a294 add x20, x20, #0x28
if ( _Scheduler_CBS_Server_list[ i ].initialized )
40025de0: 34ffff60 cbz w0, 40025dcc <_Scheduler_CBS_Cleanup+0x2c>
_Scheduler_CBS_Destroy_server( i );
40025de4: 2a1303e0 mov w0, w19
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
40025de8: 11000673 add w19, w19, #0x1
_Scheduler_CBS_Destroy_server( i );
40025dec: 94000035 bl 40025ec0 <_Scheduler_CBS_Destroy_server>
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
40025df0: 6b15027f cmp w19, w21
40025df4: 54ffff21 b.ne 40025dd8 <_Scheduler_CBS_Cleanup+0x38> // b.any <== ALWAYS TAKEN
40025df8: a94153f3 ldp x19, x20, [sp, #16]
} return SCHEDULER_CBS_OK; }
40025dfc: 52800000 mov w0, #0x0 // #0
40025e00: f94013f5 ldr x21, [sp, #32]
40025e04: a8c37bfd ldp x29, x30, [sp], #48
40025e08: d65f03c0 ret
40025e0c: 00000000 udf #0
0000000040025e10 <_Scheduler_CBS_Create_server>:
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
40025e10: aa0003e7 mov x7, x0
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
40025e14: f9400400 ldr x0, [x0, #8]
40025e18: f100001f cmp x0, #0x0
40025e1c: 5400048d b.le 40025eac <_Scheduler_CBS_Create_server+0x9c>
40025e20: f94000e0 ldr x0, [x7]
40025e24: f100001f cmp x0, #0x0
40025e28: 5400042d b.le 40025eac <_Scheduler_CBS_Create_server+0x9c>
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++ ) {
40025e2c: f0000080 adrp x0, 40038000 <_Heap_Resize_block+0xf0>
40025e30: b9487006 ldr w6, [x0, #2160]
40025e34: 34000386 cbz w6, 40025ea4 <_Scheduler_CBS_Create_server+0x94> <== NEVER TAKEN
40025e38: b00006e8 adrp x8, 40102000 <_Rate_monotonic_Objects+0x120>
40025e3c: 911fc108 add x8, x8, #0x7f0
40025e40: aa0803e4 mov x4, x8
40025e44: 52800003 mov w3, #0x0 // #0
40025e48: 14000004 b 40025e58 <_Scheduler_CBS_Create_server+0x48>
40025e4c: 11000463 add w3, w3, #0x1
40025e50: 6b0300df cmp w6, w3
40025e54: 54000280 b.eq 40025ea4 <_Scheduler_CBS_Create_server+0x94> // b.none
if ( !_Scheduler_CBS_Server_list[i].initialized )
40025e58: 39408085 ldrb w5, [x4, #32]
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
40025e5c: 9100a084 add x4, x4, #0x28
if ( !_Scheduler_CBS_Server_list[i].initialized )
40025e60: 35ffff65 cbnz w5, 40025e4c <_Scheduler_CBS_Create_server+0x3c>
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
the_server = &_Scheduler_CBS_Server_list[*server_id];
the_server->parameters = *params;
40025e64: 2a0303e0 mov w0, w3
40025e68: d2800504 mov x4, #0x28 // #40
40025e6c: f94000e6 ldr x6, [x7]
*server_id = i;
40025e70: b9000043 str w3, [x2]
the_server->parameters = *params;
40025e74: 9b047c03 mul x3, x0, x4
the_server->task_id = -1;
40025e78: 12800005 mov w5, #0xffffffff // #-1
the_server->cbs_budget_overrun = budget_overrun_callback; the_server->initialized = true;
40025e7c: 52800024 mov w4, #0x1 // #1
return SCHEDULER_CBS_OK;
40025e80: 52800000 mov w0, #0x0 // #0
the_server->parameters = *params;
40025e84: 8b030102 add x2, x8, x3
40025e88: f9000446 str x6, [x2, #8]
40025e8c: f94004e6 ldr x6, [x7, #8]
40025e90: f9000846 str x6, [x2, #16]
the_server->task_id = -1;
40025e94: b8236905 str w5, [x8, x3]
the_server->cbs_budget_overrun = budget_overrun_callback;
40025e98: f9000c41 str x1, [x2, #24]
the_server->initialized = true;
40025e9c: 39008044 strb w4, [x2, #32]
}
40025ea0: d65f03c0 ret
return SCHEDULER_CBS_ERROR_FULL;
40025ea4: 12800320 mov w0, #0xffffffe6 // #-26
}
40025ea8: d65f03c0 ret
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
40025eac: 12800220 mov w0, #0xffffffee // #-18
}
40025eb0: d65f03c0 ret
...
0000000040026230 <_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++ ) {
40026230: d0000082 adrp x2, 40038000 <_Heap_Resize_block+0xf0>
40026234: b9487045 ldr w5, [x2, #2160]
40026238: 340001a5 cbz w5, 4002626c <_Scheduler_CBS_Get_server_id+0x3c> <== NEVER TAKEN
4002623c: 900006e2 adrp x2, 40102000 <_Rate_monotonic_Objects+0x120>
40026240: 911fc042 add x2, x2, #0x7f0
40026244: 52800003 mov w3, #0x0 // #0
if ( _Scheduler_CBS_Server_list[i].initialized &&
40026248: 39408044 ldrb w4, [x2, #32]
4002624c: 34000084 cbz w4, 4002625c <_Scheduler_CBS_Get_server_id+0x2c>
40026250: b9400044 ldr w4, [x2]
40026254: 6b00009f cmp w4, w0
40026258: 540000e0 b.eq 40026274 <_Scheduler_CBS_Get_server_id+0x44> // b.none
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4002625c: 11000463 add w3, w3, #0x1
40026260: 9100a042 add x2, x2, #0x28
40026264: 6b05007f cmp w3, w5
40026268: 54ffff01 b.ne 40026248 <_Scheduler_CBS_Get_server_id+0x18> // b.any
_Scheduler_CBS_Server_list[i].task_id == task_id ) {
*server_id = i;
return SCHEDULER_CBS_OK;
}
}
return SCHEDULER_CBS_ERROR_NOSERVER;
4002626c: 12800300 mov w0, #0xffffffe7 // #-25
}
40026270: d65f03c0 ret
return SCHEDULER_CBS_OK;
40026274: 52800000 mov w0, #0x0 // #0
*server_id = i;
40026278: b9000023 str w3, [x1]
}
4002627c: d65f03c0 ret
00000000400255b0 <_Scheduler_CBS_Unblock>:
void _Scheduler_CBS_Unblock(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
400255b0: a9b97bfd stp x29, x30, [sp, #-112]!
400255b4: 910003fd mov x29, sp
400255b8: a90153f3 stp x19, x20, [sp, #16]
400255bc: aa0203f3 mov x19, x2
400255c0: aa0103f4 mov x20, x1
Priority_Control priority;
the_node = _Scheduler_CBS_Node_downcast( node );
serv_info = the_node->cbs_server;
priority = _Scheduler_Node_get_priority( &the_node->Base.Base );
priority = SCHEDULER_PRIORITY_PURIFY( priority );
400255c4: f9402443 ldr x3, [x2, #72]
serv_info = the_node->cbs_server;
400255c8: f9403c42 ldr x2, [x2, #120]
{
400255cc: f90013f5 str x21, [sp, #32]
priority = SCHEDULER_PRIORITY_PURIFY( priority );
400255d0: 927ff863 and x3, x3, #0xfffffffffffffffe
{
400255d4: aa0003f5 mov x21, x0
* 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 ) {
400255d8: f100005f cmp x2, #0x0
400255dc: fa401861 ccmp x3, #0x0, #0x1, ne // ne = any
400255e0: 5400014b b.lt 40025608 <_Scheduler_CBS_Unblock+0x58> // b.tstop
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;
400255e4: d00006e4 adrp x4, 40103000 <config+0x8>
400255e8: b9410886 ldr w6, [x4, #264]
if ( deadline * budget_left > budget * deadline_left ) {
400255ec: a9408845 ldp x5, x2, [x2, #8]
400255f0: b940ec24 ldr w4, [x1, #236]
Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot;
400255f4: cb264063 sub x3, x3, w6, uxtw
if ( deadline * budget_left > budget * deadline_left ) {
400255f8: 9b027c82 mul x2, x4, x2
400255fc: 9b057c63 mul x3, x3, x5
40025600: eb02007f cmp x3, x2
40025604: 54000108 b.hi 40025624 <_Scheduler_CBS_Unblock+0x74> // b.pmore <== ALWAYS TAKEN
&queue_context
);
}
}
_Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base );
40025608: aa1303e2 mov x2, x19
4002560c: aa1403e1 mov x1, x20
40025610: aa1503e0 mov x0, x21
}
40025614: a94153f3 ldp x19, x20, [sp, #16]
40025618: f94013f5 ldr x21, [sp, #32]
4002561c: a8c77bfd ldp x29, x30, [sp], #112
_Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base );
40025620: 14000104 b 40025a30 <_Scheduler_EDF_Unblock>
_Scheduler_CBS_Cancel_job(
40025624: f9404262 ldr x2, [x19, #128]
40025628: 9100c3e3 add x3, sp, #0x30
*/
RTEMS_INLINE_ROUTINE void _Thread_queue_Context_clear_priority_updates(
Thread_queue_Context *queue_context
)
{
queue_context->Priority.update_count = 0;
4002562c: f9002bff str xzr, [sp, #80]
40025630: 97ffffd8 bl 40025590 <_Scheduler_CBS_Cancel_job>
_Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base );
40025634: aa1303e2 mov x2, x19
40025638: aa1403e1 mov x1, x20
4002563c: aa1503e0 mov x0, x21
}
40025640: a94153f3 ldp x19, x20, [sp, #16]
40025644: f94013f5 ldr x21, [sp, #32]
40025648: a8c77bfd ldp x29, x30, [sp], #112
_Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base );
4002564c: 140000f9 b 40025a30 <_Scheduler_EDF_Unblock>
0000000040025710 <_Scheduler_EDF_Block>:
void _Scheduler_EDF_Block(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40025710: a9bd7bfd stp x29, x30, [sp, #-48]!
40025714: 910003fd mov x29, sp
40025718: a9025bf5 stp x21, x22, [sp, #32]
4002571c: aa0003f5 mov x21, x0
RTEMS_INLINE_ROUTINE void _Scheduler_EDF_Extract(
Scheduler_EDF_Context *context,
Scheduler_EDF_Node *node
)
{
_RBTree_Extract( &context->Ready, &node->Node );
40025720: f9400000 ldr x0, [x0]
40025724: a90153f3 stp x19, x20, [sp, #16]
40025728: d00006f3 adrp x19, 40103000 <config+0x8>
4002572c: 91020273 add x19, x19, #0x80
40025730: aa0103f4 mov x20, x1
40025734: 91014041 add x1, x2, #0x50
40025738: 9400100a bl 40029760 <_RBTree_Extract>
{
( *extract )( scheduler, the_thread, node );
/* TODO: flash critical section? */
if ( _Thread_Is_executing( the_thread ) || _Thread_Is_heir( the_thread ) ) {
4002573c: f9401260 ldr x0, [x19, #32]
40025740: eb00029f cmp x20, x0
40025744: 54000100 b.eq 40025764 <_Scheduler_EDF_Block+0x54> // b.none
40025748: f9401660 ldr x0, [x19, #40]
4002574c: eb00029f cmp x20, x0
40025750: 540000a0 b.eq 40025764 <_Scheduler_EDF_Block+0x54> // b.none <== NEVER TAKEN
the_thread,
node,
_Scheduler_EDF_Extract_body,
_Scheduler_EDF_Schedule_body
);
}
40025754: a94153f3 ldp x19, x20, [sp, #16]
40025758: a9425bf5 ldp x21, x22, [sp, #32]
4002575c: a8c37bfd ldp x29, x30, [sp], #48
40025760: d65f03c0 ret
Scheduler_EDF_Node *node;
(void) the_thread;
context = _Scheduler_EDF_Get_context( scheduler );
first = _RBTree_Minimum( &context->Ready );
40025764: f94002a0 ldr x0, [x21]
40025768: 94001192 bl 40029db0 <_RBTree_Minimum>
node = RTEMS_CONTAINER_OF( first, Scheduler_EDF_Node, Node );
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
4002576c: f85b0015 ldur x21, [x0, #-80]
RTEMS_INLINE_ROUTINE void _Scheduler_Update_heir(
Thread_Control *new_heir,
bool force_dispatch
)
{
Thread_Control *heir = _Thread_Heir;
40025770: f9401674 ldr x20, [x19, #40]
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40025774: eb1402bf cmp x21, x20
40025778: 54fffee0 b.eq 40025754 <_Scheduler_EDF_Block+0x44> // b.none <== NEVER TAKEN
last = cpu->cpu_usage_timestamp;
4002577c: f9401a76 ldr x22, [x19, #48]
*time = _Timecounter_Sbinuptime();
40025780: 97fffe50 bl 400250c0 <_Timecounter_Sbinuptime>
40025784: f9001a60 str x0, [x19, #48]
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;
40025788: 52800022 mov w2, #0x1 // #1
const Timestamp_Control *_start,
const Timestamp_Control *_end,
Timestamp_Control *_result
)
{
*_result = *_end - *_start;
4002578c: cb160000 sub x0, x0, x22
*_time += *_add;
40025790: f9408281 ldr x1, [x20, #256]
40025794: 8b000020 add x0, x1, x0
40025798: f9008280 str x0, [x20, #256]
4002579c: 39007262 strb w2, [x19, #28]
_Thread_Heir = new_heir;
400257a0: f9001675 str x21, [x19, #40]
400257a4: a94153f3 ldp x19, x20, [sp, #16]
400257a8: a9425bf5 ldp x21, x22, [sp, #32]
400257ac: a8c37bfd ldp x29, x30, [sp], #48
400257b0: d65f03c0 ret
...
00000000400259b0 <_Scheduler_EDF_Schedule>:
void _Scheduler_EDF_Schedule(
const Scheduler_Control *scheduler,
Thread_Control *the_thread
)
{
400259b0: a9bd7bfd stp x29, x30, [sp, #-48]!
400259b4: 910003fd mov x29, sp
first = _RBTree_Minimum( &context->Ready );
400259b8: f9400000 ldr x0, [x0]
400259bc: a90153f3 stp x19, x20, [sp, #16]
Thread_Control *heir = _Thread_Heir;
400259c0: d00006f3 adrp x19, 40103000 <config+0x8>
400259c4: 91020273 add x19, x19, #0x80
400259c8: a9025bf5 stp x21, x22, [sp, #32]
400259cc: 940010f9 bl 40029db0 <_RBTree_Minimum>
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
400259d0: f85b0015 ldur x21, [x0, #-80]
400259d4: f9401674 ldr x20, [x19, #40]
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
400259d8: eb1402bf cmp x21, x20
400259dc: 54000060 b.eq 400259e8 <_Scheduler_EDF_Schedule+0x38> // b.none <== ALWAYS TAKEN
400259e0: 3943a680 ldrb w0, [x20, #233] <== NOT EXECUTED
400259e4: 350000a0 cbnz w0, 400259f8 <_Scheduler_EDF_Schedule+0x48> <== NOT EXECUTED
_Scheduler_EDF_Schedule_body( scheduler, the_thread, false ); }
400259e8: a94153f3 ldp x19, x20, [sp, #16]
400259ec: a9425bf5 ldp x21, x22, [sp, #32]
400259f0: a8c37bfd ldp x29, x30, [sp], #48
400259f4: d65f03c0 ret
400259f8: f9401a76 ldr x22, [x19, #48] <== NOT EXECUTED
400259fc: 97fffdb1 bl 400250c0 <_Timecounter_Sbinuptime> <== NOT EXECUTED
40025a00: f9001a60 str x0, [x19, #48] <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40025a04: 52800022 mov w2, #0x1 // #1 <== NOT EXECUTED
*_result = *_end - *_start;
40025a08: cb160000 sub x0, x0, x22 <== NOT EXECUTED
*_time += *_add;
40025a0c: f9408281 ldr x1, [x20, #256] <== NOT EXECUTED
40025a10: 8b000020 add x0, x1, x0 <== NOT EXECUTED
40025a14: f9008280 str x0, [x20, #256] <== NOT EXECUTED
40025a18: 39007262 strb w2, [x19, #28] <== NOT EXECUTED
_Thread_Heir = new_heir;
40025a1c: f9001675 str x21, [x19, #40] <== NOT EXECUTED
40025a20: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40025a24: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40025a28: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
40025a2c: d65f03c0 ret <== NOT EXECUTED
0000000040025a30 <_Scheduler_EDF_Unblock>:
void _Scheduler_EDF_Unblock(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40025a30: a9bc7bfd stp x29, x30, [sp, #-64]!
40025a34: 910003fd mov x29, sp
return scheduler->context;
40025a38: f9400000 ldr x0, [x0]
40025a3c: a90153f3 stp x19, x20, [sp, #16]
40025a40: aa0103f3 mov x19, x1
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 );
40025a44: f9402446 ldr x6, [x2, #72]
{
40025a48: a9025bf5 stp x21, x22, [sp, #32]
_RBTree_Insert_inline(
40025a4c: 91014041 add x1, x2, #0x50
while ( *link != NULL ) {
40025a50: f9400004 ldr x4, [x0]
priority = SCHEDULER_PRIORITY_PURIFY( priority );
40025a54: 927ff8d5 and x21, x6, #0xfffffffffffffffe
{
40025a58: f9001bf7 str x23, [sp, #48]
40025a5c: b24000c6 orr x6, x6, #0x1
insert_priority = SCHEDULER_PRIORITY_APPEND( priority );
the_node->priority = priority;
40025a60: f9003855 str x21, [x2, #112]
40025a64: b5000064 cbnz x4, 40025a70 <_Scheduler_EDF_Unblock+0x40>
40025a68: 1400002c b 40025b18 <_Scheduler_EDF_Unblock+0xe8>
40025a6c: aa0503e4 mov x4, x5
if ( ( *less )( key, parent ) ) {
40025a70: f9401085 ldr x5, [x4, #32]
return &RB_LEFT( the_node, Node );
40025a74: 91002083 add x3, x4, #0x8
40025a78: eb0500df cmp x6, x5
40025a7c: 9a848063 csel x3, x3, x4, hi // hi = pmore
while ( *link != NULL ) {
40025a80: f9400065 ldr x5, [x3]
40025a84: b5ffff45 cbnz x5, 40025a6c <_Scheduler_EDF_Unblock+0x3c>
RB_SET( child, parent, Node );
40025a88: a900903f stp xzr, x4, [x1, #8]
40025a8c: 52800036 mov w22, #0x1 // #1
* 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 ) ) {
40025a90: d00006f4 adrp x20, 40103000 <config+0x8>
40025a94: 91020294 add x20, x20, #0x80
40025a98: f900285f str xzr, [x2, #80]
40025a9c: b9001836 str w22, [x1, #24]
*link = child;
40025aa0: f9000061 str x1, [x3]
_RBTree_Insert_color( the_rbtree, the_node );
40025aa4: 94001043 bl 40029bb0 <_RBTree_Insert_color>
40025aa8: f9401697 ldr x23, [x20, #40]
*/
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_priority(
const Priority_Aggregation *aggregation
)
{
return aggregation->Node.priority;
40025aac: f94036e0 ldr x0, [x23, #104]
40025ab0: f9401400 ldr x0, [x0, #40]
40025ab4: eb15001f cmp x0, x21
40025ab8: 540000c8 b.hi 40025ad0 <_Scheduler_EDF_Unblock+0xa0> // b.pmore
_Scheduler_Update_heir(
the_thread,
priority == ( SCHEDULER_EDF_PRIO_MSB | PRIORITY_PSEUDO_ISR )
);
}
}
40025abc: a94153f3 ldp x19, x20, [sp, #16]
40025ac0: a9425bf5 ldp x21, x22, [sp, #32]
40025ac4: f9401bf7 ldr x23, [sp, #48]
40025ac8: a8c47bfd ldp x29, x30, [sp], #64
40025acc: d65f03c0 ret
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40025ad0: eb1302ff cmp x23, x19
40025ad4: 54ffff40 b.eq 40025abc <_Scheduler_EDF_Unblock+0x8c> // b.none <== NEVER TAKEN
_Scheduler_Update_heir(
40025ad8: d2f00001 mov x1, #0x8000000000000000 // #-9223372036854775808
40025adc: 3943a6e0 ldrb w0, [x23, #233]
40025ae0: eb0102bf cmp x21, x1
40025ae4: 1a9f17e1 cset w1, eq // eq = none
40025ae8: 2a010000 orr w0, w0, w1
40025aec: 34fffe80 cbz w0, 40025abc <_Scheduler_EDF_Unblock+0x8c>
40025af0: f9401a95 ldr x21, [x20, #48]
40025af4: 97fffd73 bl 400250c0 <_Timecounter_Sbinuptime>
40025af8: f9001a80 str x0, [x20, #48]
*_result = *_end - *_start;
40025afc: cb150000 sub x0, x0, x21
*_time += *_add;
40025b00: f94082e1 ldr x1, [x23, #256]
40025b04: 8b000020 add x0, x1, x0
40025b08: f90082e0 str x0, [x23, #256]
_Thread_Dispatch_necessary = true;
40025b0c: 39007296 strb w22, [x20, #28]
_Thread_Heir = new_heir;
40025b10: f9001693 str x19, [x20, #40]
}
40025b14: 17ffffea b 40025abc <_Scheduler_EDF_Unblock+0x8c>
link = _RBTree_Root_reference( the_rbtree );
40025b18: aa0003e3 mov x3, x0
40025b1c: 17ffffdb b 40025a88 <_Scheduler_EDF_Unblock+0x58>
0000000040025910 <_Scheduler_EDF_Unmap_priority>:
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
return SCHEDULER_PRIORITY_UNMAP( priority & ~SCHEDULER_EDF_PRIO_MSB );
}
40025910: d341f820 ubfx x0, x1, #1, #62 <== NOT EXECUTED
40025914: d65f03c0 ret <== NOT EXECUTED
...
00000000400257d0 <_Scheduler_EDF_Update_priority>:
void _Scheduler_EDF_Update_priority(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
400257d0: a9bc7bfd stp x29, x30, [sp, #-64]!
400257d4: 910003fd mov x29, sp
400257d8: a9025bf5 stp x21, x22, [sp, #32]
400257dc: aa0003f5 mov x21, x0
Scheduler_EDF_Context *context;
Scheduler_EDF_Node *the_node;
Priority_Control priority;
Priority_Control insert_priority;
if ( !_Thread_Is_ready( the_thread ) ) {
400257e0: b9403820 ldr w0, [x1, #56]
400257e4: 350005a0 cbnz w0, 40025898 <_Scheduler_EDF_Update_priority+0xc8>
400257e8: a90153f3 stp x19, x20, [sp, #16]
400257ec: aa0203f3 mov x19, x2
do {
seq = _SMP_sequence_lock_Read_begin( &node->Priority.Lock );
#endif
priority = node->Priority.value;
400257f0: f9402454 ldr x20, [x2, #72]
the_node = _Scheduler_EDF_Node_downcast( node );
insert_priority = _Scheduler_Node_get_priority( &the_node->Base );
priority = SCHEDULER_PRIORITY_PURIFY( insert_priority );
if ( priority == the_node->priority ) {
400257f4: f9403841 ldr x1, [x2, #112]
priority = SCHEDULER_PRIORITY_PURIFY( insert_priority );
400257f8: 927ffa80 and x0, x20, #0xfffffffffffffffe
if ( priority == the_node->priority ) {
400257fc: eb00003f cmp x1, x0
40025800: 54000520 b.eq 400258a4 <_Scheduler_EDF_Update_priority+0xd4> // b.none<== NEVER TAKEN
/* Nothing to do */
return;
}
the_node->priority = priority;
40025804: a90363f7 stp x23, x24, [sp, #48]
_RBTree_Extract( &context->Ready, &node->Node );
40025808: 91014056 add x22, x2, #0x50
4002580c: aa1603e1 mov x1, x22
return scheduler->context;
40025810: f94002b7 ldr x23, [x21]
40025814: f9003840 str x0, [x2, #112]
40025818: aa1703e0 mov x0, x23
4002581c: 94000fd1 bl 40029760 <_RBTree_Extract>
link = _RBTree_Root_reference( the_rbtree );
parent = NULL;
is_new_minimum = true;
while ( *link != NULL ) {
40025820: f94002e4 ldr x4, [x23]
40025824: b5000064 cbnz x4, 40025830 <_Scheduler_EDF_Update_priority+0x60> <== ALWAYS TAKEN
40025828: 1400002f b 400258e4 <_Scheduler_EDF_Update_priority+0x114> <== NOT EXECUTED
4002582c: aa0503e4 mov x4, x5
parent = *link;
if ( ( *less )( key, parent ) ) {
40025830: f9401085 ldr x5, [x4, #32]
return &RB_LEFT( the_node, Node );
40025834: 91002083 add x3, x4, #0x8
40025838: eb05029f cmp x20, x5
4002583c: 9a848063 csel x3, x3, x4, hi // hi = pmore
while ( *link != NULL ) {
40025840: f9400065 ldr x5, [x3]
40025844: b5ffff45 cbnz x5, 4002582c <_Scheduler_EDF_Update_priority+0x5c>
RB_SET( child, parent, Node );
40025848: a90092df stp xzr, x4, [x22, #8]
4002584c: 52800038 mov w24, #0x1 // #1
is_new_minimum = false;
}
}
_RBTree_Add_child( the_node, parent, link );
_RBTree_Insert_color( the_rbtree, the_node );
40025850: aa1703e0 mov x0, x23
RB_SET( child, parent, Node );
40025854: f9002a7f str xzr, [x19, #80]
_RBTree_Insert_color( the_rbtree, the_node );
40025858: aa1603e1 mov x1, x22
RB_SET( child, parent, Node );
4002585c: b9001ad8 str w24, [x22, #24]
Thread_Control *heir = _Thread_Heir;
40025860: d00006f3 adrp x19, 40103000 <config+0x8>
40025864: 91020273 add x19, x19, #0x80
*link = child;
40025868: f9000076 str x22, [x3]
_RBTree_Insert_color( the_rbtree, the_node );
4002586c: 940010d1 bl 40029bb0 <_RBTree_Insert_color>
first = _RBTree_Minimum( &context->Ready );
40025870: f94002a0 ldr x0, [x21]
40025874: 9400114f bl 40029db0 <_RBTree_Minimum>
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
40025878: f85b0015 ldur x21, [x0, #-80]
4002587c: f9401674 ldr x20, [x19, #40]
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40025880: eb1402bf cmp x21, x20
40025884: 54000060 b.eq 40025890 <_Scheduler_EDF_Update_priority+0xc0> // b.none
40025888: 3943a680 ldrb w0, [x20, #233]
4002588c: 35000140 cbnz w0, 400258b4 <_Scheduler_EDF_Update_priority+0xe4> <== ALWAYS TAKEN
40025890: a94153f3 ldp x19, x20, [sp, #16]
40025894: a94363f7 ldp x23, x24, [sp, #48]
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 );
}
40025898: a9425bf5 ldp x21, x22, [sp, #32]
4002589c: a8c47bfd ldp x29, x30, [sp], #64
400258a0: d65f03c0 ret
400258a4: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400258a8: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400258ac: a8c47bfd ldp x29, x30, [sp], #64 <== NOT EXECUTED
400258b0: d65f03c0 ret <== NOT EXECUTED
400258b4: f9401a76 ldr x22, [x19, #48]
400258b8: 97fffe02 bl 400250c0 <_Timecounter_Sbinuptime>
400258bc: f9001a60 str x0, [x19, #48]
*_result = *_end - *_start;
400258c0: cb160000 sub x0, x0, x22
*_time += *_add;
400258c4: f9408281 ldr x1, [x20, #256]
400258c8: 8b000020 add x0, x1, x0
400258cc: f9008280 str x0, [x20, #256]
_Thread_Dispatch_necessary = true;
400258d0: 39007278 strb w24, [x19, #28]
_Thread_Heir = new_heir;
400258d4: a94363f7 ldp x23, x24, [sp, #48]
400258d8: f9001675 str x21, [x19, #40]
400258dc: a94153f3 ldp x19, x20, [sp, #16]
400258e0: 17ffffee b 40025898 <_Scheduler_EDF_Update_priority+0xc8>
link = _RBTree_Root_reference( the_rbtree );
400258e4: aa1703e3 mov x3, x23 <== NOT EXECUTED
400258e8: 17ffffd8 b 40025848 <_Scheduler_EDF_Update_priority+0x78> <== NOT EXECUTED
400258ec: 00000000 udf #0
0000000040025b20 <_Scheduler_EDF_Yield>:
void _Scheduler_EDF_Yield(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40025b20: a9bc7bfd stp x29, x30, [sp, #-64]!
40025b24: 910003fd mov x29, sp
40025b28: f9001bf7 str x23, [sp, #48]
return scheduler->context;
40025b2c: f9400017 ldr x23, [x0]
40025b30: a90153f3 stp x19, x20, [sp, #16]
_RBTree_Extract( &context->Ready, &node->Node );
40025b34: 91014053 add x19, x2, #0x50
40025b38: aa0203f4 mov x20, x2
40025b3c: aa1303e1 mov x1, x19
40025b40: a9025bf5 stp x21, x22, [sp, #32]
40025b44: aa0003f5 mov x21, x0
40025b48: aa1703e0 mov x0, x23
40025b4c: 94000f05 bl 40029760 <_RBTree_Extract>
while ( *link != NULL ) {
40025b50: f94002e4 ldr x4, [x23]
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 );
40025b54: f9403a86 ldr x6, [x20, #112]
40025b58: b5000064 cbnz x4, 40025b64 <_Scheduler_EDF_Yield+0x44> <== ALWAYS TAKEN
40025b5c: 14000026 b 40025bf4 <_Scheduler_EDF_Yield+0xd4> <== NOT EXECUTED
40025b60: aa0503e4 mov x4, x5
if ( ( *less )( key, parent ) ) {
40025b64: f9401085 ldr x5, [x4, #32]
return &RB_LEFT( the_node, Node );
40025b68: 91002083 add x3, x4, #0x8
40025b6c: eb0500df cmp x6, x5
40025b70: 9a848063 csel x3, x3, x4, hi // hi = pmore
while ( *link != NULL ) {
40025b74: f9400065 ldr x5, [x3]
40025b78: b5ffff45 cbnz x5, 40025b60 <_Scheduler_EDF_Yield+0x40>
RB_SET( child, parent, Node );
40025b7c: a900927f stp xzr, x4, [x19, #8]
40025b80: 52800036 mov w22, #0x1 // #1
_RBTree_Insert_color( the_rbtree, the_node );
40025b84: aa1303e1 mov x1, x19
RB_SET( child, parent, Node );
40025b88: f9002a9f str xzr, [x20, #80]
_RBTree_Insert_color( the_rbtree, the_node );
40025b8c: aa1703e0 mov x0, x23
RB_SET( child, parent, Node );
40025b90: b9001a76 str w22, [x19, #24]
*link = child;
40025b94: f9000073 str x19, [x3]
Thread_Control *heir = _Thread_Heir;
40025b98: d00006f3 adrp x19, 40103000 <config+0x8>
40025b9c: 91020273 add x19, x19, #0x80
_RBTree_Insert_color( the_rbtree, the_node );
40025ba0: 94001004 bl 40029bb0 <_RBTree_Insert_color>
first = _RBTree_Minimum( &context->Ready );
40025ba4: f94002a0 ldr x0, [x21]
40025ba8: 94001082 bl 40029db0 <_RBTree_Minimum>
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
40025bac: f85b0015 ldur x21, [x0, #-80]
40025bb0: f9401674 ldr x20, [x19, #40]
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40025bb4: eb1402bf cmp x21, x20
40025bb8: 54000140 b.eq 40025be0 <_Scheduler_EDF_Yield+0xc0> // b.none <== NEVER TAKEN
40025bbc: f9401a77 ldr x23, [x19, #48]
40025bc0: 97fffd40 bl 400250c0 <_Timecounter_Sbinuptime>
40025bc4: f9001a60 str x0, [x19, #48]
*_result = *_end - *_start;
40025bc8: cb170000 sub x0, x0, x23
*_time += *_add;
40025bcc: f9408281 ldr x1, [x20, #256]
40025bd0: 8b000020 add x0, x1, x0
40025bd4: f9008280 str x0, [x20, #256]
_Thread_Dispatch_necessary = true;
40025bd8: 39007276 strb w22, [x19, #28]
_Thread_Heir = new_heir;
40025bdc: f9001675 str x21, [x19, #40]
_Scheduler_EDF_Schedule_body( scheduler, the_thread, true ); }
40025be0: a94153f3 ldp x19, x20, [sp, #16]
40025be4: a9425bf5 ldp x21, x22, [sp, #32]
40025be8: f9401bf7 ldr x23, [sp, #48]
40025bec: a8c47bfd ldp x29, x30, [sp], #64
40025bf0: d65f03c0 ret
link = _RBTree_Root_reference( the_rbtree );
40025bf4: aa1703e3 mov x3, x23 <== NOT EXECUTED
40025bf8: 17ffffe1 b 40025b7c <_Scheduler_EDF_Yield+0x5c> <== NOT EXECUTED
40025bfc: 00000000 udf #0
0000000040028030 <_Scheduler_Set_affinity>:
bool _Scheduler_Set_affinity(
Thread_Control *the_thread,
size_t cpusetsize,
const cpu_set_t *cpuset
)
{
40028030: a9be7bfd stp x29, x30, [sp, #-32]!
Processor_mask *dst,
size_t src_size,
const cpu_set_t *src
)
{
return _Processor_mask_Copy(
40028034: aa0103e3 mov x3, x1
40028038: d2800101 mov x1, #0x8 // #8
4002803c: 910003fd mov x29, sp
40028040: 910063e0 add x0, sp, #0x18
40028044: 940010f3 bl 4002c410 <_Processor_mask_Copy>
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 ) ) {
40028048: 7100041f cmp w0, #0x1
4002804c: 54000108 b.hi 4002806c <_Scheduler_Set_affinity+0x3c> // b.pmore <== NEVER TAKEN
BIT_AND2( CPU_MAXIMUM_PROCESSORS, a, b, c );
40028050: f00003e0 adrp x0, 400a7000 <status_code_text+0x100>
40028054: f940d400 ldr x0, [x0, #424]
40028058: f9400fe1 ldr x1, [sp, #24]
);
#endif
_Scheduler_Release_critical( scheduler, &lock_context );
return ok;
}
4002805c: a8c27bfd ldp x29, x30, [sp], #32
return BIT_SUBSET( CPU_MAXIMUM_PROCESSORS, big, small );
40028060: ea21001f bics xzr, x0, x1
40028064: 1a9f17e0 cset w0, eq // eq = none
40028068: d65f03c0 ret
4002806c: 52800000 mov w0, #0x0 // #0 <== NOT EXECUTED
40028070: a8c27bfd ldp x29, x30, [sp], #32 <== NOT EXECUTED
40028074: d65f03c0 ret <== NOT EXECUTED
...
0000000040025ae0 <_Scheduler_default_Tick>:
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
40025ae0: 3943a420 ldrb w0, [x1, #233]
40025ae4: 340000e0 cbz w0, 40025b00 <_Scheduler_default_Tick+0x20>
return;
if ( !_States_Is_ready( executing->current_state ) )
40025ae8: b9403820 ldr w0, [x1, #56]
40025aec: 350000a0 cbnz w0, 40025b00 <_Scheduler_default_Tick+0x20>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
40025af0: b940f020 ldr w0, [x1, #240]
40025af4: 7100081f cmp w0, #0x2
40025af8: 54000068 b.hi 40025b04 <_Scheduler_default_Tick+0x24> // b.pmore
40025afc: 35000180 cbnz w0, 40025b2c <_Scheduler_default_Tick+0x4c>
40025b00: d65f03c0 ret
40025b04: 71000c1f cmp w0, #0x3
40025b08: 54000321 b.ne 40025b6c <_Scheduler_default_Tick+0x8c> // b.any <== NEVER TAKEN
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
40025b0c: b940ec20 ldr w0, [x1, #236]
40025b10: 51000400 sub w0, w0, #0x1
40025b14: b900ec20 str w0, [x1, #236]
40025b18: 35ffff40 cbnz w0, 40025b00 <_Scheduler_default_Tick+0x20>
(*executing->budget_callout)( executing );
40025b1c: f9407c22 ldr x2, [x1, #248]
40025b20: aa0103e0 mov x0, x1
40025b24: aa0203f0 mov x16, x2
40025b28: d61f0200 br x16
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
40025b2c: b940ec20 ldr w0, [x1, #236]
40025b30: 51000400 sub w0, w0, #0x1
40025b34: b900ec20 str w0, [x1, #236]
40025b38: 7100001f cmp w0, #0x0
40025b3c: 54fffe2c b.gt 40025b00 <_Scheduler_default_Tick+0x20>
{
40025b40: a9be7bfd stp x29, x30, [sp, #-32]!
_Thread_Yield( executing );
40025b44: aa0103e0 mov x0, x1
{
40025b48: 910003fd mov x29, sp
_Thread_Yield( executing );
40025b4c: f9000fe1 str x1, [sp, #24]
40025b50: 94000754 bl 400278a0 <_Thread_Yield>
executing->cpu_time_budget =
40025b54: f9400fe1 ldr x1, [sp, #24]
40025b58: f00000a0 adrp x0, 4003c000 <_Scheduler_Table+0x48>
40025b5c: b94e9000 ldr w0, [x0, #3728]
40025b60: b900ec20 str w0, [x1, #236]
break;
#endif
}
}
40025b64: a8c27bfd ldp x29, x30, [sp], #32
40025b68: d65f03c0 ret
40025b6c: d65f03c0 ret <== NOT EXECUTED
0000000040025f60 <_Scheduler_priority_Schedule>:
void _Scheduler_priority_Schedule(
const Scheduler_Control *scheduler,
Thread_Control *the_thread
)
{
40025f60: a9bd7bfd stp x29, x30, [sp, #-48]!
40025f64: 52800303 mov w3, #0x18 // #24
40025f68: 910003fd mov x29, sp
40025f6c: f9400001 ldr x1, [x0]
40025f70: a90153f3 stp x19, x20, [sp, #16]
Thread_Control *heir = _Thread_Heir;
40025f74: 90000713 adrp x19, 40105000 <Arr_2_Glob+0x1e68>
40025f78: 91290273 add x19, x19, #0xa40
40025f7c: a9025bf5 stp x21, x22, [sp, #32]
major = _Bitfield_Find_first_bit( bit_map->major_bit_map );
40025f80: 79400020 ldrh w0, [x1]
bit_number = (unsigned int) __builtin_clz( value )
40025f84: 5ac01000 clz w0, w0
minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] );
40025f88: 51004002 sub w2, w0, #0x10
40025f8c: f9401674 ldr x20, [x19, #40]
40025f90: 8b020422 add x2, x1, x2, lsl #1
40025f94: 79400442 ldrh w2, [x2, #2]
bit_number = (unsigned int) __builtin_clz( value )
40025f98: 5ac01042 clz w2, w2
40025f9c: 0b001040 add w0, w2, w0, lsl #4
return (_Priority_Bits_index( major ) << 4) +
40025fa0: 51044000 sub w0, w0, #0x110
return _Chain_Immutable_head( the_chain )->next;
40025fa4: 9ba30400 umaddl x0, w0, w3, x1
40025fa8: f9401415 ldr x21, [x0, #40]
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40025fac: eb15029f cmp x20, x21
40025fb0: 54000060 b.eq 40025fbc <_Scheduler_priority_Schedule+0x5c> // b.none
40025fb4: 3943a680 ldrb w0, [x20, #233]
40025fb8: 350000a0 cbnz w0, 40025fcc <_Scheduler_priority_Schedule+0x6c> <== ALWAYS TAKEN
_Scheduler_priority_Schedule_body( scheduler, the_thread, false ); }
40025fbc: a94153f3 ldp x19, x20, [sp, #16]
40025fc0: a9425bf5 ldp x21, x22, [sp, #32]
40025fc4: a8c37bfd ldp x29, x30, [sp], #48
40025fc8: d65f03c0 ret
40025fcc: f9401a76 ldr x22, [x19, #48]
40025fd0: 97fffd38 bl 400254b0 <_Timecounter_Sbinuptime>
40025fd4: f9001a60 str x0, [x19, #48]
_Thread_Dispatch_necessary = true;
40025fd8: 52800022 mov w2, #0x1 // #1
*_result = *_end - *_start;
40025fdc: cb160000 sub x0, x0, x22
*_time += *_add;
40025fe0: f9408281 ldr x1, [x20, #256]
40025fe4: 8b000020 add x0, x1, x0
40025fe8: f9008280 str x0, [x20, #256]
40025fec: 39007262 strb w2, [x19, #28]
_Thread_Heir = new_heir;
40025ff0: f9001675 str x21, [x19, #40]
40025ff4: a94153f3 ldp x19, x20, [sp, #16]
40025ff8: a9425bf5 ldp x21, x22, [sp, #32]
40025ffc: a8c37bfd ldp x29, x30, [sp], #48
40026000: d65f03c0 ret
...
0000000040026010 <_Scheduler_priority_Unblock>:
void _Scheduler_priority_Unblock (
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40026010: a9bd7bfd stp x29, x30, [sp, #-48]!
40026014: 910003fd mov x29, sp
do {
seq = _SMP_sequence_lock_Read_begin( &node->Priority.Lock );
#endif
priority = node->Priority.value;
40026018: f9402449 ldr x9, [x2, #72]
4002601c: a90153f3 stp x19, x20, [sp, #16]
40026020: aa0103f3 mov x19, x1
40026024: a9025bf5 stp x21, x22, [sp, #32]
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 );
unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority );
40026028: 53017d26 lsr w6, w9, #1
return scheduler->context;
4002602c: f9400007 ldr x7, [x0]
if ( unmapped_priority != the_node->Ready_queue.current_priority ) {
40026030: b9405040 ldr w0, [x2, #80]
40026034: 6b06001f cmp w0, w6
40026038: 54000381 b.ne 400260a8 <_Scheduler_priority_Unblock+0x98> // b.any
*bit_map_info->minor |= bit_map_info->ready_minor;
4002603c: a9458440 ldp x0, x1, [x2, #88]
40026040: 91018048 add x8, x2, #0x60
40026044: 7940d443 ldrh w3, [x2, #106]
* 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 ) ) {
40026048: f00006f4 adrp x20, 40105000 <Arr_2_Glob+0x1e68>
4002604c: 91290294 add x20, x20, #0xa40
40026050: 79400024 ldrh w4, [x1]
old_last = tail->previous;
40026054: 91002000 add x0, x0, #0x8
40026058: f9400402 ldr x2, [x0, #8]
4002605c: 2a040063 orr w3, w3, w4
40026060: f9401695 ldr x21, [x20, #40]
*/
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_priority(
const Priority_Aggregation *aggregation
)
{
return aggregation->Node.priority;
40026064: f94036a4 ldr x4, [x21, #104]
the_node->next = tail;
40026068: f9000260 str x0, [x19]
tail->previous = the_node;
4002606c: f9000413 str x19, [x0, #8]
old_last->next = the_node;
40026070: f9000053 str x19, [x2]
the_node->previous = old_last;
40026074: f9000662 str x2, [x19, #8]
40026078: 79000023 strh w3, [x1]
4002607c: f9401481 ldr x1, [x4, #40]
bit_map->major_bit_map |= bit_map_info->ready_major;
40026080: 794000e0 ldrh w0, [x7]
40026084: 79401102 ldrh w2, [x8, #8]
40026088: eb29403f cmp x1, w9, uxtw
4002608c: 2a020000 orr w0, w0, w2
40026090: 790000e0 strh w0, [x7]
40026094: 54000388 b.hi 40026104 <_Scheduler_priority_Unblock+0xf4> // b.pmore
_Scheduler_Update_heir( the_thread, priority == PRIORITY_PSEUDO_ISR );
}
}
40026098: a94153f3 ldp x19, x20, [sp, #16]
4002609c: a9425bf5 ldp x21, x22, [sp, #32]
400260a0: a8c37bfd ldp x29, x30, [sp], #48
400260a4: d65f03c0 ret
return the_priority / 16;
400260a8: 53057d25 lsr w5, w9, #5
_Scheduler_priority_Ready_queue_update(
400260ac: 9100a0e0 add x0, x7, #0x28
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
400260b0: 110004a1 add w1, w5, #0x1
return the_priority % 16;
400260b4: 12000cca and w10, w6, #0xf
ready_queue->ready_chain = &ready_queues[ new_priority ];
400260b8: 52800303 mov w3, #0x18 // #24
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
400260bc: 52900004 mov w4, #0x8000 // #32768
400260c0: 1ac52485 lsr w5, w4, w5
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
400260c4: d37f6c21 ubfiz x1, x1, #1, #28
400260c8: 9ba300c0 umaddl x0, w6, w3, x0
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
400260cc: 12003ca5 and w5, w5, #0xffff
400260d0: 1aca2483 lsr w3, w4, w10
400260d4: 12003c63 and w3, w3, #0xffff
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
400260d8: 8b0100e1 add x1, x7, x1
bit_map_info->block_minor = (Priority_bit_map_Word) ~mask;
400260dc: 2a2303e4 mvn w4, w3
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
400260e0: 91018048 add x8, x2, #0x60
ready_queue->current_priority = new_priority;
400260e4: b9005046 str w6, [x2, #80]
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
400260e8: 2a2503e6 mvn w6, w5
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
400260ec: a9058440 stp x0, x1, [x2, #88]
bit_map_info->ready_major = mask;
400260f0: 7900d045 strh w5, [x2, #104]
bit_map_info->ready_minor = mask;
400260f4: 7900d443 strh w3, [x2, #106]
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
400260f8: 7900d846 strh w6, [x2, #108]
bit_map_info->block_minor = (Priority_bit_map_Word) ~mask;
400260fc: 7900dc44 strh w4, [x2, #110]
_Priority_bit_map_Initialize_information(
bit_map,
&ready_queue->Priority_map,
new_priority
);
}
40026100: 17ffffd2 b 40026048 <_Scheduler_priority_Unblock+0x38>
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40026104: eb1302bf cmp x21, x19
40026108: 54fffc80 b.eq 40026098 <_Scheduler_priority_Unblock+0x88> // b.none<== NEVER TAKEN
4002610c: 3943a6a0 ldrb w0, [x21, #233]
_Scheduler_Update_heir( the_thread, priority == PRIORITY_PSEUDO_ISR );
40026110: 7100013f cmp w9, #0x0
40026114: 1a9f17e1 cset w1, eq // eq = none
40026118: 2a010000 orr w0, w0, w1
4002611c: 34fffbe0 cbz w0, 40026098 <_Scheduler_priority_Unblock+0x88>
40026120: f9401a96 ldr x22, [x20, #48]
40026124: 97fffce3 bl 400254b0 <_Timecounter_Sbinuptime>
40026128: f9001a80 str x0, [x20, #48]
_Thread_Dispatch_necessary = true;
4002612c: 52800022 mov w2, #0x1 // #1
*_result = *_end - *_start;
40026130: cb160000 sub x0, x0, x22
*_time += *_add;
40026134: f94082a1 ldr x1, [x21, #256]
40026138: 8b000020 add x0, x1, x0
4002613c: f90082a0 str x0, [x21, #256]
40026140: 39007282 strb w2, [x20, #28]
_Thread_Heir = new_heir;
40026144: f9001693 str x19, [x20, #40]
}
40026148: 17ffffd4 b 40026098 <_Scheduler_priority_Unblock+0x88>
4002614c: 00000000 udf #0
0000000040025530 <_Scheduler_simple_Block>:
void _Scheduler_simple_Block(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40025530: a9bd7bfd stp x29, x30, [sp, #-48]!
40025534: 910003fd mov x29, sp
40025538: a90153f3 stp x19, x20, [sp, #16]
return ( the_thread == _Thread_Heir );
4002553c: b00006f3 adrp x19, 40102000 <_RTEMS_tasks_Objects+0x13b8>
40025540: 91320273 add x19, x19, #0xc80
previous = the_node->previous;
40025544: a9400823 ldp x3, x2, [x1]
40025548: a9425264 ldp x4, x20, [x19, #32]
next->previous = previous;
4002554c: f9000462 str x2, [x3, #8]
previous->next = next;
40025550: f9000043 str x3, [x2]
{
( *extract )( scheduler, the_thread, node );
/* TODO: flash critical section? */
if ( _Thread_Is_executing( the_thread ) || _Thread_Is_heir( the_thread ) ) {
40025554: eb04003f cmp x1, x4
40025558: 540000c0 b.eq 40025570 <_Scheduler_simple_Block+0x40> // b.none
4002555c: eb14003f cmp x1, x20
40025560: 54000080 b.eq 40025570 <_Scheduler_simple_Block+0x40> // b.none <== NEVER TAKEN
the_thread,
node,
_Scheduler_simple_Extract,
_Scheduler_simple_Schedule_body
);
}
40025564: a94153f3 ldp x19, x20, [sp, #16]
40025568: a8c37bfd ldp x29, x30, [sp], #48
4002556c: d65f03c0 ret
return _Chain_Immutable_head( the_chain )->next;
40025570: f9400000 ldr x0, [x0]
40025574: a9025bf5 stp x21, x22, [sp, #32]
40025578: f9400015 ldr x21, [x0]
bool force_dispatch
)
{
Thread_Control *heir = _Thread_Heir;
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4002557c: eb1402bf cmp x21, x20
40025580: 540001e0 b.eq 400255bc <_Scheduler_simple_Block+0x8c> // b.none <== NEVER TAKEN
last = cpu->cpu_usage_timestamp;
40025584: f9401a76 ldr x22, [x19, #48]
*time = _Timecounter_Sbinuptime();
40025588: 97fffe86 bl 40024fa0 <_Timecounter_Sbinuptime>
4002558c: f9001a60 str x0, [x19, #48]
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;
40025590: 52800022 mov w2, #0x1 // #1
const Timestamp_Control *_start,
const Timestamp_Control *_end,
Timestamp_Control *_result
)
{
*_result = *_end - *_start;
40025594: cb160000 sub x0, x0, x22
*_time += *_add;
40025598: f9408281 ldr x1, [x20, #256]
4002559c: 8b000020 add x0, x1, x0
400255a0: f9008280 str x0, [x20, #256]
400255a4: 39007262 strb w2, [x19, #28]
_Thread_Heir = new_heir;
400255a8: f9001675 str x21, [x19, #40]
400255ac: a94153f3 ldp x19, x20, [sp, #16]
400255b0: a9425bf5 ldp x21, x22, [sp, #32]
400255b4: a8c37bfd ldp x29, x30, [sp], #48
400255b8: d65f03c0 ret
400255bc: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400255c0: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400255c4: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
400255c8: d65f03c0 ret <== NOT EXECUTED
400255cc: 00000000 udf #0
00000000400256e0 <_Scheduler_simple_Schedule>:
void _Scheduler_simple_Schedule(
const Scheduler_Control *scheduler,
Thread_Control *the_thread
)
{
400256e0: a9bd7bfd stp x29, x30, [sp, #-48]! <== NOT EXECUTED
400256e4: 910003fd mov x29, sp <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
400256e8: f9400000 ldr x0, [x0] <== NOT EXECUTED
400256ec: a90153f3 stp x19, x20, [sp, #16] <== NOT EXECUTED
Thread_Control *heir = _Thread_Heir;
400256f0: b00006f3 adrp x19, 40102000 <_RTEMS_tasks_Objects+0x13b8> <== NOT EXECUTED
400256f4: 91320273 add x19, x19, #0xc80 <== NOT EXECUTED
400256f8: a9025bf5 stp x21, x22, [sp, #32] <== NOT EXECUTED
400256fc: f9400015 ldr x21, [x0] <== NOT EXECUTED
40025700: f9401674 ldr x20, [x19, #40] <== NOT EXECUTED
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
40025704: eb1402bf cmp x21, x20 <== NOT EXECUTED
40025708: 54000060 b.eq 40025714 <_Scheduler_simple_Schedule+0x34> // b.none <== NOT EXECUTED
4002570c: 3943a680 ldrb w0, [x20, #233] <== NOT EXECUTED
40025710: 350000a0 cbnz w0, 40025724 <_Scheduler_simple_Schedule+0x44> <== NOT EXECUTED
_Scheduler_simple_Schedule_body( scheduler, the_thread, false ); }
40025714: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40025718: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
4002571c: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
40025720: d65f03c0 ret <== NOT EXECUTED
40025724: f9401a76 ldr x22, [x19, #48] <== NOT EXECUTED
40025728: 97fffe1e bl 40024fa0 <_Timecounter_Sbinuptime> <== NOT EXECUTED
4002572c: f9001a60 str x0, [x19, #48] <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
40025730: 52800022 mov w2, #0x1 // #1 <== NOT EXECUTED
*_result = *_end - *_start;
40025734: cb160000 sub x0, x0, x22 <== NOT EXECUTED
*_time += *_add;
40025738: f9408281 ldr x1, [x20, #256] <== NOT EXECUTED
4002573c: 8b000020 add x0, x1, x0 <== NOT EXECUTED
40025740: f9008280 str x0, [x20, #256] <== NOT EXECUTED
40025744: 39007262 strb w2, [x19, #28] <== NOT EXECUTED
_Thread_Heir = new_heir;
40025748: f9001675 str x21, [x19, #40] <== NOT EXECUTED
4002574c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40025750: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40025754: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
40025758: d65f03c0 ret <== NOT EXECUTED
4002575c: 00000000 udf #0
0000000040025760 <_Scheduler_simple_Unblock>:
void _Scheduler_simple_Unblock(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40025760: a9bd7bfd stp x29, x30, [sp, #-48]!
40025764: 910003fd mov x29, sp
return &the_chain->Tail.Node;
40025768: f9400003 ldr x3, [x0]
4002576c: a90153f3 stp x19, x20, [sp, #16]
40025770: aa0103f3 mov x19, x1
40025774: f9403421 ldr x1, [x1, #104]
40025778: a9025bf5 stp x21, x22, [sp, #32]
return _Chain_Immutable_head( the_chain )->next;
4002577c: f8408460 ldr x0, [x3], #8
40025780: f9401421 ldr x1, [x1, #40]
while ( next != tail && !( *order )( left, next ) ) {
40025784: eb00007f cmp x3, x0
40025788: 54000140 b.eq 400257b0 <_Scheduler_simple_Unblock+0x50> // b.none
4002578c: 32000024 orr w4, w1, #0x1
40025790: 14000004 b 400257a0 <_Scheduler_simple_Unblock+0x40>
return the_node->next;
40025794: f9400000 ldr x0, [x0]
while ( next != tail && !( *order )( left, next ) ) {
40025798: eb00007f cmp x3, x0
4002579c: 540000a0 b.eq 400257b0 <_Scheduler_simple_Unblock+0x50> // b.none
400257a0: f9403402 ldr x2, [x0, #104]
400257a4: f9401442 ldr x2, [x2, #40]
400257a8: eb04005f cmp x2, x4
400257ac: 54ffff43 b.cc 40025794 <_Scheduler_simple_Unblock+0x34> // b.lo, b.ul, b.last
* 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 ) ) {
400257b0: b00006f4 adrp x20, 40102000 <_RTEMS_tasks_Objects+0x13b8>
400257b4: 91320294 add x20, x20, #0xc80
return the_node->previous;
400257b8: f9400400 ldr x0, [x0, #8]
400257bc: f9401695 ldr x21, [x20, #40]
before_node = after_node->next;
400257c0: f9400002 ldr x2, [x0]
the_node->previous = after_node;
400257c4: f9000660 str x0, [x19, #8]
after_node->next = the_node;
400257c8: f9000013 str x19, [x0]
400257cc: f94036a0 ldr x0, [x21, #104]
400257d0: f9401400 ldr x0, [x0, #40]
the_node->next = before_node;
400257d4: f9000262 str x2, [x19]
before_node->previous = the_node;
400257d8: f9000453 str x19, [x2, #8]
400257dc: eb21401f cmp x0, w1, uxtw
400257e0: 540000a8 b.hi 400257f4 <_Scheduler_simple_Unblock+0x94> // b.pmore
_Scheduler_Update_heir(
the_thread,
priority == PRIORITY_PSEUDO_ISR
);
}
}
400257e4: a94153f3 ldp x19, x20, [sp, #16]
400257e8: a9425bf5 ldp x21, x22, [sp, #32]
400257ec: a8c37bfd ldp x29, x30, [sp], #48
400257f0: d65f03c0 ret
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
400257f4: eb1302bf cmp x21, x19
400257f8: 54ffff60 b.eq 400257e4 <_Scheduler_simple_Unblock+0x84> // b.none <== NEVER TAKEN
400257fc: 3943a6a0 ldrb w0, [x21, #233]
_Scheduler_Update_heir(
40025800: 7100003f cmp w1, #0x0
40025804: 1a9f17e1 cset w1, eq // eq = none
40025808: 2a010000 orr w0, w0, w1
4002580c: 34fffec0 cbz w0, 400257e4 <_Scheduler_simple_Unblock+0x84>
40025810: f9401a96 ldr x22, [x20, #48]
40025814: 97fffde3 bl 40024fa0 <_Timecounter_Sbinuptime>
40025818: f9001a80 str x0, [x20, #48]
_Thread_Dispatch_necessary = true;
4002581c: 52800022 mov w2, #0x1 // #1
*_result = *_end - *_start;
40025820: cb160000 sub x0, x0, x22
*_time += *_add;
40025824: f94082a1 ldr x1, [x21, #256]
40025828: 8b000020 add x0, x1, x0
4002582c: f90082a0 str x0, [x21, #256]
40025830: 39007282 strb w2, [x20, #28]
_Thread_Heir = new_heir;
40025834: f9001693 str x19, [x20, #40]
}
40025838: 17ffffeb b 400257e4 <_Scheduler_simple_Unblock+0x84>
4002583c: 00000000 udf #0
00000000400255f0 <_Scheduler_simple_Update_priority>:
)
{
Scheduler_simple_Context *context;
unsigned int new_priority;
if ( !_Thread_Is_ready( the_thread ) ) {
400255f0: b9403823 ldr w3, [x1, #56]
400255f4: 34000043 cbz w3, 400255fc <_Scheduler_simple_Update_priority+0xc> <== ALWAYS TAKEN
400255f8: d65f03c0 ret <== NOT EXECUTED
{
400255fc: a9bd7bfd stp x29, x30, [sp, #-48]!
40025600: 910003fd mov x29, sp
40025604: f9400005 ldr x5, [x0]
40025608: a90153f3 stp x19, x20, [sp, #16]
previous = the_node->previous;
4002560c: a9400026 ldp x6, x0, [x1]
40025610: a9025bf5 stp x21, x22, [sp, #32]
return &the_chain->Tail.Node;
40025614: aa0503e3 mov x3, x5
do {
seq = _SMP_sequence_lock_Read_begin( &node->Priority.Lock );
#endif
priority = node->Priority.value;
40025618: f9402444 ldr x4, [x2, #72]
next->previous = previous;
4002561c: f90004c0 str x0, [x6, #8]
previous->next = next;
40025620: f9000006 str x6, [x0]
return _Chain_Immutable_head( the_chain )->next;
40025624: f8408460 ldr x0, [x3], #8
)
{
const Chain_Node *tail = _Chain_Immutable_tail( the_chain );
Chain_Node *next = _Chain_First( the_chain );
while ( next != tail && !( *order )( left, next ) ) {
40025628: eb00007f cmp x3, x0
4002562c: 54000140 b.eq 40025654 <_Scheduler_simple_Update_priority+0x64> // b.none<== NEVER TAKEN
40025630: 92407c84 and x4, x4, #0xffffffff
40025634: 14000004 b 40025644 <_Scheduler_simple_Update_priority+0x54>
return the_node->next;
40025638: f9400000 ldr x0, [x0]
while ( next != tail && !( *order )( left, next ) ) {
4002563c: eb00007f cmp x3, x0
40025640: 540000a0 b.eq 40025654 <_Scheduler_simple_Update_priority+0x64> // b.none
return aggregation->Node.priority;
40025644: f9403402 ldr x2, [x0, #104]
40025648: f9401442 ldr x2, [x2, #40]
4002564c: eb02009f cmp x4, x2
40025650: 54ffff48 b.hi 40025638 <_Scheduler_simple_Update_priority+0x48> // b.pmore
return the_node->previous;
40025654: f9400400 ldr x0, [x0, #8]
Thread_Control *heir = _Thread_Heir;
40025658: b00006f3 adrp x19, 40102000 <_RTEMS_tasks_Objects+0x13b8>
4002565c: 91320273 add x19, x19, #0xc80
before_node = after_node->next;
40025660: f9400002 ldr x2, [x0]
40025664: f9401674 ldr x20, [x19, #40]
the_node->previous = after_node;
40025668: f9000420 str x0, [x1, #8]
after_node->next = the_node;
4002566c: f9000001 str x1, [x0]
the_node->next = before_node;
40025670: f9000022 str x2, [x1]
return _Chain_Immutable_head( the_chain )->next;
40025674: f94000b5 ldr x21, [x5]
before_node->previous = the_node;
40025678: f9000441 str x1, [x2, #8]
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
4002567c: eb1402bf cmp x21, x20
40025680: 54000060 b.eq 4002568c <_Scheduler_simple_Update_priority+0x9c> // b.none
40025684: 3943a680 ldrb w0, [x20, #233]
40025688: 350000a0 cbnz w0, 4002569c <_Scheduler_simple_Update_priority+0xac> <== NEVER TAKEN
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 );
}
4002568c: a94153f3 ldp x19, x20, [sp, #16]
40025690: a9425bf5 ldp x21, x22, [sp, #32]
40025694: a8c37bfd ldp x29, x30, [sp], #48
40025698: d65f03c0 ret
4002569c: f9401a76 ldr x22, [x19, #48] <== NOT EXECUTED
400256a0: 97fffe40 bl 40024fa0 <_Timecounter_Sbinuptime> <== NOT EXECUTED
400256a4: f9001a60 str x0, [x19, #48] <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
400256a8: 52800022 mov w2, #0x1 // #1 <== NOT EXECUTED
*_result = *_end - *_start;
400256ac: cb160000 sub x0, x0, x22 <== NOT EXECUTED
*_time += *_add;
400256b0: f9408281 ldr x1, [x20, #256] <== NOT EXECUTED
400256b4: 8b000020 add x0, x1, x0 <== NOT EXECUTED
400256b8: f9008280 str x0, [x20, #256] <== NOT EXECUTED
400256bc: 39007262 strb w2, [x19, #28] <== NOT EXECUTED
_Thread_Heir = new_heir;
400256c0: f9001675 str x21, [x19, #40] <== NOT EXECUTED
400256c4: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
400256c8: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
400256cc: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
400256d0: d65f03c0 ret <== NOT EXECUTED
...
0000000040025840 <_Scheduler_simple_Yield>:
void _Scheduler_simple_Yield(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
40025840: a9bd7bfd stp x29, x30, [sp, #-48]!
40025844: 910003fd mov x29, sp
return scheduler->context;
40025848: f9400005 ldr x5, [x0]
4002584c: a90153f3 stp x19, x20, [sp, #16]
previous = the_node->previous;
40025850: a9400022 ldp x2, x0, [x1]
40025854: a9025bf5 stp x21, x22, [sp, #32]
return &the_chain->Tail.Node;
40025858: aa0503e4 mov x4, x5
4002585c: f9403423 ldr x3, [x1, #104]
context = _Scheduler_simple_Get_context( scheduler );
(void) node;
_Chain_Extract_unprotected( &the_thread->Object.Node );
insert_priority = (unsigned int) _Thread_Get_priority( the_thread );
40025860: f9401463 ldr x3, [x3, #40]
next->previous = previous;
40025864: f9000440 str x0, [x2, #8]
previous->next = next;
40025868: f9000002 str x2, [x0]
return _Chain_Immutable_head( the_chain )->next;
4002586c: f8408480 ldr x0, [x4], #8
while ( next != tail && !( *order )( left, next ) ) {
40025870: eb00009f cmp x4, x0
40025874: 54000140 b.eq 4002589c <_Scheduler_simple_Yield+0x5c> // b.none <== NEVER TAKEN
40025878: 32000063 orr w3, w3, #0x1
4002587c: 14000004 b 4002588c <_Scheduler_simple_Yield+0x4c>
return the_node->next;
40025880: f9400000 ldr x0, [x0]
while ( next != tail && !( *order )( left, next ) ) {
40025884: eb00009f cmp x4, x0
40025888: 540000a0 b.eq 4002589c <_Scheduler_simple_Yield+0x5c> // b.none <== NEVER TAKEN
4002588c: f9403402 ldr x2, [x0, #104]
40025890: f9401442 ldr x2, [x2, #40]
40025894: eb02007f cmp x3, x2
40025898: 54ffff48 b.hi 40025880 <_Scheduler_simple_Yield+0x40> // b.pmore
return the_node->previous;
4002589c: f9400400 ldr x0, [x0, #8]
Thread_Control *heir = _Thread_Heir;
400258a0: b00006f3 adrp x19, 40102000 <_RTEMS_tasks_Objects+0x13b8>
400258a4: 91320273 add x19, x19, #0xc80
before_node = after_node->next;
400258a8: f9400002 ldr x2, [x0]
400258ac: f9401674 ldr x20, [x19, #40]
the_node->previous = after_node;
400258b0: f9000420 str x0, [x1, #8]
after_node->next = the_node;
400258b4: f9000001 str x1, [x0]
the_node->next = before_node;
400258b8: f9000022 str x2, [x1]
return _Chain_Immutable_head( the_chain )->next;
400258bc: f94000b5 ldr x21, [x5]
before_node->previous = the_node;
400258c0: f9000441 str x1, [x2, #8]
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
400258c4: eb1402bf cmp x21, x20
400258c8: 54000060 b.eq 400258d4 <_Scheduler_simple_Yield+0x94> // b.none
400258cc: 3943a680 ldrb w0, [x20, #233]
400258d0: 350000a0 cbnz w0, 400258e4 <_Scheduler_simple_Yield+0xa4> <== NEVER TAKEN
insert_priority = SCHEDULER_PRIORITY_APPEND( insert_priority ); _Scheduler_simple_Insert( &context->Ready, the_thread, insert_priority ); _Scheduler_simple_Schedule_body( scheduler, the_thread, false ); }
400258d4: a94153f3 ldp x19, x20, [sp, #16]
400258d8: a9425bf5 ldp x21, x22, [sp, #32]
400258dc: a8c37bfd ldp x29, x30, [sp], #48
400258e0: d65f03c0 ret
400258e4: f9401a76 ldr x22, [x19, #48] <== NOT EXECUTED
400258e8: 97fffdae bl 40024fa0 <_Timecounter_Sbinuptime> <== NOT EXECUTED
400258ec: f9001a60 str x0, [x19, #48] <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
400258f0: 52800022 mov w2, #0x1 // #1 <== NOT EXECUTED
*_result = *_end - *_start;
400258f4: cb160000 sub x0, x0, x22 <== NOT EXECUTED
*_time += *_add;
400258f8: f9408281 ldr x1, [x20, #256] <== NOT EXECUTED
400258fc: 8b000020 add x0, x1, x0 <== NOT EXECUTED
40025900: f9008280 str x0, [x20, #256] <== NOT EXECUTED
40025904: 39007262 strb w2, [x19, #28] <== NOT EXECUTED
_Thread_Heir = new_heir;
40025908: f9001675 str x21, [x19, #40] <== NOT EXECUTED
4002590c: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
40025910: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40025914: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
40025918: d65f03c0 ret <== NOT EXECUTED
4002591c: 00000000 udf #0
0000000040025940 <_TOD_Set>:
Status_Control _TOD_Set(
const struct timespec *tod,
ISR_lock_Context *lock_context
)
{
40025940: a9bb7bfd stp x29, x30, [sp, #-80]!
40025944: 910003fd mov x29, sp
40025948: a90153f3 stp x19, x20, [sp, #16]
4002594c: aa0103f4 mov x20, x1
40025950: f90013f5 str x21, [sp, #32]
&& (unsigned long) ts->tv_nsec < WATCHDOG_NANOSECONDS_PER_SECOND;
40025954: b40000e0 cbz x0, 40025970 <_TOD_Set+0x30> <== NEVER TAKEN
40025958: aa0003f3 mov x19, x0
4002595c: d2993fe0 mov x0, #0xc9ff // #51711
40025960: f2a77340 movk x0, #0x3b9a, lsl #16
40025964: f9400661 ldr x1, [x19, #8]
40025968: eb00003f cmp x1, x0
4002596c: 54000129 b.ls 40025990 <_TOD_Set+0x50> // b.plast
return STATUS_INVALID_NUMBER;
40025970: 5282c155 mov w21, #0x160a // #5642
_Timecounter_Release( lock_context );
40025974: b9400280 ldr w0, [x20]
40025978: d51b4220 msr daif, x0
}
_TOD.is_set = true;
return STATUS_SUCCESSFUL;
}
4002597c: 2a1503e0 mov w0, w21
40025980: a94153f3 ldp x19, x20, [sp, #16]
40025984: f94013f5 ldr x21, [sp, #32]
40025988: a8c57bfd ldp x29, x30, [sp], #80
4002598c: d65f03c0 ret
if ( _Watchdog_Is_far_future_timespec( tod ) ) {
40025990: f9400260 ldr x0, [x19]
40025994: 929c9fe2 mov x2, #0xffffffffffff1b00 // #-58624
40025998: f2bbc4a2 movk x2, #0xde25, lsl #16
4002599c: d2835fe1 mov x1, #0x1aff // #6911
400259a0: f2bbc4a1 movk x1, #0xde25, lsl #16
400259a4: 8b020000 add x0, x0, x2
400259a8: f2c00061 movk x1, #0x3, lsl #32
400259ac: eb01001f cmp x0, x1
400259b0: 54fffe08 b.hi 40025970 <_TOD_Set+0x30> // b.pmore
return _TOD_Hook_Run( TOD_ACTION_SET_CLOCK, tod );
400259b4: aa1303e1 mov x1, x19
400259b8: 52800000 mov w0, #0x0 // #0
400259bc: 9400112d bl 40029e70 <_TOD_Hook_Run>
400259c0: 2a0003f5 mov w21, w0
if ( status != STATUS_SUCCESSFUL ) {
400259c4: 35fffd80 cbnz w0, 40025974 <_TOD_Set+0x34>
_bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL;
400259c8: a9400a63 ldp x3, x2, [x19]
400259cc: d29f4120 mov x0, #0xfa09 // #64009
400259d0: f2a97040 movk x0, #0x4b82, lsl #16
_Timecounter_Set_clock( &tod_as_bintime, lock_context );
400259d4: aa1403e1 mov x1, x20
400259d8: f2c00080 movk x0, #0x4, lsl #32
400259dc: 9b007c42 mul x2, x2, x0
400259e0: 910103e0 add x0, sp, #0x40
400259e4: a9040be3 stp x3, x2, [sp, #64]
400259e8: 94000182 bl 40025ff0 <_Timecounter_Set_clock>
ticks |= (uint32_t) ts->tv_nsec;
400259ec: a9400262 ldp x2, x0, [x19]
__asm__ volatile (
400259f0: d53b4221 mrs x1, daif
400259f4: d50342df msr daifset, #0x2
_ISR_lock_ISR_disable_and_acquire( &cpu->Watchdog.Lock, &lock_context );
400259f8: b9003be1 str w1, [sp, #56]
return (Watchdog_Control *) header->first;
400259fc: f00006e1 adrp x1, 40104000 <_RTEMS_tasks_Objects+0x1760>
40025a00: f946ac21 ldr x1, [x1, #3416]
if ( first != NULL ) {
40025a04: b40000e1 cbz x1, 40025a20 <_TOD_Set+0xe0>
ticks |= (uint32_t) ts->tv_nsec;
40025a08: 92407c00 and x0, x0, #0xffffffff
_Watchdog_Tickle(
40025a0c: 9100e3e3 add x3, sp, #0x38
40025a10: aa027802 orr x2, x0, x2, lsl #30
40025a14: f00006e0 adrp x0, 40104000 <_RTEMS_tasks_Objects+0x1760>
40025a18: 91354000 add x0, x0, #0xd50
40025a1c: 94000b69 bl 400287c0 <_Watchdog_Do_tickle>
_ISR_lock_Release_and_ISR_enable( &cpu->Watchdog.Lock, &lock_context );
40025a20: b9403be0 ldr w0, [sp, #56]
__asm__ volatile (
40025a24: d51b4220 msr daif, x0
_TOD.is_set = true;
40025a28: f00006e0 adrp x0, 40104000 <_RTEMS_tasks_Objects+0x1760>
40025a2c: 52800021 mov w1, #0x1 // #1
}
40025a30: a94153f3 ldp x19, x20, [sp, #16]
_TOD.is_set = true;
40025a34: 39336001 strb w1, [x0, #3288]
}
40025a38: 2a1503e0 mov w0, w21
40025a3c: f94013f5 ldr x21, [sp, #32]
40025a40: a8c57bfd ldp x29, x30, [sp], #80
40025a44: d65f03c0 ret
...
0000000040025240 <_Terminate>:
void _Terminate(
Internal_errors_Source the_source,
Internal_errors_t the_error
)
{
40025240: a9bd7bfd stp x29, x30, [sp, #-48]!
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, error };
_User_extensions_Iterate(
40025244: 52800002 mov w2, #0x0 // #0
40025248: 910003fd mov x29, sp
4002524c: a90153f3 stp x19, x20, [sp, #16]
40025250: 2a0003f4 mov w20, w0
40025254: aa0103f3 mov x19, x1
40025258: 910083e0 add x0, sp, #0x20
4002525c: d0000001 adrp x1, 40027000 <_Thread_queue_Priority_enqueue+0xa0>
40025260: 91294021 add x1, x1, #0xa50
User_extensions_Fatal_context ctx = { source, error };
40025264: b90023f4 str w20, [sp, #32]
40025268: f90017f3 str x19, [sp, #40]
_User_extensions_Iterate(
4002526c: 94000a0d bl 40027aa0 <_User_extensions_Iterate>
_User_extensions_Fatal( the_source, the_error );
_Internal_errors_What_happened.the_source = the_source;
40025270: 90000700 adrp x0, 40105000 <Arr_2_Glob+0x1e68> <== NOT EXECUTED
40025274: 9127e001 add x1, x0, #0x9f8 <== NOT EXECUTED
_System_state_Current = state;
40025278: 90000702 adrp x2, 40105000 <Arr_2_Glob+0x1e68> <== NOT EXECUTED
4002527c: 52800063 mov w3, #0x3 // #3 <== NOT EXECUTED
40025280: b909f814 str w20, [x0, #2552] <== NOT EXECUTED
40025284: b90a0843 str w3, [x2, #2568] <== NOT EXECUTED
_Internal_errors_What_happened.the_error = the_error;
40025288: f9000433 str x19, [x1, #8] <== NOT EXECUTED
__asm__ volatile (
4002528c: d53b4220 mrs x0, daif <== NOT EXECUTED
40025290: d50342df msr daifset, #0x2 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_TERMINATED );
_SMP_Request_shutdown();
_CPU_Fatal_halt( the_source, the_error );
40025294: aa1303e0 mov x0, x19 <== NOT EXECUTED
40025298: 14000000 b 40025298 <_Terminate+0x58> <== NOT EXECUTED
4002529c: 00000000 udf #0
0000000040029ae0 <_Thread_Allocate_unlimited>:
}
}
}
Objects_Control *_Thread_Allocate_unlimited( Objects_Information *information )
{
40029ae0: a9bd7bfd stp x29, x30, [sp, #-48]!
40029ae4: 910003fd mov x29, sp
return _Chain_Immutable_head( the_chain )->next;
40029ae8: f9401401 ldr x1, [x0, #40]
40029aec: a90153f3 stp x19, x20, [sp, #16]
return &the_chain->Tail.Node;
40029af0: 9100c014 add x20, x0, #0x30
40029af4: a9025bf5 stp x21, x22, [sp, #32]
40029af8: aa0003f3 mov x19, x0
return _Chain_Immutable_head( the_chain )->next;
40029afc: 9100a015 add x21, x0, #0x28
if ( !_Chain_Is_empty(the_chain))
40029b00: eb14003f cmp x1, x20
40029b04: 54000300 b.eq 40029b64 <_Thread_Allocate_unlimited+0x84> // b.none
new_first = old_first->next;
40029b08: f9400020 ldr x0, [x1]
head->next = new_first;
40029b0c: f9001660 str x0, [x19, #40]
Objects_Maximum objects_per_block;
Objects_Maximum block;
_Assert( _Objects_Is_auto_extend( information ) );
objects_per_block = information->objects_per_block;
40029b10: 79404663 ldrh w3, [x19, #34]
new_first->previous = head;
40029b14: f9000415 str x21, [x0, #8]
40029b18: b9401020 ldr w0, [x1, #16]
block = _Objects_Get_index( the_object->id ) - OBJECTS_INDEX_MINIMUM;
40029b1c: 51000400 sub w0, w0, #0x1
40029b20: 12003c02 and w2, w0, #0xffff
if ( block > objects_per_block ) {
40029b24: 6b20207f cmp w3, w0, uxth
40029b28: 54000142 b.cs 40029b50 <_Thread_Allocate_unlimited+0x70> // b.hs, b.nlast
block /= objects_per_block;
information->inactive_per_block[ block ]--;
40029b2c: 1ac30842 udiv w2, w2, w3
40029b30: f9402263 ldr x3, [x19, #64]
40029b34: d37f3c42 ubfiz x2, x2, #1, #16
40029b38: 78626860 ldrh w0, [x3, x2]
40029b3c: 51000400 sub w0, w0, #0x1
40029b40: 78226860 strh w0, [x3, x2]
information->inactive--;
40029b44: 79404260 ldrh w0, [x19, #32]
40029b48: 51000400 sub w0, w0, #0x1
40029b4c: 79004260 strh w0, [x19, #32]
return _Objects_Allocate_with_extend(
information,
_Thread_Extend_information
);
}
40029b50: aa0103e0 mov x0, x1
40029b54: a94153f3 ldp x19, x20, [sp, #16]
40029b58: a9425bf5 ldp x21, x22, [sp, #32]
40029b5c: a8c37bfd ldp x29, x30, [sp], #48
40029b60: d65f03c0 ret
block = _Objects_Extend_information( &information->Objects );
40029b64: 97fffcdf bl 40028ee0 <_Objects_Extend_information>
40029b68: 2a0003f6 mov w22, w0
if ( block > 0 ) {
40029b6c: 72003c1f tst w0, #0xffff
40029b70: 540000c1 b.ne 40029b88 <_Thread_Allocate_unlimited+0xa8> // b.any <== ALWAYS TAKEN
return _Chain_Immutable_head( the_chain )->next;
40029b74: f9401661 ldr x1, [x19, #40]
if ( !_Chain_Is_empty(the_chain))
40029b78: eb01029f cmp x20, x1
40029b7c: 54fffc61 b.ne 40029b08 <_Thread_Allocate_unlimited+0x28> // b.any <== ALWAYS TAKEN
return NULL;
40029b80: d2800001 mov x1, #0x0 // #0 <== NOT EXECUTED
40029b84: 17fffff3 b 40029b50 <_Thread_Allocate_unlimited+0x70> <== NOT EXECUTED
new_heads = _Freechain_Extend(
40029b88: 79404662 ldrh w2, [x19, #34]
40029b8c: d0000001 adrp x1, 4002b000 <_Thread_Cancel+0x70>
40029b90: 91016260 add x0, x19, #0x58
40029b94: 9133c021 add x1, x1, #0xcf0
40029b98: d2800e03 mov x3, #0x70 // #112
40029b9c: 94002395 bl 400329f0 <_Freechain_Extend>
if ( new_heads == NULL ) {
40029ba0: b5fffea0 cbnz x0, 40029b74 <_Thread_Allocate_unlimited+0x94> <== ALWAYS TAKEN
_Objects_Free_objects_block( &information->Objects, block );
40029ba4: 2a1603e1 mov w1, w22 <== NOT EXECUTED
40029ba8: aa1303e0 mov x0, x19 <== NOT EXECUTED
40029bac: 97fffd91 bl 400291f0 <_Objects_Free_objects_block> <== NOT EXECUTED
40029bb0: 17fffff1 b 40029b74 <_Thread_Allocate_unlimited+0x94> <== NOT EXECUTED
...
000000004002b6f0 <_Thread_Cancel>:
void _Thread_Cancel(
Thread_Control *the_thread,
Thread_Control *executing,
void *exit_value
)
{
4002b6f0: a9bd7bfd stp x29, x30, [sp, #-48]!
4002b6f4: 910003fd mov x29, sp
4002b6f8: a90153f3 stp x19, x20, [sp, #16]
4002b6fc: aa0003f3 mov x19, x0
4002b700: a9025bf5 stp x21, x22, [sp, #32]
__asm__ volatile (
4002b704: d53b4235 mrs x21, daif
4002b708: d50342df msr daifset, #0x2
previous = the_thread->Life.state;
4002b70c: b9426803 ldr w3, [x0, #616]
if (
4002b710: 52800124 mov w4, #0x9 // #9
the_thread->Life.exit_value = exit_value;
4002b714: f9013802 str x2, [x0, #624]
state |= set;
4002b718: 321e0062 orr w2, w3, #0x4
the_thread->Life.state = state;
4002b71c: b9026802 str w2, [x0, #616]
if (
4002b720: 6a04007f tst w3, w4
4002b724: 540004c1 b.ne 4002b7bc <_Thread_Cancel+0xcc> // b.any
the_thread->is_preemptible = the_thread->Start.is_preemptible;
4002b728: 39448003 ldrb w3, [x0, #288]
cpu_self->dispatch_necessary = true;
4002b72c: b00006d4 adrp x20, 40104000 <rtems_libio_iops+0x260>
4002b730: 91080294 add x20, x20, #0x200
4002b734: 3903a663 strb w3, [x19, #233]
the_thread->budget_callout = the_thread->Start.budget_callout;
4002b738: f9409663 ldr x3, [x19, #296]
4002b73c: f9007e63 str x3, [x19, #248]
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
4002b740: b9412664 ldr w4, [x19, #292]
action->handler = handler;
4002b744: 91094002 add x2, x0, #0x250
if ( _Chain_Is_node_off_chain( the_node ) ) {
4002b748: f9412a63 ldr x3, [x19, #592]
4002b74c: 90000000 adrp x0, 4002b000 <_Thread_queue_FIFO_enqueue+0x30>
4002b750: 91120000 add x0, x0, #0x480
4002b754: b900f264 str w4, [x19, #240]
4002b758: f9013260 str x0, [x19, #608]
4002b75c: 52800024 mov w4, #0x1 // #1
4002b760: 39007284 strb w4, [x20, #28]
4002b764: b4000823 cbz x3, 4002b868 <_Thread_Cancel+0x178>
return aggregation->Node.priority;
4002b768: f9403421 ldr x1, [x1, #104]
disable_level = cpu_self->thread_dispatch_disable_level;
4002b76c: b9401a80 ldr w0, [x20, #24]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4002b770: 11000400 add w0, w0, #0x1
4002b774: f9401436 ldr x22, [x1, #40]
4002b778: b9001a80 str w0, [x20, #24]
);
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
priority = _Thread_Get_priority( executing );
if ( _States_Is_dormant( the_thread->current_state ) ) {
4002b77c: b9403a60 ldr w0, [x19, #56]
4002b780: 37f80620 tbnz w0, #31, 4002b844 <_Thread_Cancel+0x154>
pending_requests = the_thread->Life.pending_life_change_requests;
4002b784: b9426e60 ldr w0, [x19, #620]
the_thread->Life.pending_life_change_requests = pending_requests + 1;
4002b788: 11000401 add w1, w0, #0x1
4002b78c: b9026e61 str w1, [x19, #620]
if ( pending_requests == 0 ) {
4002b790: 34000840 cbz w0, 4002b898 <_Thread_Cancel+0x1a8> <== ALWAYS TAKEN
__asm__ volatile (
4002b794: 92407eb5 and x21, x21, #0xffffffff
4002b798: d51b4235 msr daif, x21
_Thread_queue_Extract_with_proxy( the_thread );
4002b79c: aa1303e0 mov x0, x19
4002b7a0: 940018ec bl 40031b50 <_Thread_queue_Extract_with_proxy>
__asm__ volatile (
4002b7a4: d53b4235 mrs x21, daif
4002b7a8: d50342df msr daifset, #0x2
4002b7ac: f9405a60 ldr x0, [x19, #176]
4002b7b0: 9102e261 add x1, x19, #0xb8
4002b7b4: 94000247 bl 4002c0d0 <_Watchdog_Remove>
_Per_CPU_Get(),
#endif
the_thread->Timer.header
);
_ISR_lock_Release_and_ISR_enable( &the_thread->Timer.Lock, &lock_context );
4002b7b8: 14000011 b 4002b7fc <_Thread_Cancel+0x10c>
disable_level = cpu_self->thread_dispatch_disable_level;
4002b7bc: b00006d4 adrp x20, 40104000 <rtems_libio_iops+0x260>
4002b7c0: 91080294 add x20, x20, #0x200
4002b7c4: b9401a82 ldr w2, [x20, #24]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4002b7c8: 11000442 add w2, w2, #0x1
4002b7cc: b9001a82 str w2, [x20, #24]
if ( _States_Is_dormant( the_thread->current_state ) ) {
4002b7d0: b9403802 ldr w2, [x0, #56]
4002b7d4: 37f80382 tbnz w2, #31, 4002b844 <_Thread_Cancel+0x154> <== NEVER TAKEN
4002b7d8: f9403423 ldr x3, [x1, #104]
pending_requests = the_thread->Life.pending_life_change_requests;
4002b7dc: b9426e61 ldr w1, [x19, #620]
the_thread->Life.pending_life_change_requests = pending_requests + 1;
4002b7e0: 11000422 add w2, w1, #0x1
4002b7e4: f9401476 ldr x22, [x3, #40]
4002b7e8: b9026e62 str w2, [x19, #620]
if ( pending_requests == 0 ) {
4002b7ec: 340005e1 cbz w1, 4002b8a8 <_Thread_Cancel+0x1b8> <== ALWAYS TAKEN
_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 );
4002b7f0: aa1303e0 mov x0, x19
4002b7f4: 52900001 mov w1, #0x8000 // #32768
4002b7f8: 940017be bl 400316f0 <_Thread_Clear_state_locked>
__asm__ volatile (
4002b7fc: 92407eb5 and x21, x21, #0xffffffff
4002b800: d51b4235 msr daif, x21
_Thread_State_release( the_thread, &lock_context );
_Thread_Raise_real_priority( the_thread, priority );
4002b804: aa1603e1 mov x1, x22
4002b808: aa1303e0 mov x0, x19
4002b80c: 97fffead bl 4002b2c0 <_Thread_Raise_real_priority>
__asm__ volatile (
4002b810: d53b4235 mrs x21, daif
4002b814: d50342df msr daifset, #0x2
pending_requests = the_thread->Life.pending_life_change_requests;
4002b818: b9426e60 ldr w0, [x19, #620]
if ( pending_requests == 1 ) {
4002b81c: 71000401 subs w1, w0, #0x1
the_thread->Life.pending_life_change_requests = pending_requests - 1;
4002b820: b9026e61 str w1, [x19, #620]
if ( pending_requests == 1 ) {
4002b824: 54000300 b.eq 4002b884 <_Thread_Cancel+0x194> // b.none <== ALWAYS TAKEN
__asm__ volatile (
4002b828: 92407eb5 and x21, x21, #0xffffffff
4002b82c: d51b4235 msr daif, x21
_Thread_Remove_life_change_request( the_thread );
}
_Thread_Dispatch_enable( cpu_self );
4002b830: aa1403e0 mov x0, x20
}
4002b834: a94153f3 ldp x19, x20, [sp, #16]
4002b838: a9425bf5 ldp x21, x22, [sp, #32]
4002b83c: a8c37bfd ldp x29, x30, [sp], #48
_Thread_Dispatch_enable( cpu_self );
4002b840: 17fffb18 b 4002a4a0 <_Thread_Dispatch_enable>
4002b844: 92407eb5 and x21, x21, #0xffffffff
4002b848: d51b4235 msr daif, x21
_Thread_Make_zombie( the_thread );
4002b84c: aa1303e0 mov x0, x19
4002b850: 97fffedc bl 4002b3c0 <_Thread_Make_zombie>
_Thread_Dispatch_enable( cpu_self );
4002b854: aa1403e0 mov x0, x20
}
4002b858: a94153f3 ldp x19, x20, [sp, #16]
4002b85c: a9425bf5 ldp x21, x22, [sp, #32]
4002b860: a8c37bfd ldp x29, x30, [sp], #48
_Thread_Dispatch_enable( cpu_self );
4002b864: 17fffb0f b 4002a4a0 <_Thread_Dispatch_enable>
old_last = tail->previous;
4002b868: f940ba63 ldr x3, [x19, #368]
4002b86c: 9105a260 add x0, x19, #0x168
tail->previous = the_node;
4002b870: f900ba62 str x2, [x19, #368]
the_node->next = tail;
4002b874: f9012a60 str x0, [x19, #592]
old_last->next = the_node;
4002b878: f9000062 str x2, [x3]
the_node->previous = old_last;
4002b87c: f9012e63 str x3, [x19, #600]
}
4002b880: 17ffffba b 4002b768 <_Thread_Cancel+0x78>
_Thread_Clear_state_locked(
4002b884: aa1303e0 mov x0, x19
4002b888: 52906181 mov w1, #0x830c // #33548
4002b88c: 72a60041 movk w1, #0x3002, lsl #16
4002b890: 94001798 bl 400316f0 <_Thread_Clear_state_locked>
4002b894: 17ffffe5 b 4002b828 <_Thread_Cancel+0x138>
_Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING );
4002b898: aa1303e0 mov x0, x19
4002b89c: 52a00041 mov w1, #0x20000 // #131072
4002b8a0: 94000074 bl 4002ba70 <_Thread_Set_state_locked>
4002b8a4: 17ffffbc b 4002b794 <_Thread_Cancel+0xa4>
4002b8a8: 52a00041 mov w1, #0x20000 // #131072
4002b8ac: 94000071 bl 4002ba70 <_Thread_Set_state_locked>
4002b8b0: 17ffffd0 b 4002b7f0 <_Thread_Cancel+0x100>
...
0000000040029050 <_Thread_Change_life>:
Thread_Life_state _Thread_Change_life(
Thread_Life_state clear,
Thread_Life_state set,
Thread_Life_state ignore
)
{
40029050: a9be7bfd stp x29, x30, [sp, #-32]!
40029054: 2a0003e4 mov w4, w0
40029058: 910003fd mov x29, sp
4002905c: f9000bf3 str x19, [sp, #16]
__asm__ volatile (
40029060: d53b4225 mrs x5, daif
40029064: d50342df msr daifset, #0x2
40029068: d00006c3 adrp x3, 40103000 <_POSIX_Threads_Objects+0xb38>
4002906c: 912c0060 add x0, x3, #0xb00
& ( THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED ) ) == 0;
40029070: 52800126 mov w6, #0x9 // #9
40029074: f9401003 ldr x3, [x0, #32]
previous = the_thread->Life.state;
40029078: b9426873 ldr w19, [x3, #616]
state &= ~clear;
4002907c: 0a240264 bic w4, w19, w4
state |= set;
40029080: 2a040021 orr w1, w1, w4
the_thread->Life.state = state;
40029084: b9026861 str w1, [x3, #616]
state &= ~ignore;
40029088: 0a220021 bic w1, w1, w2
if (
4002908c: 6a06003f tst w1, w6
40029090: 54000221 b.ne 400290d4 <_Thread_Change_life+0x84> // b.any
&& _Thread_Is_life_changing( state )
40029094: 721f043f tst w1, #0x6
40029098: 540001e0 b.eq 400290d4 <_Thread_Change_life+0x84> // b.none
the_thread->is_preemptible = the_thread->Start.is_preemptible;
4002909c: 39448064 ldrb w4, [x3, #288]
action->handler = handler;
400290a0: f0ffffe1 adrp x1, 40028000 <_Thread_queue_Priority_priority_actions+0x50>
400290a4: 912d8021 add x1, x1, #0xb60
400290a8: 3903a464 strb w4, [x3, #233]
the_thread->budget_callout = the_thread->Start.budget_callout;
400290ac: f9409464 ldr x4, [x3, #296]
400290b0: f9007c64 str x4, [x3, #248]
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
400290b4: b9412466 ldr w6, [x3, #292]
400290b8: 91094062 add x2, x3, #0x250
if ( _Chain_Is_node_off_chain( the_node ) ) {
400290bc: f9412864 ldr x4, [x3, #592]
400290c0: b900f066 str w6, [x3, #240]
400290c4: f9013061 str x1, [x3, #608]
400290c8: 52800026 mov w6, #0x1 // #1
400290cc: 39007006 strb w6, [x0, #28]
400290d0: b4000164 cbz x4, 400290fc <_Thread_Change_life+0xac> <== ALWAYS TAKEN
disable_level = cpu_self->thread_dispatch_disable_level;
400290d4: b9401801 ldr w1, [x0, #24]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
400290d8: 11000421 add w1, w1, #0x1
400290dc: b9001801 str w1, [x0, #24]
__asm__ volatile (
400290e0: 92407ca1 and x1, x5, #0xffffffff
400290e4: d51b4221 msr daif, x1
previous = _Thread_Change_life_locked( executing, clear, set, ignore );
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
_Thread_State_release( executing, &lock_context );
_Thread_Dispatch_enable( cpu_self );
400290e8: 97fff986 bl 40027700 <_Thread_Dispatch_enable>
return previous;
}
400290ec: 2a1303e0 mov w0, w19
400290f0: f9400bf3 ldr x19, [sp, #16]
400290f4: a8c27bfd ldp x29, x30, [sp], #32
400290f8: d65f03c0 ret
old_last = tail->previous;
400290fc: f940b864 ldr x4, [x3, #368]
40029100: 9105a061 add x1, x3, #0x168
tail->previous = the_node;
40029104: f900b862 str x2, [x3, #368]
the_node->next = tail;
40029108: f9012861 str x1, [x3, #592]
old_last->next = the_node;
4002910c: f9000082 str x2, [x4]
the_node->previous = old_last;
40029110: f9012c64 str x4, [x3, #600]
}
40029114: 17fffff0 b 400290d4 <_Thread_Change_life+0x84>
...
0000000040029fd0 <_Thread_Clear_state_locked>:
States_Control _Thread_Clear_state_locked(
Thread_Control *the_thread,
States_Control state
)
{
40029fd0: a9be7bfd stp x29, x30, [sp, #-32]!
40029fd4: 910003fd mov x29, sp
40029fd8: f9000bf3 str x19, [sp, #16]
States_Control previous_state;
_Assert( state != 0 );
_Assert( _Thread_State_is_owner( the_thread ) );
previous_state = the_thread->current_state;
40029fdc: b9403813 ldr w19, [x0, #56]
if ( ( previous_state & state ) != 0 ) {
40029fe0: 6a01027f tst w19, w1
40029fe4: 54000160 b.eq 4002a010 <_Thread_Clear_state_locked+0x40> // b.none
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
40029fe8: 0a210262 bic w2, w19, w1
States_Control next_state;
next_state = _States_Clear( state, previous_state );
the_thread->current_state = next_state;
40029fec: b9003802 str w2, [x0, #56]
*/
RTEMS_INLINE_ROUTINE bool _States_Is_ready (
States_Control the_states
)
{
return (the_states == STATES_READY);
40029ff0: aa0003e3 mov x3, x0
if ( _States_Is_ready( next_state ) ) {
40029ff4: 350000e2 cbnz w2, 4002a010 <_Thread_Clear_state_locked+0x40> <== NEVER TAKEN
( *scheduler->Operations.unblock )( scheduler, the_thread, scheduler_node );
40029ff8: d0000080 adrp x0, 4003b000 <__sfvwrite_r+0x5d4>
40029ffc: 913ee000 add x0, x0, #0xfb8
4002a000: f9403462 ldr x2, [x3, #104]
4002a004: aa0303e1 mov x1, x3
4002a008: f9401404 ldr x4, [x0, #40]
4002a00c: d63f0080 blr x4
_Scheduler_Unblock( the_thread );
}
}
return previous_state;
}
4002a010: 2a1303e0 mov w0, w19
4002a014: f9400bf3 ldr x19, [sp, #16]
4002a018: a8c27bfd ldp x29, x30, [sp], #32
4002a01c: d65f03c0 ret
00000000400263a0 <_Thread_Dispatch_enable>:
}
void _Thread_Dispatch_enable( Per_CPU_Control *cpu_self )
{
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
400263a0: b9401801 ldr w1, [x0, #24]
if ( disable_level == 1 ) {
400263a4: 7100043f cmp w1, #0x1
400263a8: 54000080 b.eq 400263b8 <_Thread_Dispatch_enable+0x18> // b.none
_Profiling_Thread_dispatch_enable( cpu_self, 0 );
_ISR_Local_enable( level );
}
} else {
_Assert( disable_level > 0 );
cpu_self->thread_dispatch_disable_level = disable_level - 1;
400263ac: 51000421 sub w1, w1, #0x1
400263b0: b9001801 str w1, [x0, #24]
} }
400263b4: d65f03c0 ret
400263b8: d53b4221 mrs x1, daif
400263bc: d50342df msr daifset, #0x2
cpu_self->dispatch_necessary
400263c0: 39407002 ldrb w2, [x0, #28]
if (
400263c4: 72001c5f tst w2, #0xff
400263c8: 54000061 b.ne 400263d4 <_Thread_Dispatch_enable+0x34> // b.any
|| !_ISR_Is_enabled( level )
400263cc: 92407c22 and x2, x1, #0xffffffff
400263d0: 34000041 cbz w1, 400263d8 <_Thread_Dispatch_enable+0x38> <== ALWAYS TAKEN
_Thread_Do_dispatch( cpu_self, level );
400263d4: 17ffff93 b 40026220 <_Thread_Do_dispatch>
cpu_self->thread_dispatch_disable_level = 0;
400263d8: b900181f str wzr, [x0, #24]
__asm__ volatile (
400263dc: d51b4222 msr daif, x2
}
400263e0: d65f03c0 ret
...
0000000040026220 <_Thread_Do_dispatch>:
_Thread_State_release( executing, &lock_context );
}
void _Thread_Do_dispatch( Per_CPU_Control *cpu_self, ISR_Level level )
{
40026220: a9bb7bfd stp x29, x30, [sp, #-80]!
40026224: 910003fd mov x29, sp
40026228: a90153f3 stp x19, x20, [sp, #16]
4002622c: a9025bf5 stp x21, x22, [sp, #32]
40026230: a90363f7 stp x23, x24, [sp, #48]
Thread_Control *executing;
_Assert( cpu_self->thread_dispatch_disable_level == 1 );
#if defined(RTEMS_SCORE_ROBUST_THREAD_DISPATCH)
if (
40026234: 350009a1 cbnz w1, 40026368 <_Thread_Do_dispatch+0x148> <== NEVER TAKEN
return _Chain_Immutable_head( the_chain )->next;
40026238: d00006d7 adrp x23, 40100000 <_RTEMS_tasks_Information>
4002623c: 910f02f7 add x23, x23, #0x3c0
) {
_Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT );
}
#endif
executing = cpu_self->executing;
40026240: f9401015 ldr x21, [x0, #32]
/*
* 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();
40026244: d00000b8 adrp x24, 4003c000 <_Scheduler_Table+0x48>
40026248: 913a4318 add x24, x24, #0xe90
if ( node != tail ) {
4002624c: 910022f6 add x22, x23, #0x8
heir = cpu_self->heir;
40026250: f9401414 ldr x20, [x0, #40]
cpu_self->dispatch_necessary = false;
40026254: 3900701f strb wzr, [x0, #28]
cpu_self->executing = heir;
40026258: f9001014 str x20, [x0, #32]
if ( heir == executing )
4002625c: eb1402bf cmp x21, x20
40026260: 540003c0 b.eq 400262d8 <_Thread_Do_dispatch+0xb8> // b.none
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
40026264: b940f280 ldr w0, [x20, #240]
40026268: 7100041f cmp w0, #0x1
4002626c: 54000061 b.ne 40026278 <_Thread_Do_dispatch+0x58> // b.any
heir->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice();
40026270: b9400300 ldr w0, [x24]
40026274: b900ee80 str w0, [x20, #236]
_ISR_Local_enable( level );
40026278: 2a0103e1 mov w1, w1
4002627c: d51b4221 msr daif, x1
40026280: f94002f3 ldr x19, [x23]
40026284: eb16027f cmp x19, x22
40026288: 54000120 b.eq 400262ac <_Thread_Do_dispatch+0x8c> // b.none
4002628c: d503201f nop
(*extension->thread_switch)( executing, heir );
40026290: f9400a62 ldr x2, [x19, #16]
40026294: aa1403e1 mov x1, x20
return the_node->next;
40026298: f9400273 ldr x19, [x19]
4002629c: aa1503e0 mov x0, x21
400262a0: d63f0040 blr x2
while ( node != tail ) {
400262a4: eb16027f cmp x19, x22
400262a8: 54ffff41 b.ne 40026290 <_Thread_Do_dispatch+0x70> // b.any
#if !defined(RTEMS_SMP)
_User_extensions_Thread_switch( executing, heir );
#endif
_Thread_Save_fp( executing );
_Context_Switch( &executing->Registers, &heir->Registers );
400262ac: 9105e281 add x1, x20, #0x178
400262b0: 9105e2a0 add x0, x21, #0x178
400262b4: 94000753 bl 40028000 <_CPU_Context_switch>
__asm__ volatile (
400262b8: d53b4221 mrs x1, daif
400262bc: d50342df msr daifset, #0x2
* stack or non-volatile registers reflect the old execution environment.
*/
cpu_self = _Per_CPU_Get();
_ISR_Local_disable( level );
} while ( cpu_self->dispatch_necessary );
400262c0: f00006e2 adrp x2, 40105000 <Arr_2_Glob+0x1e68>
400262c4: 91290042 add x2, x2, #0xa40
cpu_self = _Per_CPU_Get();
400262c8: aa0203e0 mov x0, x2
} while ( cpu_self->dispatch_necessary );
400262cc: 39407042 ldrb w2, [x2, #28]
400262d0: 72001c5f tst w2, #0xff
400262d4: 54fffbe1 b.ne 40026250 <_Thread_Do_dispatch+0x30> // b.any
post_switch:
_Assert( cpu_self->thread_dispatch_disable_level == 1 );
cpu_self->thread_dispatch_disable_level = 0;
400262d8: b900181f str wzr, [x0, #24]
_Profiling_Thread_dispatch_enable( cpu_self, 0 );
_ISR_Local_enable( level );
400262dc: 2a0103e1 mov w1, w1
__asm__ volatile (
400262e0: d51b4221 msr daif, x1
__asm__ volatile (
400262e4: d53b4220 mrs x0, daif
400262e8: d50342df msr daifset, #0x2
_ISR_lock_ISR_disable( lock_context );
400262ec: b9004be0 str w0, [sp, #72]
return _Chain_Immutable_head( the_chain )->next;
400262f0: f940b2a1 ldr x1, [x21, #352]
return &the_chain->Tail.Node;
400262f4: 9105a2b4 add x20, x21, #0x168
return _Chain_Immutable_head( the_chain )->next;
400262f8: 910582b3 add x19, x21, #0x160
if ( !_Chain_Is_empty(the_chain))
400262fc: eb14003f cmp x1, x20
40026300: 54000260 b.eq 4002634c <_Thread_Do_dispatch+0x12c> // b.none
new_first = old_first->next;
40026304: f9400020 ldr x0, [x1]
head->next = new_first;
40026308: f900b2a0 str x0, [x21, #352]
new_first->previous = head;
4002630c: f9000413 str x19, [x0, #8]
while ( action != NULL ) {
40026310: 14000004 b 40026320 <_Thread_Do_dispatch+0x100>
new_first = old_first->next;
40026314: f9400020 ldr x0, [x1] <== NOT EXECUTED
head->next = new_first;
40026318: f9000260 str x0, [x19] <== NOT EXECUTED
new_first->previous = head;
4002631c: f9000413 str x19, [x0, #8] <== NOT EXECUTED
( *action->handler )( executing, action, &lock_context );
40026320: f9400823 ldr x3, [x1, #16]
node->next = NULL;
40026324: f900003f str xzr, [x1]
40026328: 910123e2 add x2, sp, #0x48
4002632c: aa1503e0 mov x0, x21
40026330: d63f0060 blr x3
40026334: d53b4220 mrs x0, daif
40026338: d50342df msr daifset, #0x2
4002633c: b9004be0 str w0, [sp, #72]
return _Chain_Immutable_head( the_chain )->next;
40026340: f9400261 ldr x1, [x19]
if ( !_Chain_Is_empty(the_chain))
40026344: eb01029f cmp x20, x1
40026348: 54fffe61 b.ne 40026314 <_Thread_Do_dispatch+0xf4> // b.any <== NEVER TAKEN
_ISR_lock_ISR_enable( lock_context );
4002634c: b9404be0 ldr w0, [sp, #72]
__asm__ volatile (
40026350: d51b4220 msr daif, x0
_Thread_Run_post_switch_actions( executing );
}
40026354: a94153f3 ldp x19, x20, [sp, #16]
40026358: a9425bf5 ldp x21, x22, [sp, #32]
4002635c: a94363f7 ldp x23, x24, [sp, #48]
40026360: a8c57bfd ldp x29, x30, [sp], #80
40026364: d65f03c0 ret
_Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT );
40026368: 528003e0 mov w0, #0x1f // #31 <== NOT EXECUTED
4002636c: 97fffbcd bl 400252a0 <_Internal_error> <== NOT EXECUTED
000000004002b910 <_Thread_Exit>:
__asm__ volatile (
4002b910: d53b4223 mrs x3, daif
4002b914: d50342df msr daifset, #0x2
state |= set;
4002b918: b9426804 ldr w4, [x0, #616]
the_thread->Life.exit_value = exit_value;
4002b91c: f9013802 str x2, [x0, #624]
state |= set;
4002b920: 2a040021 orr w1, w1, w4
the_thread->Life.state = state;
4002b924: b9026801 str w1, [x0, #616]
&& _Thread_Is_life_changing( state )
4002b928: 721f043f tst w1, #0x6
4002b92c: 54000220 b.eq 4002b970 <_Thread_Exit+0x60> // b.none <== NEVER TAKEN
the_thread->is_preemptible = the_thread->Start.is_preemptible;
4002b930: 39448005 ldrb w5, [x0, #288]
cpu_self->dispatch_necessary = true;
4002b934: b00006c1 adrp x1, 40104000 <rtems_libio_iops+0x260>
4002b938: 91080021 add x1, x1, #0x200
4002b93c: 3903a405 strb w5, [x0, #233]
the_thread->budget_callout = the_thread->Start.budget_callout;
4002b940: f9409405 ldr x5, [x0, #296]
4002b944: f9007c05 str x5, [x0, #248]
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
4002b948: b9412406 ldr w6, [x0, #292]
action->handler = handler;
4002b94c: 90000002 adrp x2, 4002b000 <_Thread_queue_FIFO_enqueue+0x30>
4002b950: 91120042 add x2, x2, #0x480
4002b954: b900f006 str w6, [x0, #240]
if ( _Chain_Is_node_off_chain( the_node ) ) {
4002b958: f9412805 ldr x5, [x0, #592]
4002b95c: f9013002 str x2, [x0, #608]
4002b960: 52800026 mov w6, #0x1 // #1
4002b964: 39007026 strb w6, [x1, #28]
4002b968: 91094004 add x4, x0, #0x250
4002b96c: b4000085 cbz x5, 4002b97c <_Thread_Exit+0x6c> <== ALWAYS TAKEN
__asm__ volatile (
4002b970: 92407c60 and x0, x3, #0xffffffff
4002b974: d51b4220 msr daif, x0
0,
set,
THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED
);
_Thread_State_release( executing, &lock_context );
}
4002b978: d65f03c0 ret
old_last = tail->previous;
4002b97c: f940b802 ldr x2, [x0, #368]
4002b980: 9105a001 add x1, x0, #0x168
tail->previous = the_node;
4002b984: f900b804 str x4, [x0, #368]
the_node->next = tail;
4002b988: f9012801 str x1, [x0, #592]
old_last->next = the_node;
4002b98c: f9000044 str x4, [x2]
the_node->previous = old_last;
4002b990: f9012c02 str x2, [x0, #600]
}
4002b994: 17fffff7 b 4002b970 <_Thread_Exit+0x60>
...
000000004002d580 <_Thread_Get_name>:
size_t _Thread_Get_name(
const Thread_Control *the_thread,
char *buffer,
size_t buffer_size
)
{
4002d580: aa0103e4 mov x4, x1
4002d584: aa0203e3 mov x3, x2
const char *name;
name = the_thread->Join_queue.Queue.name;
4002d588: f9401801 ldr x1, [x0, #48]
if ( name != NULL && name[ 0 ] != '\0' ) {
4002d58c: b4000061 cbz x1, 4002d598 <_Thread_Get_name+0x18> <== NEVER TAKEN
4002d590: 39400025 ldrb w5, [x1]
4002d594: 350000a5 cbnz w5, 4002d5a8 <_Thread_Get_name+0x28>
return strlcpy( buffer, name, buffer_size );
} else {
return _Objects_Name_to_string(
4002d598: f9400c00 ldr x0, [x0, #24]
4002d59c: aa0403e2 mov x2, x4
4002d5a0: 52800001 mov w1, #0x0 // #0
4002d5a4: 14000473 b 4002e770 <_Objects_Name_to_string>
return strlcpy( buffer, name, buffer_size );
4002d5a8: aa0403e0 mov x0, x4
4002d5ac: 140007ce b 4002f4e4 <strlcpy>
...
000000004002a1b0 <_Thread_Initialize>:
bool _Thread_Initialize(
Thread_Information *information,
Thread_Control *the_thread,
const Thread_Configuration *config
)
{
4002a1b0: a9bb7bfd stp x29, x30, [sp, #-80]!
4002a1b4: 910003fd mov x29, sp
4002a1b8: a9025bf5 stp x21, x22, [sp, #32]
4002a1bc: aa0003f5 mov x21, x0
const Scheduler_Control *scheduler_for_index;
#endif
size_t scheduler_index;
Per_CPU_Control *cpu = _Per_CPU_Get_by_index( 0 );
memset(
4002a1c0: 91008020 add x0, x1, #0x20
{
4002a1c4: a90153f3 stp x19, x20, [sp, #16]
4002a1c8: aa0203f4 mov x20, x2
&the_thread->Join_queue,
0,
information->Objects.object_size - offsetof( Thread_Control, Join_queue )
4002a1cc: 79404aa2 ldrh w2, [x21, #36]
{
4002a1d0: aa0103f3 mov x19, x1
memset(
4002a1d4: 52800001 mov w1, #0x0 // #0
4002a1d8: d1008042 sub x2, x2, #0x20
4002a1dc: 94001346 bl 4002eef4 <memset>
);
for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) {
4002a1e0: d0000080 adrp x0, 4003c000 <_Scheduler_Table+0x48>
4002a1e4: f9402402 ldr x2, [x0, #72]
4002a1e8: d0000083 adrp x3, 4003c000 <_Scheduler_Table+0x48>
4002a1ec: 91014063 add x3, x3, #0x50
4002a1f0: d2800004 mov x4, #0x0 // #0
4002a1f4: b4000102 cbz x2, 4002a214 <_Thread_Initialize+0x64> <== NEVER TAKEN
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;
4002a1f8: a9400465 ldp x5, x1, [x3]
for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) {
4002a1fc: 91000484 add x4, x4, #0x1
4002a200: eb02009f cmp x4, x2
4002a204: 91004063 add x3, x3, #0x10
(char *) the_thread + add_on->source_offset;
4002a208: 8b010261 add x1, x19, x1
*(void **) ( (char *) the_thread + add_on->destination_offset ) =
4002a20c: f8256a61 str x1, [x19, x5]
for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) {
4002a210: 54ffff41 b.ne 4002a1f8 <_Thread_Initialize+0x48> // b.any
goto failed;
}
#endif
#if defined(RTEMS_SMP) || CPU_ENABLE_ROBUST_THREAD_DISPATCH == TRUE
if (
4002a214: b9404280 ldr w0, [x20, #64]
the_thread->Start.stack_free = config->stack_free;
4002a218: f9400e81 ldr x1, [x20, #24]
4002a21c: f900a261 str x1, [x19, #320]
if (
4002a220: 34000100 cbz w0, 4002a240 <_Thread_Initialize+0x90> <== ALWAYS TAKEN
#if defined(RTEMS_SMP) || CPU_ENABLE_ROBUST_THREAD_DISPATCH == TRUE
failed:
#endif
( *the_thread->Start.stack_free )( the_thread->Start.Initial_stack.area );
4002a224: f940aa60 ldr x0, [x19, #336]
4002a228: d63f0020 blr x1
return false;
4002a22c: 52800000 mov w0, #0x0 // #0
}
4002a230: a94153f3 ldp x19, x20, [sp, #16]
4002a234: a9425bf5 ldp x21, x22, [sp, #32]
4002a238: a8c57bfd ldp x29, x30, [sp], #80
4002a23c: d65f03c0 ret
stack_end = stack_begin + config->stack_size;
4002a240: f9400a96 ldr x22, [x20, #16]
4002a244: f9001bf7 str x23, [sp, #48]
stack_begin = config->stack_area;
4002a248: f9400697 ldr x23, [x20, #8]
stack_end = stack_begin + config->stack_size;
4002a24c: 8b1602f6 add x22, x23, x22
tls_size = _TLS_Get_allocation_size();
4002a250: 940000f8 bl 4002a630 <_TLS_Get_allocation_size>
if ( tls_size > 0 ) {
4002a254: b4000120 cbz x0, 4002a278 <_Thread_Initialize+0xc8>
tls_align = (uintptr_t) _TLS_Alignment;
4002a258: d0dffea1 adrp x1, 0 <HeapSize>
4002a25c: 91000421 add x1, x1, #0x1
stack_end -= tls_size;
4002a260: cb0002d6 sub x22, x22, x0
( ( (uintptr_t) stack_end + tls_align - 1 ) & ~( tls_align - 1 ) );
4002a264: d1000420 sub x0, x1, #0x1
4002a268: 8b0002c0 add x0, x22, x0
4002a26c: cb0103e1 neg x1, x1
4002a270: 8a010001 and x1, x0, x1
the_thread->Start.tls_area = (void *)
4002a274: f900ae61 str x1, [x19, #344]
old_first = head->next;
4002a278: f9402ea0 ldr x0, [x21, #88]
stack_end - stack_begin
4002a27c: cb1702d6 sub x22, x22, x23
the_thread->Start.budget_algorithm = config->budget_algorithm;
4002a280: b9402a82 ldr w2, [x20, #40]
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
4002a284: 52800046 mov w6, #0x2 // #2
the_thread->Start.budget_callout = config->budget_callout;
4002a288: f9401a85 ldr x5, [x20, #48]
head->next = tail;
4002a28c: 91012004 add x4, x0, #0x48
new_first = old_first->next;
4002a290: f9400001 ldr x1, [x0]
the_stack->area = starting_address;
4002a294: a914de76 stp x22, x23, [x19, #328]
return &the_chain->Head.Node;
4002a298: 910162b6 add x22, x21, #0x58
head->next = new_first;
4002a29c: f9002ea1 str x1, [x21, #88]
return &the_chain->Tail.Node;
4002a2a0: 91014003 add x3, x0, #0x50
new_first->previous = head;
4002a2a4: f9000436 str x22, [x1, #8]
timer->header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ];
4002a2a8: f00006c1 adrp x1, 40105000 <Arr_2_Glob+0x1e68>
4002a2ac: 912a0021 add x1, x1, #0xa80
the_thread->Wait.spare_heads = _Freechain_Pop(
4002a2b0: f9005660 str x0, [x19, #168]
head->previous = NULL;
4002a2b4: a904fc03 stp x3, xzr, [x0, #72]
switch ( config->budget_algorithm ) {
4002a2b8: 6b06005f cmp w2, w6
the_thread->Start.is_preemptible = config->is_preemptible;
4002a2bc: 39411683 ldrb w3, [x20, #69]
tail->previous = head;
4002a2c0: f9002c04 str x4, [x0, #88]
the_thread->is_fp = config->is_fp;
4002a2c4: 39411284 ldrb w4, [x20, #68]
the_thread->Start.isr_level = config->isr_level;
4002a2c8: b9404280 ldr w0, [x20, #64]
4002a2cc: f9005a61 str x1, [x19, #176]
4002a2d0: b900d266 str w6, [x19, #208]
the_thread->is_fp = config->is_fp;
4002a2d4: 3903aa64 strb w4, [x19, #234]
the_thread->Start.is_preemptible = config->is_preemptible;
4002a2d8: 39048263 strb w3, [x19, #288]
the_thread->Start.budget_algorithm = config->budget_algorithm;
4002a2dc: b9012662 str w2, [x19, #292]
the_thread->Start.budget_callout = config->budget_callout;
4002a2e0: f9009665 str x5, [x19, #296]
the_thread->Start.isr_level = config->isr_level;
4002a2e4: b9013260 str w0, [x19, #304]
switch ( config->budget_algorithm ) {
4002a2e8: 54000081 b.ne 4002a2f8 <_Thread_Initialize+0x148> // b.any
the_thread->cpu_time_budget =
4002a2ec: d0000080 adrp x0, 4003c000 <_Scheduler_Table+0x48>
4002a2f0: b94e9000 ldr w0, [x0, #3728]
4002a2f4: b900ee60 str w0, [x19, #236]
config->scheduler,
4002a2f8: f9400280 ldr x0, [x20]
( *scheduler->Operations.node_initialize )(
4002a2fc: aa1303e2 mov x2, x19
4002a300: f9401283 ldr x3, [x20, #32]
4002a304: f9402404 ldr x4, [x0, #72]
return the_thread->Scheduler.nodes;
4002a308: f9403677 ldr x23, [x19, #104]
4002a30c: aa1703e1 mov x1, x23
4002a310: d63f0080 blr x4
_Priority_Node_initialize( &the_thread->Real_priority, config->priority );
4002a314: f9401286 ldr x6, [x20, #32]
node->priority = priority;
4002a318: f9003266 str x6, [x19, #96]
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
4002a31c: 79402265 ldrh w5, [x19, #16]
4002a320: 91010260 add x0, x19, #0x40
RB_ROOT( the_rbtree ) = the_node;
4002a324: a90282e6 stp x6, x0, [x23, #40]
return &the_chain->Tail.Node;
4002a328: 9105a263 add x3, x19, #0x168
4002a32c: 510004a5 sub w5, w5, #0x1
the_thread->Start.initial_priority = config->priority;
4002a330: f9009e66 str x6, [x19, #312]
head->next = tail;
4002a334: 91058264 add x4, x19, #0x160
4002a338: f94006a6 ldr x6, [x21, #8]
4002a33c: f900b263 str x3, [x19, #352]
4002a340: f9401e83 ldr x3, [x20, #56]
the_thread->current_state = STATES_DORMANT;
4002a344: 52b00009 mov w9, #0x80000000 // #-2147483648
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4002a348: d0000087 adrp x7, 4003c000 <_Scheduler_Table+0x48>
4002a34c: 913860e7 add x7, x7, #0xe18
the_object->name = name;
4002a350: f9000e63 str x3, [x19, #24]
User_extensions_Thread_create_context ctx = { created, true };
4002a354: 52800028 mov w8, #0x1 // #1
the_thread->current_state = STATES_DORMANT;
4002a358: b9003a69 str w9, [x19, #56]
_User_extensions_Iterate(
4002a35c: 910103e0 add x0, sp, #0x40
RB_RIGHT( the_node, Node ) = NULL;
4002a360: a9047e7f stp xzr, xzr, [x19, #64]
4002a364: b0ffffe1 adrp x1, 40027000 <_Thread_queue_Priority_enqueue+0xa0>
4002a368: 52800002 mov w2, #0x0 // #0
RB_PARENT( the_node, Node ) = NULL;
4002a36c: f9002a7f str xzr, [x19, #80]
4002a370: 9125c021 add x1, x1, #0x970
RB_COLOR( the_node, Node ) = RB_BLACK;
4002a374: b9005a7f str wzr, [x19, #88]
the_thread->Wait.operations = &_Thread_queue_Operations_default;
4002a378: f9005267 str x7, [x19, #160]
tail->previous = head;
4002a37c: a916927f stp xzr, x4, [x19, #360]
RB_INIT( the_rbtree );
4002a380: f901267f str xzr, [x19, #584]
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
4002a384: f82578d3 str x19, [x6, x5, lsl #3]
User_extensions_Thread_create_context ctx = { created, true };
4002a388: f90023f3 str x19, [sp, #64]
4002a38c: 390123e8 strb w8, [sp, #72]
_User_extensions_Iterate(
4002a390: 97fff5c4 bl 40027aa0 <_User_extensions_Iterate>
return ctx.ok;
4002a394: 394123e0 ldrb w0, [sp, #72]
if ( extension_status )
4002a398: 350001c0 cbnz w0, 4002a3d0 <_Thread_Initialize+0x220>
_Scheduler_Node_destroy( config->scheduler, scheduler_node );
4002a39c: f9400280 ldr x0, [x20]
( *scheduler->Operations.node_destroy )( scheduler, node );
4002a3a0: aa1703e1 mov x1, x23
4002a3a4: f9402802 ldr x2, [x0, #80]
4002a3a8: d63f0040 blr x2
the_thread->Wait.spare_heads
4002a3ac: f9405660 ldr x0, [x19, #168]
before_node = after_node->next;
4002a3b0: f9402ea2 ldr x2, [x21, #88]
before_node->previous = the_node;
4002a3b4: f9401bf7 ldr x23, [sp, #48]
( *the_thread->Start.stack_free )( the_thread->Start.Initial_stack.area );
4002a3b8: f940a261 ldr x1, [x19, #320]
the_node->previous = after_node;
4002a3bc: f9000416 str x22, [x0, #8]
after_node->next = the_node;
4002a3c0: f9002ea0 str x0, [x21, #88]
the_node->next = before_node;
4002a3c4: f9000002 str x2, [x0]
before_node->previous = the_node;
4002a3c8: f9000440 str x0, [x2, #8]
void *node
)
{
_Chain_Initialize_node( node );
_Chain_Prepend_unprotected( &freechain->Free, node );
}
4002a3cc: 17ffff96 b 4002a224 <_Thread_Initialize+0x74>
}
4002a3d0: a94153f3 ldp x19, x20, [sp, #16]
4002a3d4: a9425bf5 ldp x21, x22, [sp, #32]
4002a3d8: f9401bf7 ldr x23, [sp, #48]
4002a3dc: a8c57bfd ldp x29, x30, [sp], #80
4002a3e0: d65f03c0 ret
...
000000004002a4a0 <_Thread_Iterate>:
void _Thread_Iterate(
Thread_Visitor visitor,
void *arg
)
{
4002a4a0: a9bb7bfd stp x29, x30, [sp, #-80]!
4002a4a4: 910003fd mov x29, sp
4002a4a8: a9025bf5 stp x21, x22, [sp, #32]
4002a4ac: aa0003f6 mov x22, x0
4002a4b0: a90363f7 stp x23, x24, [sp, #48]
4002a4b4: f00000b8 adrp x24, 40041000 <status_code_text+0x98>
4002a4b8: 9109c318 add x24, x24, #0x270
4002a4bc: f90023f9 str x25, [sp, #64]
4002a4c0: aa0103f9 mov x25, x1
4002a4c4: d2800037 mov x23, #0x1 // #1
4002a4c8: a90153f3 stp x19, x20, [sp, #16]
const Objects_Information *information;
Objects_Maximum maximum;
Objects_Maximum index;
_Assert( _Objects_Information_table[ api_index ] != NULL );
information = _Objects_Information_table[ api_index ][ 1 ];
4002a4cc: f8777b00 ldr x0, [x24, x23, lsl #3]
4002a4d0: f9400414 ldr x20, [x0, #8]
if ( information == NULL ) {
4002a4d4: b40001f4 cbz x20, 4002a510 <_Thread_Iterate+0x70>
(Objects_Maximum)((id >> OBJECTS_INDEX_START_BIT) &
4002a4d8: 79400295 ldrh w21, [x20]
continue;
}
maximum = _Objects_Get_maximum_index( information );
for ( index = 0 ; index < maximum ; ++index ) {
4002a4dc: 340001b5 cbz w21, 4002a510 <_Thread_Iterate+0x70> <== NEVER TAKEN
4002a4e0: d37d3eb5 ubfiz x21, x21, #3, #16
4002a4e4: d2800013 mov x19, #0x0 // #0
Thread_Control *the_thread;
the_thread = (Thread_Control *) information->local_table[ index ];
4002a4e8: f9400682 ldr x2, [x20, #8]
if ( the_thread != NULL ) {
bool done;
done = (* visitor )( the_thread, arg );
4002a4ec: aa1903e1 mov x1, x25
the_thread = (Thread_Control *) information->local_table[ index ];
4002a4f0: f8736840 ldr x0, [x2, x19]
for ( index = 0 ; index < maximum ; ++index ) {
4002a4f4: 91002273 add x19, x19, #0x8
if ( the_thread != NULL ) {
4002a4f8: b4000080 cbz x0, 4002a508 <_Thread_Iterate+0x68>
done = (* visitor )( the_thread, arg );
4002a4fc: d63f02c0 blr x22
if ( done ) {
4002a500: 72001c1f tst w0, #0xff
4002a504: 540000c1 b.ne 4002a51c <_Thread_Iterate+0x7c> // b.any <== NEVER TAKEN
for ( index = 0 ; index < maximum ; ++index ) {
4002a508: eb1302bf cmp x21, x19
4002a50c: 54fffee1 b.ne 4002a4e8 <_Thread_Iterate+0x48> // b.any
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; ++api_index ) {
4002a510: 910006f7 add x23, x23, #0x1
4002a514: f10012ff cmp x23, #0x4
4002a518: 54fffda1 b.ne 4002a4cc <_Thread_Iterate+0x2c> // b.any
return;
}
}
}
}
}
4002a51c: a94153f3 ldp x19, x20, [sp, #16]
4002a520: a9425bf5 ldp x21, x22, [sp, #32]
4002a524: a94363f7 ldp x23, x24, [sp, #48]
4002a528: f94023f9 ldr x25, [sp, #64]
4002a52c: a8c57bfd ldp x29, x30, [sp], #80
4002a530: d65f03c0 ret
...
0000000040027450 <_Thread_Kill_zombies>:
{
40027450: a9bc7bfd stp x29, x30, [sp, #-64]!
40027454: 910003fd mov x29, sp
40027458: a90153f3 stp x19, x20, [sp, #16]
4002745c: a9025bf5 stp x21, x22, [sp, #32]
40027460: a90363f7 stp x23, x24, [sp, #48]
__asm__ volatile (
40027464: d53b4220 mrs x0, daif
40027468: d50342df msr daifset, #0x2
return _Chain_Immutable_head( the_chain )->next;
4002746c: b00006c1 adrp x1, 40100000 <_RTEMS_tasks_Information>
40027470: 910f6035 add x21, x1, #0x3d8
if ( !_Chain_Is_empty(the_chain))
40027474: 910022b8 add x24, x21, #0x8
return _Chain_Immutable_head( the_chain )->next;
40027478: f941ec33 ldr x19, [x1, #984]
if ( !_Chain_Is_empty(the_chain))
4002747c: eb18027f cmp x19, x24
40027480: 54000700 b.eq 40027560 <_Thread_Kill_zombies+0x110> // b.none
new_first = old_first->next;
40027484: f9400262 ldr x2, [x19]
head->next = new_first;
40027488: 90000017 adrp x23, 40027000 <_Thread_queue_Priority_enqueue+0xa0>
4002748c: 9126c2f7 add x23, x23, #0x9b0
40027490: 900000b6 adrp x22, 4003b000 <__sfvwrite_r+0x5d4>
40027494: 913ee2d6 add x22, x22, #0xfb8
40027498: f901ec22 str x2, [x1, #984]
new_first->previous = head;
4002749c: f9000455 str x21, [x2, #8]
_ISR_lock_Release_and_ISR_enable( &zombies->Lock, &lock_context );
400274a0: 2a0003e0 mov w0, w0
__asm__ volatile (
400274a4: d51b4220 msr daif, x0
_Objects_Get_information_id( the_thread->Object.id );
400274a8: b9401260 ldr w0, [x19, #16]
400274ac: 94000831 bl 40029570 <_Objects_Get_information_id>
400274b0: aa0003f4 mov x20, x0
_User_extensions_Iterate(
400274b4: aa1703e1 mov x1, x23
400274b8: aa1303e0 mov x0, x19
400274bc: 52800022 mov w2, #0x1 // #1
400274c0: 94000178 bl 40027aa0 <_User_extensions_Iterate>
__asm__ volatile (
400274c4: d53b4220 mrs x0, daif
400274c8: d50342df msr daifset, #0x2
iter = the_thread->last_user_extensions_iterator;
400274cc: f9414e61 ldr x1, [x19, #664]
while ( iter != NULL ) {
400274d0: b40000e1 cbz x1, 400274ec <_Thread_Kill_zombies+0x9c>
400274d4: d503201f nop
previous = the_node->previous;
400274d8: a9400823 ldp x3, x2, [x1]
iter = iter->previous;
400274dc: f9401021 ldr x1, [x1, #32]
next->previous = previous;
400274e0: f9000462 str x2, [x3, #8]
previous->next = next;
400274e4: f9000043 str x3, [x2]
while ( iter != NULL ) {
400274e8: b5ffff81 cbnz x1, 400274d8 <_Thread_Kill_zombies+0x88> <== NEVER TAKEN
__asm__ volatile (
400274ec: 92407c00 and x0, x0, #0xffffffff
400274f0: d51b4220 msr daif, x0
( *scheduler->Operations.node_destroy )( scheduler, node );
400274f4: f9402ac2 ldr x2, [x22, #80]
400274f8: aa1603e0 mov x0, x22
400274fc: f9403661 ldr x1, [x19, #104]
40027500: d63f0040 blr x2
the_thread->Wait.spare_heads
40027504: f9405661 ldr x1, [x19, #168]
return &the_chain->Head.Node;
40027508: 91016280 add x0, x20, #0x58
before_node = after_node->next;
4002750c: f9402e82 ldr x2, [x20, #88]
( *the_thread->Start.stack_free )( the_thread->Start.Initial_stack.area );
40027510: f940a263 ldr x3, [x19, #320]
the_node->previous = after_node;
40027514: f9000420 str x0, [x1, #8]
40027518: f940aa60 ldr x0, [x19, #336]
after_node->next = the_node;
4002751c: f9002e81 str x1, [x20, #88]
the_node->next = before_node;
40027520: f9000022 str x2, [x1]
before_node->previous = the_node;
40027524: f9000441 str x1, [x2, #8]
40027528: d63f0060 blr x3
Objects_Control *the_object
)
{
_Assert( _Objects_Allocator_is_owner() );
_Assert( information->deallocate != NULL );
( *information->deallocate )( information, the_object );
4002752c: f9400e82 ldr x2, [x20, #24]
40027530: aa1303e1 mov x1, x19
40027534: aa1403e0 mov x0, x20
40027538: d63f0040 blr x2
__asm__ volatile (
4002753c: d53b4220 mrs x0, daif
40027540: d50342df msr daifset, #0x2
return _Chain_Immutable_head( the_chain )->next;
40027544: f94002b3 ldr x19, [x21]
if ( !_Chain_Is_empty(the_chain))
40027548: eb18027f cmp x19, x24
4002754c: 540000a0 b.eq 40027560 <_Thread_Kill_zombies+0x110> // b.none
new_first = old_first->next;
40027550: f9400261 ldr x1, [x19]
head->next = new_first;
40027554: f90002a1 str x1, [x21]
new_first->previous = head;
40027558: f9000435 str x21, [x1, #8]
4002755c: 17ffffd1 b 400274a0 <_Thread_Kill_zombies+0x50>
_ISR_lock_Release_and_ISR_enable( &zombies->Lock, &lock_context );
40027560: 2a0003e0 mov w0, w0
__asm__ volatile (
40027564: d51b4220 msr daif, x0
}
40027568: a94153f3 ldp x19, x20, [sp, #16]
4002756c: a9425bf5 ldp x21, x22, [sp, #32]
40027570: a94363f7 ldp x23, x24, [sp, #48]
40027574: a8c47bfd ldp x29, x30, [sp], #64
40027578: d65f03c0 ret
4002757c: 00000000 udf #0
000000004002c870 <_Thread_Priority_add>:
void _Thread_Priority_add(
Thread_Control *the_thread,
Priority_Node *priority_node,
Thread_queue_Context *queue_context
)
{
4002c870: a9bd7bfd stp x29, x30, [sp, #-48]!
_Thread_Priority_do_perform_actions(
4002c874: aa0203e4 mov x4, x2
4002c878: 52800003 mov w3, #0x0 // #0
{
4002c87c: 910003fd mov x29, sp
return the_thread->Scheduler.nodes;
4002c880: f9403405 ldr x5, [x0, #104]
4002c884: a90153f3 stp x19, x20, [sp, #16]
4002c888: aa0203f3 mov x19, x2
_Thread_Priority_do_perform_actions(
4002c88c: a9498814 ldp x20, x2, [x0, #152]
aggregation->Action.node = node;
4002c890: 910020a5 add x5, x5, #0x8
4002c894: f90018a1 str x1, [x5, #48]
aggregation->Action.type = type;
4002c898: b90038bf str wzr, [x5, #56]
actions->actions = aggregation;
4002c89c: f9000e65 str x5, [x19, #24]
4002c8a0: aa1403e1 mov x1, x20
4002c8a4: 97ffff5f bl 4002c620 <_Thread_Priority_do_perform_actions>
if ( !_Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) {
4002c8a8: f9400e60 ldr x0, [x19, #24]
4002c8ac: b40001e0 cbz x0, 4002c8e8 <_Thread_Priority_add+0x78> <== ALWAYS TAKEN
_Thread_Priority_perform_actions( queue->owner, queue_context );
4002c8b0: f9400680 ldr x0, [x20, #8] <== NOT EXECUTED
return queue_context->Priority.update_count;
4002c8b4: f90013f5 str x21, [sp, #32] <== NOT EXECUTED
4002c8b8: f9401275 ldr x21, [x19, #32] <== NOT EXECUTED
4002c8bc: 14000003 b 4002c8c8 <_Thread_Priority_add+0x58> <== NOT EXECUTED
the_thread = queue->owner;
4002c8c0: f9400680 ldr x0, [x20, #8] <== NOT EXECUTED
queue_context->Priority.update_count = update_count;
4002c8c4: f9001275 str x21, [x19, #32] <== NOT EXECUTED
_Thread_Priority_do_perform_actions(
4002c8c8: a9498814 ldp x20, x2, [x0, #152] <== NOT EXECUTED
4002c8cc: aa1303e4 mov x4, x19 <== NOT EXECUTED
4002c8d0: 52800003 mov w3, #0x0 // #0 <== NOT EXECUTED
4002c8d4: aa1403e1 mov x1, x20 <== NOT EXECUTED
4002c8d8: 97ffff52 bl 4002c620 <_Thread_Priority_do_perform_actions> <== NOT EXECUTED
if ( _Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) {
4002c8dc: f9400e60 ldr x0, [x19, #24] <== NOT EXECUTED
4002c8e0: b5ffff00 cbnz x0, 4002c8c0 <_Thread_Priority_add+0x50> <== NOT EXECUTED
4002c8e4: f94013f5 ldr x21, [sp, #32] <== NOT EXECUTED
priority_node,
queue_context,
false,
PRIORITY_ACTION_ADD
);
}
4002c8e8: a94153f3 ldp x19, x20, [sp, #16]
4002c8ec: a8c37bfd ldp x29, x30, [sp], #48
4002c8f0: d65f03c0 ret
...
000000004002c900 <_Thread_Priority_remove>:
void _Thread_Priority_remove(
Thread_Control *the_thread,
Priority_Node *priority_node,
Thread_queue_Context *queue_context
)
{
4002c900: a9bd7bfd stp x29, x30, [sp, #-48]!
_Thread_Priority_do_perform_actions(
4002c904: aa0203e4 mov x4, x2
aggregation->Action.type = type;
4002c908: 52800047 mov w7, #0x2 // #2
{
4002c90c: 910003fd mov x29, sp
4002c910: f9403405 ldr x5, [x0, #104]
4002c914: a90153f3 stp x19, x20, [sp, #16]
4002c918: aa0203f3 mov x19, x2
_Thread_Priority_do_perform_actions(
4002c91c: a9498814 ldp x20, x2, [x0, #152]
aggregation->Action.node = node;
4002c920: 910020a5 add x5, x5, #0x8
4002c924: f90018a1 str x1, [x5, #48]
4002c928: 52800023 mov w3, #0x1 // #1
aggregation->Action.type = type;
4002c92c: b90038a7 str w7, [x5, #56]
actions->actions = aggregation;
4002c930: f9000e65 str x5, [x19, #24]
4002c934: aa1403e1 mov x1, x20
4002c938: 97ffff3a bl 4002c620 <_Thread_Priority_do_perform_actions>
if ( !_Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) {
4002c93c: f9400e60 ldr x0, [x19, #24]
4002c940: b40001e0 cbz x0, 4002c97c <_Thread_Priority_remove+0x7c> <== ALWAYS TAKEN
_Thread_Priority_perform_actions( queue->owner, queue_context );
4002c944: f9400680 ldr x0, [x20, #8] <== NOT EXECUTED
return queue_context->Priority.update_count;
4002c948: f90013f5 str x21, [sp, #32] <== NOT EXECUTED
4002c94c: f9401275 ldr x21, [x19, #32] <== NOT EXECUTED
4002c950: 14000003 b 4002c95c <_Thread_Priority_remove+0x5c> <== NOT EXECUTED
the_thread = queue->owner;
4002c954: f9400680 ldr x0, [x20, #8] <== NOT EXECUTED
queue_context->Priority.update_count = update_count;
4002c958: f9001275 str x21, [x19, #32] <== NOT EXECUTED
_Thread_Priority_do_perform_actions(
4002c95c: a9498814 ldp x20, x2, [x0, #152] <== NOT EXECUTED
4002c960: aa1303e4 mov x4, x19 <== NOT EXECUTED
4002c964: 52800003 mov w3, #0x0 // #0 <== NOT EXECUTED
4002c968: aa1403e1 mov x1, x20 <== NOT EXECUTED
4002c96c: 97ffff2d bl 4002c620 <_Thread_Priority_do_perform_actions> <== NOT EXECUTED
if ( _Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) {
4002c970: f9400e60 ldr x0, [x19, #24] <== NOT EXECUTED
4002c974: b5ffff00 cbnz x0, 4002c954 <_Thread_Priority_remove+0x54> <== NOT EXECUTED
4002c978: f94013f5 ldr x21, [sp, #32] <== NOT EXECUTED
priority_node,
queue_context,
true,
PRIORITY_ACTION_REMOVE
);
}
4002c97c: a94153f3 ldp x19, x20, [sp, #16]
4002c980: a8c37bfd ldp x29, x30, [sp], #48
4002c984: d65f03c0 ret
...
0000000040025d60 <_Thread_Restart_other>:
bool _Thread_Restart_other(
Thread_Control *the_thread,
const Thread_Entry_information *entry,
ISR_lock_Context *lock_context
)
{
40025d60: a9bd7bfd stp x29, x30, [sp, #-48]!
40025d64: 910003fd mov x29, 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 ) ) {
40025d68: b9403803 ldr w3, [x0, #56]
{
40025d6c: a9025bf5 stp x21, x22, [sp, #32]
40025d70: aa0203f5 mov x21, x2
if ( _States_Is_dormant( the_thread->current_state ) ) {
40025d74: 37f809c3 tbnz w3, #31, 40025eac <_Thread_Restart_other+0x14c>
_Thread_State_release( the_thread, lock_context );
return false;
}
the_thread->Start.Entry = *entry;
40025d78: a90153f3 stp x19, x20, [sp, #16]
if (
40025d7c: 52800125 mov w5, #0x9 // #9
40025d80: aa0003f3 mov x19, x0
the_thread->Start.Entry = *entry;
40025d84: f9400023 ldr x3, [x1]
40025d88: f9008403 str x3, [x0, #264]
previous = the_thread->Life.state;
40025d8c: b9426803 ldr w3, [x0, #616]
the_thread->Start.Entry = *entry;
40025d90: f9400424 ldr x4, [x1, #8]
40025d94: f9008804 str x4, [x0, #272]
state |= set;
40025d98: 321f0064 orr w4, w3, #0x2
if (
40025d9c: 6a05007f tst w3, w5
the_thread->Start.Entry = *entry;
40025da0: f9400821 ldr x1, [x1, #16]
40025da4: f9008c01 str x1, [x0, #280]
the_thread->Life.state = state;
40025da8: b9026804 str w4, [x0, #616]
if (
40025dac: 54000220 b.eq 40025df0 <_Thread_Restart_other+0x90> // b.none <== ALWAYS TAKEN
disable_level = cpu_self->thread_dispatch_disable_level;
40025db0: d00006f4 adrp x20, 40103000 <_RTEMS_tasks_Objects+0x590> <== NOT EXECUTED
40025db4: 91230294 add x20, x20, #0x8c0 <== NOT EXECUTED
_Thread_Finalize_life_change(
the_thread,
the_thread->Start.initial_priority
);
} else {
_Thread_Clear_state_locked( the_thread, STATES_SUSPENDED );
40025db8: 52900001 mov w1, #0x8000 // #32768 <== NOT EXECUTED
40025dbc: b9401a82 ldr w2, [x20, #24] <== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40025dc0: 11000442 add w2, w2, #0x1 <== NOT EXECUTED
40025dc4: b9001a82 str w2, [x20, #24] <== NOT EXECUTED
40025dc8: 94000dba bl 400294b0 <_Thread_Clear_state_locked> <== NOT EXECUTED
_ISR_lock_ISR_enable( lock_context );
40025dcc: b94002a0 ldr w0, [x21] <== NOT EXECUTED
40025dd0: d51b4220 msr daif, x0 <== NOT EXECUTED
_Thread_State_release( the_thread, lock_context );
}
_Thread_Dispatch_enable( cpu_self );
40025dd4: aa1403e0 mov x0, x20
40025dd8: 97fffdd2 bl 40025520 <_Thread_Dispatch_enable>
return true;
40025ddc: 52800020 mov w0, #0x1 // #1
40025de0: a94153f3 ldp x19, x20, [sp, #16]
}
40025de4: a9425bf5 ldp x21, x22, [sp, #32]
40025de8: a8c37bfd ldp x29, x30, [sp], #48
40025dec: d65f03c0 ret
the_thread->is_preemptible = the_thread->Start.is_preemptible;
40025df0: 39448002 ldrb w2, [x0, #288]
cpu_self->dispatch_necessary = true;
40025df4: d00006f4 adrp x20, 40103000 <_RTEMS_tasks_Objects+0x590>
40025df8: 91230294 add x20, x20, #0x8c0
40025dfc: 3903a662 strb w2, [x19, #233]
the_thread->budget_callout = the_thread->Start.budget_callout;
40025e00: f9409662 ldr x2, [x19, #296]
40025e04: f9007e62 str x2, [x19, #248]
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
40025e08: b9412663 ldr w3, [x19, #292]
action->handler = handler;
40025e0c: 91094001 add x1, x0, #0x250
if ( _Chain_Is_node_off_chain( the_node ) ) {
40025e10: f9412a62 ldr x2, [x19, #592]
40025e14: 90000000 adrp x0, 40025000 <_Thread_Priority_do_perform_actions+0xd0>
40025e18: 91210000 add x0, x0, #0x840
40025e1c: b900f263 str w3, [x19, #240]
40025e20: f9013260 str x0, [x19, #608]
40025e24: 52800023 mov w3, #0x1 // #1
40025e28: 39007283 strb w3, [x20, #28]
40025e2c: b40005e2 cbz x2, 40025ee8 <_Thread_Restart_other+0x188> <== ALWAYS TAKEN
disable_level = cpu_self->thread_dispatch_disable_level;
40025e30: b9401a80 ldr w0, [x20, #24]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40025e34: 11000400 add w0, w0, #0x1
40025e38: b9001a80 str w0, [x20, #24]
pending_requests = the_thread->Life.pending_life_change_requests;
40025e3c: b9426e60 ldr w0, [x19, #620]
the_thread->Life.pending_life_change_requests = pending_requests + 1;
40025e40: 11000401 add w1, w0, #0x1
40025e44: b9026e61 str w1, [x19, #620]
if ( pending_requests == 0 ) {
40025e48: 340003e0 cbz w0, 40025ec4 <_Thread_Restart_other+0x164> <== ALWAYS TAKEN
_ISR_lock_ISR_enable( lock_context );
40025e4c: b94002a0 ldr w0, [x21]
40025e50: d51b4220 msr daif, x0
_Thread_queue_Extract_with_proxy( the_thread );
40025e54: aa1303e0 mov x0, x19
_Thread_Finalize_life_change(
40025e58: f9409e76 ldr x22, [x19, #312]
_Thread_queue_Extract_with_proxy( the_thread );
40025e5c: 94000fb1 bl 40029d20 <_Thread_queue_Extract_with_proxy>
__asm__ volatile (
40025e60: d53b4235 mrs x21, daif
40025e64: d50342df msr daifset, #0x2
40025e68: f9405a60 ldr x0, [x19, #176]
40025e6c: 9102e261 add x1, x19, #0xb8
40025e70: 94000268 bl 40026810 <_Watchdog_Remove>
__asm__ volatile (
40025e74: 92407eb5 and x21, x21, #0xffffffff
40025e78: d51b4235 msr daif, x21
_Thread_Raise_real_priority( the_thread, priority );
40025e7c: aa1603e1 mov x1, x22
40025e80: aa1303e0 mov x0, x19
40025e84: 97fffdff bl 40025680 <_Thread_Raise_real_priority>
__asm__ volatile (
40025e88: d53b4235 mrs x21, daif
40025e8c: d50342df msr daifset, #0x2
pending_requests = the_thread->Life.pending_life_change_requests;
40025e90: b9426e60 ldr w0, [x19, #620]
if ( pending_requests == 1 ) {
40025e94: 71000401 subs w1, w0, #0x1
the_thread->Life.pending_life_change_requests = pending_requests - 1;
40025e98: b9026e61 str w1, [x19, #620]
if ( pending_requests == 1 ) {
40025e9c: 540001c0 b.eq 40025ed4 <_Thread_Restart_other+0x174> // b.none <== ALWAYS TAKEN
__asm__ volatile (
40025ea0: 92407eb5 and x21, x21, #0xffffffff
40025ea4: d51b4235 msr daif, x21
}
40025ea8: 17ffffcb b 40025dd4 <_Thread_Restart_other+0x74>
40025eac: b9400040 ldr w0, [x2]
40025eb0: d51b4220 msr daif, x0
return false;
40025eb4: 52800000 mov w0, #0x0 // #0
}
40025eb8: a9425bf5 ldp x21, x22, [sp, #32]
40025ebc: a8c37bfd ldp x29, x30, [sp], #48
40025ec0: d65f03c0 ret
_Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING );
40025ec4: aa1303e0 mov x0, x19
40025ec8: 52a00041 mov w1, #0x20000 // #131072
40025ecc: 9400006d bl 40026080 <_Thread_Set_state_locked>
40025ed0: 17ffffdf b 40025e4c <_Thread_Restart_other+0xec>
_Thread_Clear_state_locked(
40025ed4: aa1303e0 mov x0, x19
40025ed8: 52906181 mov w1, #0x830c // #33548
40025edc: 72a60041 movk w1, #0x3002, lsl #16
40025ee0: 94000d74 bl 400294b0 <_Thread_Clear_state_locked>
40025ee4: 17ffffef b 40025ea0 <_Thread_Restart_other+0x140>
old_last = tail->previous;
40025ee8: f940ba62 ldr x2, [x19, #368]
40025eec: 9105a260 add x0, x19, #0x168
tail->previous = the_node;
40025ef0: f900ba61 str x1, [x19, #368]
the_node->next = tail;
40025ef4: f9012a60 str x0, [x19, #592]
old_last->next = the_node;
40025ef8: f9000041 str x1, [x2]
the_node->previous = old_last;
40025efc: f9012e62 str x2, [x19, #600]
}
40025f00: 17ffffcc b 40025e30 <_Thread_Restart_other+0xd0>
...
0000000040027580 <_Thread_Set_life_protection>:
return previous;
}
Thread_Life_state _Thread_Set_life_protection( Thread_Life_state state )
{
40027580: a9be7bfd stp x29, x30, [sp, #-32]!
40027584: 2a0003e3 mov w3, w0
40027588: 910003fd mov x29, sp
4002758c: f9000bf3 str x19, [sp, #16]
__asm__ volatile (
40027590: d53b4222 mrs x2, daif
40027594: d50342df msr daifset, #0x2
40027598: d00006e1 adrp x1, 40105000 <Arr_2_Glob+0x1e68>
4002759c: 91290020 add x0, x1, #0xa40
& ( THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED ) ) == 0;
400275a0: 52800125 mov w5, #0x9 // #9
400275a4: f9401001 ldr x1, [x0, #32]
previous = the_thread->Life.state;
400275a8: b9426833 ldr w19, [x1, #616]
state |= set;
400275ac: 2a1303e4 mov w4, w19
400275b0: 33000064 bfxil w4, w3, #0, #1
the_thread->Life.state = state;
400275b4: b9026824 str w4, [x1, #616]
if (
400275b8: 6a05009f tst w4, w5
400275bc: 54000221 b.ne 40027600 <_Thread_Set_life_protection+0x80> // b.any
&& _Thread_Is_life_changing( state )
400275c0: 721f049f tst w4, #0x6
400275c4: 540001e0 b.eq 40027600 <_Thread_Set_life_protection+0x80> // b.none
the_thread->is_preemptible = the_thread->Start.is_preemptible;
400275c8: 39448025 ldrb w5, [x1, #288]
action->handler = handler;
400275cc: 90000003 adrp x3, 40027000 <_Thread_queue_Priority_enqueue+0xa0>
400275d0: 910c4063 add x3, x3, #0x310
400275d4: 3903a425 strb w5, [x1, #233]
the_thread->budget_callout = the_thread->Start.budget_callout;
400275d8: f9409425 ldr x5, [x1, #296]
400275dc: f9007c25 str x5, [x1, #248]
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
400275e0: b9412426 ldr w6, [x1, #292]
400275e4: 91094024 add x4, x1, #0x250
if ( _Chain_Is_node_off_chain( the_node ) ) {
400275e8: f9412825 ldr x5, [x1, #592]
400275ec: b900f026 str w6, [x1, #240]
400275f0: f9013023 str x3, [x1, #608]
cpu_self->dispatch_necessary = true;
400275f4: 52800026 mov w6, #0x1 // #1
400275f8: 39007006 strb w6, [x0, #28]
400275fc: b4000165 cbz x5, 40027628 <_Thread_Set_life_protection+0xa8> <== ALWAYS TAKEN
disable_level = cpu_self->thread_dispatch_disable_level;
40027600: b9401801 ldr w1, [x0, #24]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40027604: 11000421 add w1, w1, #0x1
40027608: b9001801 str w1, [x0, #24]
__asm__ volatile (
4002760c: 92407c41 and x1, x2, #0xffffffff
40027610: d51b4221 msr daif, x1
_Thread_Dispatch_enable( cpu_self );
40027614: 97fffb63 bl 400263a0 <_Thread_Dispatch_enable>
return _Thread_Change_life(
THREAD_LIFE_PROTECTED,
state & THREAD_LIFE_PROTECTED,
0
);
}
40027618: 2a1303e0 mov w0, w19
4002761c: f9400bf3 ldr x19, [sp, #16]
40027620: a8c27bfd ldp x29, x30, [sp], #32
40027624: d65f03c0 ret
old_last = tail->previous;
40027628: f940b825 ldr x5, [x1, #368]
4002762c: 9105a023 add x3, x1, #0x168
tail->previous = the_node;
40027630: f900b824 str x4, [x1, #368]
the_node->next = tail;
40027634: f9012823 str x3, [x1, #592]
old_last->next = the_node;
40027638: f90000a4 str x4, [x5]
the_node->previous = old_last;
4002763c: f9012c25 str x5, [x1, #600]
}
40027640: 17fffff0 b 40027600 <_Thread_Set_life_protection+0x80>
...
00000000400285c0 <_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;
400285c0: f9404c01 ldr x1, [x0, #152]
queue_object = THREAD_QUEUE_QUEUE_TO_OBJECT( queue );
return queue_object->Object.id;
}
return 0;
400285c4: 52800000 mov w0, #0x0 // #0
if ( queue != NULL && queue->name == _Thread_queue_Object_name ) {
400285c8: b40000e1 cbz x1, 400285e4 <_Thread_Wait_get_id+0x24>
400285cc: f9400823 ldr x3, [x1, #16]
400285d0: f0000062 adrp x2, 40037000 <_Heap_Resize_block+0x40>
400285d4: 9131c042 add x2, x2, #0xc70
return 0;
400285d8: 52800000 mov w0, #0x0 // #0
if ( queue != NULL && queue->name == _Thread_queue_Object_name ) {
400285dc: eb02007f cmp x3, x2
400285e0: 54000040 b.eq 400285e8 <_Thread_Wait_get_id+0x28> // b.none <== ALWAYS TAKEN
}
400285e4: d65f03c0 ret
return queue_object->Object.id;
400285e8: b85f0020 ldur w0, [x1, #-16]
}
400285ec: d65f03c0 ret
00000000400278a0 <_Thread_Yield>:
#include <rtems/score/threadimpl.h>
#include <rtems/score/schedulerimpl.h>
void _Thread_Yield( Thread_Control *executing )
{
400278a0: a9be7bfd stp x29, x30, [sp, #-32]!
400278a4: aa0003e1 mov x1, x0
400278a8: 910003fd mov x29, sp
400278ac: f9000bf3 str x19, [sp, #16]
__asm__ volatile (
400278b0: d53b4233 mrs x19, daif
400278b4: d50342df msr daifset, #0x2
ISR_lock_Context lock_context;
_Thread_State_acquire( executing, &lock_context );
if ( _States_Is_ready( executing->current_state ) ) {
400278b8: b9403800 ldr w0, [x0, #56]
400278bc: 350000c0 cbnz w0, 400278d4 <_Thread_Yield+0x34> <== NEVER TAKEN
( *scheduler->Operations.yield )(
400278c0: 900000a0 adrp x0, 4003b000 <__sfvwrite_r+0x5d4>
400278c4: 913ee000 add x0, x0, #0xfb8
400278c8: f9403422 ldr x2, [x1, #104]
400278cc: f9400c03 ldr x3, [x0, #24]
400278d0: d63f0060 blr x3
__asm__ volatile (
400278d4: 92407e73 and x19, x19, #0xffffffff
400278d8: d51b4233 msr daif, x19
_Scheduler_Yield( executing );
}
_Thread_State_release( executing, &lock_context );
}
400278dc: f9400bf3 ldr x19, [sp, #16]
400278e0: a8c27bfd ldp x29, x30, [sp], #32
400278e4: d65f03c0 ret
...
0000000040026580 <_Thread_queue_Enqueue>:
{
40026580: a9bd7bfd stp x29, x30, [sp, #-48]!
}
40026584: aa0003e4 mov x4, x0
40026588: 910003fd mov x29, sp
4002658c: a90153f3 stp x19, x20, [sp, #16]
40026590: aa0203f3 mov x19, x2
40026594: aa0303f4 mov x20, x3
40026598: a9025bf5 stp x21, x22, [sp, #32]
4002659c: aa0003f5 mov x21, x0
the_thread->Wait.queue = queue;
400265a0: f9004c40 str x0, [x2, #152]
}
400265a4: 14000004 b 400265b4 <_Thread_queue_Enqueue+0x34>
if ( owner == the_thread ) {
400265a8: 540008e0 b.eq 400266c4 <_Thread_queue_Enqueue+0x144> // b.none
queue = owner->Wait.queue;
400265ac: f9404c84 ldr x4, [x4, #152]
} while ( queue != NULL );
400265b0: b4000084 cbz x4, 400265c0 <_Thread_queue_Enqueue+0x40>
owner = queue->owner;
400265b4: f9400484 ldr x4, [x4, #8]
if ( owner == the_thread ) {
400265b8: eb04027f cmp x19, x4
if ( owner == NULL ) {
400265bc: b5ffff64 cbnz x4, 400265a8 <_Thread_queue_Enqueue+0x28>
( *operations->enqueue )( queue, the_thread, queue_context );
400265c0: f9400423 ldr x3, [x1, #8]
queue_context->Priority.update_count = 0;
400265c4: f900129f str xzr, [x20, #32]
the_thread->Wait.operations = operations;
400265c8: f9005261 str x1, [x19, #160]
400265cc: aa1503e0 mov x0, x21
400265d0: aa1403e2 mov x2, x20
400265d4: aa1303e1 mov x1, x19
disable_level = cpu_self->thread_dispatch_disable_level;
400265d8: f00006f6 adrp x22, 40105000 <Arr_2_Glob+0x1e68>
400265dc: 912902d6 add x22, x22, #0xa40
400265e0: d63f0060 blr x3
the_thread->Wait.flags = flags;
400265e4: 52808020 mov w0, #0x401 // #1025
400265e8: 2911827f stp wzr, w0, [x19, #140]
400265ec: b9401ac0 ldr w0, [x22, #24]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
400265f0: 11000400 add w0, w0, #0x1
400265f4: b9001ac0 str w0, [x22, #24]
_ISR_lock_ISR_enable( lock_context );
400265f8: b9400280 ldr w0, [x20]
400265fc: d51b4220 msr daif, x0
( *queue_context->enqueue_callout )(
40026600: f9400684 ldr x4, [x20, #8]
40026604: aa1503e0 mov x0, x21
40026608: aa1403e3 mov x3, x20
4002660c: aa1603e2 mov x2, x22
40026610: aa1303e1 mov x1, x19
40026614: d63f0080 blr x4
_Thread_Set_state( the_thread, queue_context->thread_state );
40026618: b9400681 ldr w1, [x20, #4]
4002661c: aa1303e0 mov x0, x19
40026620: 94000420 bl 400276a0 <_Thread_Set_state>
__asm__ volatile (
40026624: d53b4220 mrs x0, daif
40026628: d50342df msr daifset, #0x2
bool success = ( the_thread->Wait.flags == expected_flags );
4002662c: b9409261 ldr w1, [x19, #144]
if ( success ) {
40026630: 7110043f cmp w1, #0x401
40026634: 54000180 b.eq 40026664 <_Thread_queue_Enqueue+0xe4> // b.none
__asm__ volatile (
40026638: 92407c00 and x0, x0, #0xffffffff
4002663c: d51b4220 msr daif, x0
if ( !success ) {
40026640: 7110043f cmp w1, #0x401
40026644: 540001c1 b.ne 4002667c <_Thread_queue_Enqueue+0xfc> // b.any <== ALWAYS TAKEN
_Thread_Priority_update( queue_context );
40026648: aa1403e0 mov x0, x20
4002664c: 94000e45 bl 40029f60 <_Thread_Priority_update>
_Thread_Dispatch_direct( cpu_self );
40026650: aa1603e0 mov x0, x22
}
40026654: a94153f3 ldp x19, x20, [sp, #16]
40026658: a9425bf5 ldp x21, x22, [sp, #32]
4002665c: a8c37bfd ldp x29, x30, [sp], #48
_Thread_Dispatch_direct( cpu_self );
40026660: 17ffff44 b 40026370 <_Thread_Dispatch_direct>
the_thread->Wait.flags = desired_flags;
40026664: 52808042 mov w2, #0x402 // #1026
40026668: b9009262 str w2, [x19, #144]
4002666c: 92407c00 and x0, x0, #0xffffffff
40026670: d51b4220 msr daif, x0
if ( !success ) {
40026674: 7110043f cmp w1, #0x401
40026678: 54fffe80 b.eq 40026648 <_Thread_queue_Enqueue+0xc8> // b.none <== ALWAYS TAKEN
__asm__ volatile (
4002667c: d53b4235 mrs x21, daif
40026680: d50342df msr daifset, #0x2
40026684: f9405a60 ldr x0, [x19, #176]
40026688: 9102e261 add x1, x19, #0xb8
4002668c: 94000589 bl 40027cb0 <_Watchdog_Remove>
__asm__ volatile (
40026690: 92407eb5 and x21, x21, #0xffffffff
40026694: d51b4235 msr daif, x21
_Thread_Clear_state( the_thread, STATES_BLOCKED );
40026698: 528bffe1 mov w1, #0x5fff // #24575
4002669c: 72a60021 movk w1, #0x3001, lsl #16
400266a0: aa1303e0 mov x0, x19
400266a4: 94000e5f bl 4002a020 <_Thread_Clear_state>
_Thread_Priority_update( queue_context );
400266a8: aa1403e0 mov x0, x20
400266ac: 94000e2d bl 40029f60 <_Thread_Priority_update>
_Thread_Dispatch_direct( cpu_self );
400266b0: aa1603e0 mov x0, x22
}
400266b4: a94153f3 ldp x19, x20, [sp, #16]
400266b8: a9425bf5 ldp x21, x22, [sp, #32]
400266bc: a8c37bfd ldp x29, x30, [sp], #48
_Thread_Dispatch_direct( cpu_self );
400266c0: 17ffff2c b 40026370 <_Thread_Dispatch_direct>
the_thread->Wait.operations = &_Thread_queue_Operations_default;
400266c4: d00000a0 adrp x0, 4003c000 <_Scheduler_Table+0x48>
400266c8: 91386000 add x0, x0, #0xe18
400266cc: a909827f stp xzr, x0, [x19, #152]
400266d0: b9400280 ldr w0, [x20]
400266d4: d51b4220 msr daif, x0
( *queue_context->deadlock_callout )( the_thread );
400266d8: aa1303e0 mov x0, x19
}
400266dc: a9425bf5 ldp x21, x22, [sp, #32]
( *queue_context->deadlock_callout )( the_thread );
400266e0: f9401e81 ldr x1, [x20, #56]
}
400266e4: a94153f3 ldp x19, x20, [sp, #16]
( *queue_context->deadlock_callout )( the_thread );
400266e8: aa0103f0 mov x16, x1
}
400266ec: a8c37bfd ldp x29, x30, [sp], #48
( *queue_context->deadlock_callout )( the_thread );
400266f0: d61f0200 br x16
...
0000000040026750 <_Thread_queue_Extract>:
&queue_context->Lock_context.Lock_context
);
}
void _Thread_queue_Extract( Thread_Control *the_thread )
{
40026750: a9ba7bfd stp x29, x30, [sp, #-96]!
40026754: 910003fd mov x29, sp
40026758: f9000bf3 str x19, [sp, #16]
4002675c: aa0003f3 mov x19, x0
queue_context->Priority.update_count = 0;
40026760: f90023ff str xzr, [sp, #64]
__asm__ volatile (
40026764: d53b4220 mrs x0, daif
40026768: d50342df msr daifset, #0x2
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
4002676c: b90023e0 str w0, [sp, #32]
_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;
40026770: f9404e60 ldr x0, [x19, #152]
if ( queue != NULL ) {
40026774: b4000360 cbz x0, 400267e0 <_Thread_queue_Extract+0x90>
( *operations->extract )( queue, the_thread, queue_context );
40026778: f9405263 ldr x3, [x19, #160]
4002677c: aa1303e1 mov x1, x19
40026780: 910083e2 add x2, sp, #0x20
40026784: f9400863 ldr x3, [x3, #16]
40026788: d63f0060 blr x3
the_thread->Wait.queue = NULL;
4002678c: f9004e7f str xzr, [x19, #152]
if ( success ) {
40026790: b9409260 ldr w0, [x19, #144]
the_thread->Wait.flags = desired_flags;
40026794: 52808081 mov w1, #0x404 // #1028
40026798: b9009261 str w1, [x19, #144]
if ( success ) {
4002679c: 7110041f cmp w0, #0x401
the_thread->Wait.operations = &_Thread_queue_Operations_default;
400267a0: d00000a0 adrp x0, 4003c000 <_Scheduler_Table+0x48>
400267a4: 91386000 add x0, x0, #0xe18
if ( success ) {
400267a8: 54000100 b.eq 400267c8 <_Thread_queue_Extract+0x78> // b.none <== NEVER TAKEN
the_thread->Wait.operations = &_Thread_queue_Operations_default;
400267ac: f9005260 str x0, [x19, #160]
if ( unblock ) {
400267b0: 910083e1 add x1, sp, #0x20
400267b4: aa1303e0 mov x0, x19
400267b8: 97ffff4e bl 400264f0 <_Thread_queue_Unblock_critical.part.0>
&queue_context.Lock_context.Lock_context
);
} else {
_Thread_Wait_release( the_thread, &queue_context );
}
}
400267bc: f9400bf3 ldr x19, [sp, #16]
400267c0: a8c67bfd ldp x29, x30, [sp], #96
400267c4: d65f03c0 ret
400267c8: f9005260 str x0, [x19, #160] <== NOT EXECUTED
_ISR_lock_ISR_enable( lock_context );
400267cc: b94023e0 ldr w0, [sp, #32] <== NOT EXECUTED
__asm__ volatile (
400267d0: d51b4220 msr daif, x0 <== NOT EXECUTED
400267d4: f9400bf3 ldr x19, [sp, #16] <== NOT EXECUTED
400267d8: a8c67bfd ldp x29, x30, [sp], #96 <== NOT EXECUTED
400267dc: d65f03c0 ret <== NOT EXECUTED
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
400267e0: b94023e0 ldr w0, [sp, #32]
400267e4: d51b4220 msr daif, x0
400267e8: f9400bf3 ldr x19, [sp, #16]
400267ec: a8c67bfd ldp x29, x30, [sp], #96
400267f0: d65f03c0 ret
...
0000000040029bd0 <_Thread_queue_Queue_get_name_and_id>:
const Thread_queue_Queue *queue,
char *buffer,
size_t buffer_size,
Objects_Id *id
)
{
40029bd0: aa0003e5 mov x5, x0 <== NOT EXECUTED
40029bd4: aa0103e0 mov x0, x1 <== NOT EXECUTED
const char *name;
name = queue->name;
if ( name == _Thread_queue_Object_name ) {
40029bd8: f00000a4 adrp x4, 40040000 <IMFS_LIMITS_AND_OPTIONS+0x5c0> <== NOT EXECUTED
40029bdc: 91356084 add x4, x4, #0xd58 <== NOT EXECUTED
{
40029be0: aa0303e6 mov x6, x3 <== NOT EXECUTED
40029be4: aa0203e3 mov x3, x2 <== NOT EXECUTED
name = queue->name;
40029be8: f94008a1 ldr x1, [x5, #16] <== NOT EXECUTED
if ( name == _Thread_queue_Object_name ) {
40029bec: eb04003f cmp x1, x4 <== NOT EXECUTED
40029bf0: 540000a0 b.eq 40029c04 <_Thread_queue_Queue_get_name_and_id+0x34> // b.none<== NOT EXECUTED
} else {
if ( name == NULL ) {
name = _Thread_queue_Object_name;
}
*id = 0;
40029bf4: b90000df str wzr, [x6] <== NOT EXECUTED
name = _Thread_queue_Object_name;
40029bf8: f100003f cmp x1, #0x0 <== NOT EXECUTED
return strlcpy( buffer, name, buffer_size );
40029bfc: 9a841021 csel x1, x1, x4, ne // ne = any <== NOT EXECUTED
40029c00: 140028d5 b 40033f54 <strlcpy> <== NOT EXECUTED
return _Objects_Name_to_string(
40029c04: aa0003e2 mov x2, x0 <== NOT EXECUTED
*id = queue_object->Object.id;
40029c08: b85f00a0 ldur w0, [x5, #-16] <== NOT EXECUTED
40029c0c: b90000c0 str w0, [x6] <== NOT EXECUTED
return _Objects_Name_to_string(
40029c10: 52800001 mov w1, #0x0 // #0 <== NOT EXECUTED
40029c14: f85f80a0 ldur x0, [x5, #-8] <== NOT EXECUTED
40029c18: 17fffbe6 b 40028bb0 <_Objects_Name_to_string> <== NOT EXECUTED
40029c1c: 00000000 udf #0
0000000040026800 <_Thread_queue_Surrender>:
Thread_queue_Heads *heads,
Thread_Control *previous_owner,
Thread_queue_Context *queue_context,
const Thread_queue_Operations *operations
)
{
40026800: a9bd7bfd stp x29, x30, [sp, #-48]!
40026804: 910003fd mov x29, sp
Per_CPU_Control *cpu_self;
_Assert( heads != NULL );
_Thread_queue_Context_clear_priority_updates( queue_context );
new_owner = ( *operations->surrender )(
40026808: f9400c84 ldr x4, [x4, #24]
{
4002680c: a90153f3 stp x19, x20, [sp, #16]
disable_level = cpu_self->thread_dispatch_disable_level;
40026810: f00006f4 adrp x20, 40105000 <Arr_2_Glob+0x1e68>
40026814: 91290294 add x20, x20, #0xa40
40026818: a9025bf5 stp x21, x22, [sp, #32]
4002681c: aa0003f6 mov x22, x0
queue_context->Priority.update_count = 0;
40026820: f900107f str xzr, [x3, #32]
40026824: aa0303f5 mov x21, x3
new_owner = ( *operations->surrender )(
40026828: d63f0080 blr x4
4002682c: aa0003f3 mov x19, x0
queue,
heads,
previous_owner,
queue_context
);
queue->owner = new_owner;
40026830: f90006c0 str x0, [x22, #8]
bool success = ( the_thread->Wait.flags == expected_flags );
40026834: 52808080 mov w0, #0x404 // #1028
the_thread->Wait.operations = &_Thread_queue_Operations_default;
40026838: d00000a1 adrp x1, 4003c000 <_Scheduler_Table+0x48>
4002683c: 91386021 add x1, x1, #0xe18
bool success = ( the_thread->Wait.flags == expected_flags );
40026840: b9409276 ldr w22, [x19, #144]
if ( success ) {
40026844: b9009260 str w0, [x19, #144]
the_thread->Wait.queue = NULL;
40026848: f9004e7f str xzr, [x19, #152]
4002684c: b9401a80 ldr w0, [x20, #24]
the_thread->Wait.operations = &_Thread_queue_Operations_default;
40026850: f9005261 str x1, [x19, #160]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40026854: 11000400 add w0, w0, #0x1
40026858: b9001a80 str w0, [x20, #24]
_ISR_lock_ISR_enable( lock_context );
4002685c: b94002a0 ldr w0, [x21]
40026860: d51b4220 msr daif, x0
_Thread_queue_Queue_release(
queue,
&queue_context->Lock_context.Lock_context
);
_Thread_Priority_update( queue_context );
40026864: aa1503e0 mov x0, x21
40026868: 94000dbe bl 40029f60 <_Thread_Priority_update>
if ( unblock ) {
4002686c: 711006df cmp w22, #0x401
40026870: 540000c1 b.ne 40026888 <_Thread_queue_Surrender+0x88> // b.any <== ALWAYS TAKEN
_Thread_Remove_timer_and_unblock( new_owner, queue );
}
_Thread_Dispatch_enable( cpu_self );
40026874: aa1403e0 mov x0, x20 <== NOT EXECUTED
}
40026878: a94153f3 ldp x19, x20, [sp, #16] <== NOT EXECUTED
4002687c: a9425bf5 ldp x21, x22, [sp, #32] <== NOT EXECUTED
40026880: a8c37bfd ldp x29, x30, [sp], #48 <== NOT EXECUTED
_Thread_Dispatch_enable( cpu_self );
40026884: 17fffec7 b 400263a0 <_Thread_Dispatch_enable> <== NOT EXECUTED
__asm__ volatile (
40026888: d53b4235 mrs x21, daif
4002688c: d50342df msr daifset, #0x2
40026890: f9405a60 ldr x0, [x19, #176]
40026894: 9102e261 add x1, x19, #0xb8
40026898: 94000506 bl 40027cb0 <_Watchdog_Remove>
__asm__ volatile (
4002689c: 92407eb5 and x21, x21, #0xffffffff
400268a0: d51b4235 msr daif, x21
_Thread_Clear_state( the_thread, STATES_BLOCKED );
400268a4: 528bffe1 mov w1, #0x5fff // #24575
400268a8: 72a60021 movk w1, #0x3001, lsl #16
400268ac: aa1303e0 mov x0, x19
400268b0: 94000ddc bl 4002a020 <_Thread_Clear_state>
400268b4: aa1403e0 mov x0, x20
}
400268b8: a94153f3 ldp x19, x20, [sp, #16]
400268bc: a9425bf5 ldp x21, x22, [sp, #32]
400268c0: a8c37bfd ldp x29, x30, [sp], #48
_Thread_Dispatch_enable( cpu_self );
400268c4: 17fffeb7 b 400263a0 <_Thread_Dispatch_enable>
...
0000000040025540 <_Timecounter_Bintime>:
{
40025540: a9bc7bfd stp x29, x30, [sp, #-64]!
40025544: 910003fd mov x29, sp
40025548: a90153f3 stp x19, x20, [sp, #16]
4002554c: aa0003f4 mov x20, x0
40025550: a9025bf5 stp x21, x22, [sp, #32]
40025554: f00006d6 adrp x22, 40100000 <_RTEMS_tasks_Information>
40025558: 910de2d6 add x22, x22, #0x378
4002555c: a90363f7 stp x23, x24, [sp, #48]
th = timehands;
40025560: f94002d3 ldr x19, [x22]
40025564: b9407277 ldr w23, [x19, #112]
tc = th->th_counter;
40025568: f9400275 ldr x21, [x19]
*bt = th->th_bintime;
4002556c: f9401a60 ldr x0, [x19, #48]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
40025570: f94002a1 ldr x1, [x21]
bintime_addx(bt, th->th_scale * tc_delta(th));
40025574: f9400a78 ldr x24, [x19, #16]
*bt = th->th_bintime;
40025578: f9000280 str x0, [x20]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
4002557c: aa1503e0 mov x0, x21
*bt = th->th_bintime;
40025580: f9401e62 ldr x2, [x19, #56]
40025584: f9000682 str x2, [x20, #8]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
40025588: d63f0020 blr x1
4002558c: b9401a61 ldr w1, [x19, #24]
40025590: b9400aa2 ldr w2, [x21, #8]
40025594: 4b010001 sub w1, w0, w1
bintime_addx(bt, th->th_scale * tc_delta(th));
40025598: 0a020021 and w1, w1, w2
4002559c: f9400680 ldr x0, [x20, #8]
400255a0: 9b187c21 mul x1, x1, x24
400255a4: ab000021 adds x1, x1, x0
_bt->frac += _x;
400255a8: f9000681 str x1, [x20, #8]
if (_u > _bt->frac)
400255ac: 54000083 b.cc 400255bc <_Timecounter_Bintime+0x7c> // b.lo, b.ul, b.last
_bt->sec++;
400255b0: f9400280 ldr x0, [x20]
400255b4: 91000400 add x0, x0, #0x1
400255b8: f9000280 str x0, [x20]
} while (gen == 0 || gen != th->th_generation);
400255bc: 34fffd37 cbz w23, 40025560 <_Timecounter_Bintime+0x20> <== NEVER TAKEN
400255c0: b9407260 ldr w0, [x19, #112]
400255c4: 6b17001f cmp w0, w23
400255c8: 54fffcc1 b.ne 40025560 <_Timecounter_Bintime+0x20> // b.any
}
400255cc: a94153f3 ldp x19, x20, [sp, #16]
400255d0: a9425bf5 ldp x21, x22, [sp, #32]
400255d4: a94363f7 ldp x23, x24, [sp, #48]
400255d8: a8c47bfd ldp x29, x30, [sp], #64
400255dc: d65f03c0 ret
0000000040027520 <_Timecounter_Binuptime>:
{
40027520: a9bc7bfd stp x29, x30, [sp, #-64]!
40027524: 910003fd mov x29, sp
40027528: a90153f3 stp x19, x20, [sp, #16]
4002752c: aa0003f4 mov x20, x0
40027530: a9025bf5 stp x21, x22, [sp, #32]
40027534: b00006d6 adrp x22, 40100000 <_RTEMS_tasks_Information>
40027538: 911122d6 add x22, x22, #0x448
4002753c: a90363f7 stp x23, x24, [sp, #48]
th = timehands;
40027540: f94002d3 ldr x19, [x22]
val = *obj;
40027544: b9407277 ldr w23, [x19, #112]
tc = th->th_counter;
40027548: f9400275 ldr x21, [x19]
*bt = th->th_offset;
4002754c: f9401260 ldr x0, [x19, #32]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
40027550: f94002a1 ldr x1, [x21]
bintime_addx(bt, th->th_scale * tc_delta(th));
40027554: f9400a78 ldr x24, [x19, #16]
*bt = th->th_offset;
40027558: f9000280 str x0, [x20]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
4002755c: aa1503e0 mov x0, x21
*bt = th->th_offset;
40027560: f9401662 ldr x2, [x19, #40]
40027564: f9000682 str x2, [x20, #8]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
40027568: d63f0020 blr x1
4002756c: b9401a61 ldr w1, [x19, #24]
40027570: b9400aa2 ldr w2, [x21, #8]
40027574: 4b010001 sub w1, w0, w1
bintime_addx(bt, th->th_scale * tc_delta(th));
40027578: 0a020021 and w1, w1, w2
4002757c: f9400680 ldr x0, [x20, #8]
40027580: 9b187c21 mul x1, x1, x24
40027584: ab000021 adds x1, x1, x0
_bt->frac += _x;
40027588: f9000681 str x1, [x20, #8]
if (_u > _bt->frac)
4002758c: 54000083 b.cc 4002759c <_Timecounter_Binuptime+0x7c> // b.lo, b.ul, b.last
_bt->sec++;
40027590: f9400280 ldr x0, [x20]
40027594: 91000400 add x0, x0, #0x1
40027598: f9000280 str x0, [x20]
} while (gen == 0 || gen != th->th_generation);
4002759c: 34fffd37 cbz w23, 40027540 <_Timecounter_Binuptime+0x20> <== NEVER TAKEN
400275a0: b9407260 ldr w0, [x19, #112]
400275a4: 6b17001f cmp w0, w23
400275a8: 54fffcc1 b.ne 40027540 <_Timecounter_Binuptime+0x20> // b.any
}
400275ac: a94153f3 ldp x19, x20, [sp, #16]
400275b0: a9425bf5 ldp x21, x22, [sp, #32]
400275b4: a94363f7 ldp x23, x24, [sp, #48]
400275b8: a8c47bfd ldp x29, x30, [sp], #64
400275bc: d65f03c0 ret
0000000040025660 <_Timecounter_Getbintime>:
{
40025660: f00006c4 adrp x4, 40100000 <_RTEMS_tasks_Information>
40025664: 910de084 add x4, x4, #0x378
th = timehands;
40025668: f9400081 ldr x1, [x4]
4002566c: b9407022 ldr w2, [x1, #112]
*bt = th->th_bintime;
40025670: f9401823 ldr x3, [x1, #48]
40025674: f9000003 str x3, [x0]
40025678: f9401c23 ldr x3, [x1, #56]
4002567c: f9000403 str x3, [x0, #8]
} while (gen == 0 || gen != th->th_generation);
40025680: 34ffff42 cbz w2, 40025668 <_Timecounter_Getbintime+0x8> <== NEVER TAKEN
40025684: b9407021 ldr w1, [x1, #112]
40025688: 6b02003f cmp w1, w2
4002568c: 54fffee1 b.ne 40025668 <_Timecounter_Getbintime+0x8> // b.any <== NEVER TAKEN
}
40025690: d65f03c0 ret
...
00000000400228d0 <_Timecounter_Getbinuptime>:
{
400228d0: d00006e4 adrp x4, 40100000 <_Thread_Information>
400228d4: 9104c084 add x4, x4, #0x130
th = timehands;
400228d8: f9400081 ldr x1, [x4]
400228dc: b9407022 ldr w2, [x1, #112]
*bt = th->th_offset;
400228e0: f9401023 ldr x3, [x1, #32]
400228e4: f9000003 str x3, [x0]
400228e8: f9401423 ldr x3, [x1, #40]
400228ec: f9000403 str x3, [x0, #8]
} while (gen == 0 || gen != th->th_generation);
400228f0: 34ffff42 cbz w2, 400228d8 <_Timecounter_Getbinuptime+0x8> <== NEVER TAKEN
400228f4: b9407021 ldr w1, [x1, #112]
400228f8: 6b02003f cmp w1, w2
400228fc: 54fffee1 b.ne 400228d8 <_Timecounter_Getbinuptime+0x8> // b.any <== NEVER TAKEN
}
40022900: d65f03c0 ret
...
0000000040022a10 <_Timecounter_Getmicrotime>:
{
40022a10: d00006e4 adrp x4, 40100000 <_Thread_Information>
40022a14: 9104c084 add x4, x4, #0x130
th = timehands;
40022a18: f9400081 ldr x1, [x4]
40022a1c: b9407022 ldr w2, [x1, #112]
*tvp = th->th_microtime;
40022a20: f9402023 ldr x3, [x1, #64]
40022a24: f9000003 str x3, [x0]
40022a28: f9402423 ldr x3, [x1, #72]
40022a2c: f9000403 str x3, [x0, #8]
} while (gen == 0 || gen != th->th_generation);
40022a30: 34ffff42 cbz w2, 40022a18 <_Timecounter_Getmicrotime+0x8> <== NEVER TAKEN
40022a34: b9407021 ldr w1, [x1, #112]
40022a38: 6b02003f cmp w1, w2
40022a3c: 54fffee1 b.ne 40022a18 <_Timecounter_Getmicrotime+0x8> // b.any <== NEVER TAKEN
}
40022a40: d65f03c0 ret
...
0000000040022950 <_Timecounter_Getmicrouptime>:
{
40022950: d00006e5 adrp x5, 40100000 <_Thread_Information>
40022954: 9104c0a5 add x5, x5, #0x130
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
40022958: d2884806 mov x6, #0x4240 // #16960
4002295c: f2a001e6 movk x6, #0xf, lsl #16
th = timehands;
40022960: f94000a2 ldr x2, [x5]
40022964: b9407043 ldr w3, [x2, #112]
40022968: b9402c41 ldr w1, [x2, #44]
_tv->tv_sec = _bt->sec;
4002296c: f9401044 ldr x4, [x2, #32]
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
40022970: 9b067c21 mul x1, x1, x6
40022974: d360fc21 lsr x1, x1, #32
40022978: a9000404 stp x4, x1, [x0]
} while (gen == 0 || gen != th->th_generation);
4002297c: 34ffff23 cbz w3, 40022960 <_Timecounter_Getmicrouptime+0x10> <== NEVER TAKEN
40022980: b9407041 ldr w1, [x2, #112]
40022984: 6b03003f cmp w1, w3
40022988: 54fffec1 b.ne 40022960 <_Timecounter_Getmicrouptime+0x10> // b.any <== NEVER TAKEN
}
4002298c: d65f03c0 ret
00000000400256a0 <_Timecounter_Getnanotime>:
{
400256a0: f00006c4 adrp x4, 40100000 <_RTEMS_tasks_Information>
400256a4: 910de084 add x4, x4, #0x378
th = timehands;
400256a8: f9400081 ldr x1, [x4]
400256ac: b9407022 ldr w2, [x1, #112]
*tsp = th->th_nanotime;
400256b0: f9402823 ldr x3, [x1, #80]
400256b4: f9000003 str x3, [x0]
400256b8: f9402c23 ldr x3, [x1, #88]
400256bc: f9000403 str x3, [x0, #8]
} while (gen == 0 || gen != th->th_generation);
400256c0: 34ffff42 cbz w2, 400256a8 <_Timecounter_Getnanotime+0x8> <== NEVER TAKEN
400256c4: b9407021 ldr w1, [x1, #112]
400256c8: 6b02003f cmp w1, w2
400256cc: 54fffee1 b.ne 400256a8 <_Timecounter_Getnanotime+0x8> // b.any <== NEVER TAKEN
}
400256d0: d65f03c0 ret
...
0000000040025620 <_Timecounter_Getnanouptime>:
{
40025620: f00006c5 adrp x5, 40100000 <_RTEMS_tasks_Information>
40025624: 910de0a5 add x5, x5, #0x378
_ts->tv_nsec = ((uint64_t)1000000000 *
40025628: d2994006 mov x6, #0xca00 // #51712
4002562c: f2a77346 movk x6, #0x3b9a, lsl #16
th = timehands;
40025630: f94000a2 ldr x2, [x5]
40025634: b9407043 ldr w3, [x2, #112]
(uint32_t)(_bt->frac >> 32)) >> 32;
40025638: b9402c41 ldr w1, [x2, #44]
_ts->tv_sec = _bt->sec;
4002563c: f9401044 ldr x4, [x2, #32]
_ts->tv_nsec = ((uint64_t)1000000000 *
40025640: 9b067c21 mul x1, x1, x6
(uint32_t)(_bt->frac >> 32)) >> 32;
40025644: d360fc21 lsr x1, x1, #32
_ts->tv_nsec = ((uint64_t)1000000000 *
40025648: a9000404 stp x4, x1, [x0]
} while (gen == 0 || gen != th->th_generation);
4002564c: 34ffff23 cbz w3, 40025630 <_Timecounter_Getnanouptime+0x10> <== NEVER TAKEN
40025650: b9407041 ldr w1, [x2, #112]
40025654: 6b03003f cmp w1, w3
40025658: 54fffec1 b.ne 40025630 <_Timecounter_Getnanouptime+0x10> // b.any <== NEVER TAKEN
}
4002565c: d65f03c0 ret
00000000400256e0 <_Timecounter_Install>:
if (tc->tc_quality < timecounter->tc_quality)
400256e0: f00006c1 adrp x1, 40100000 <_RTEMS_tasks_Information>
400256e4: f9415c22 ldr x2, [x1, #696]
400256e8: b9402004 ldr w4, [x0, #32]
400256ec: b9402043 ldr w3, [x2, #32]
400256f0: 6b03009f cmp w4, w3
400256f4: 5400022b b.lt 40025738 <_Timecounter_Install+0x58> // b.tstop <== NEVER TAKEN
if (tc->tc_quality == timecounter->tc_quality &&
400256f8: 540000a1 b.ne 4002570c <_Timecounter_Install+0x2c> // b.any
400256fc: f9400803 ldr x3, [x0, #16]
40025700: f9400842 ldr x2, [x2, #16]
40025704: eb02007f cmp x3, x2
40025708: 54000183 b.cc 40025738 <_Timecounter_Install+0x58> // b.lo, b.ul, b.last
{
4002570c: a9be7bfd stp x29, x30, [sp, #-32]!
40025710: 910003fd mov x29, sp
timecounter = tc;
40025714: f9015c20 str x0, [x1, #696]
__asm__ volatile (
40025718: d53b4220 mrs x0, daif
4002571c: d50342df msr daifset, #0x2
_Timecounter_Acquire(&lock_context);
40025720: b9001be0 str w0, [sp, #24]
_Timecounter_Windup(new_boottimebin, &lock_context);
40025724: d2800000 mov x0, #0x0 // #0
40025728: 910063e1 add x1, sp, #0x18
4002572c: 97fffee9 bl 400252d0 <_Timecounter_Windup>
}
40025730: a8c27bfd ldp x29, x30, [sp], #32
40025734: d65f03c0 ret
40025738: d65f03c0 ret
4002573c: 00000000 udf #0
00000000400254b0 <_Timecounter_Sbinuptime>:
{
400254b0: a9bb7bfd stp x29, x30, [sp, #-80]!
400254b4: 910003fd mov x29, sp
400254b8: f90023f9 str x25, [sp, #64]
400254bc: f00006d9 adrp x25, 40100000 <_RTEMS_tasks_Information>
400254c0: 910de339 add x25, x25, #0x378
400254c4: a90153f3 stp x19, x20, [sp, #16]
400254c8: a9025bf5 stp x21, x22, [sp, #32]
400254cc: a90363f7 stp x23, x24, [sp, #48]
th = timehands;
400254d0: f9400333 ldr x19, [x25]
val = *obj;
400254d4: b9407275 ldr w21, [x19, #112]
tc = th->th_counter;
400254d8: f9400274 ldr x20, [x19]
sbt += (th->th_scale * tc_delta(th)) >> 32;
400254dc: f9400a77 ldr x23, [x19, #16]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
400254e0: aa1403e0 mov x0, x20
400254e4: f9400281 ldr x1, [x20]
400254e8: a9426276 ldp x22, x24, [x19, #32]
400254ec: d63f0020 blr x1
400254f0: b9401a62 ldr w2, [x19, #24]
tc->tc_counter_mask);
400254f4: b9400a81 ldr w1, [x20, #8]
} while (gen == 0 || gen != th->th_generation);
400254f8: 34fffed5 cbz w21, 400254d0 <_Timecounter_Sbinuptime+0x20> <== NEVER TAKEN
400254fc: b9407263 ldr w3, [x19, #112]
40025500: 6b15007f cmp w3, w21
40025504: 54fffe61 b.ne 400254d0 <_Timecounter_Sbinuptime+0x20> // b.any
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
40025508: 4b020000 sub w0, w0, w2
return (((sbintime_t)_bt.sec << 32) + (_bt.frac >> 32));
4002550c: d360ff18 lsr x24, x24, #32
sbt += (th->th_scale * tc_delta(th)) >> 32;
40025510: 0a010000 and w0, w0, w1
40025514: 8b168316 add x22, x24, x22, lsl #32
}
40025518: a94153f3 ldp x19, x20, [sp, #16]
sbt += (th->th_scale * tc_delta(th)) >> 32;
4002551c: 9b177c00 mul x0, x0, x23
}
40025520: a94363f7 ldp x23, x24, [sp, #48]
40025524: 8b4082c0 add x0, x22, x0, lsr #32
40025528: a9425bf5 ldp x21, x22, [sp, #32]
4002552c: f94023f9 ldr x25, [sp, #64]
40025530: a8c57bfd ldp x29, x30, [sp], #80
40025534: d65f03c0 ret
...
0000000040026730 <_Timecounter_Tick_simple>:
{
struct bintime bt;
struct timehands *th;
uint32_t ogen;
th = timehands;
40026730: d00006c3 adrp x3, 40100000 <_RTEMS_tasks_Information>
40026734: f9420063 ldr x3, [x3, #1024]
ogen = th->th_generation;
th->th_offset_count = offset;
bintime_addx(&th->th_offset, th->th_scale * delta);
40026738: 2a0003e0 mov w0, w0
4002673c: f9400866 ldr x6, [x3, #16]
th->th_offset_count = offset;
40026740: b9001861 str w1, [x3, #24]
40026744: a9421467 ldp x7, x5, [x3, #32]
bintime_addx(&th->th_offset, th->th_scale * delta);
40026748: 9b067c00 mul x0, x0, x6
ogen = th->th_generation;
4002674c: b9407061 ldr w1, [x3, #112]
if (_u > _bt->frac)
40026750: ab050000 adds x0, x0, x5
_bt->frac += _x;
40026754: f9001460 str x0, [x3, #40]
if (_u > _bt->frac)
40026758: 54000063 b.cc 40026764 <_Timecounter_Tick_simple+0x34> // b.lo, b.ul, b.last<== ALWAYS TAKEN
_bt->sec++;
4002675c: 910004e7 add x7, x7, #0x1 <== NOT EXECUTED
40026760: f9001067 str x7, [x3, #32] <== NOT EXECUTED
_bt->frac += _bt2->frac;
40026764: f9403464 ldr x4, [x3, #104]
40026768: ab000080 adds x0, x4, x0
4002676c: 54000382 b.cs 400267dc <_Timecounter_Tick_simple+0xac> // b.hs, b.nlast
bt = th->th_offset;
40026770: aa0703e5 mov x5, x7
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
40026774: d360fc04 lsr x4, x0, #32
40026778: d2884806 mov x6, #0x4240 // #16960
4002677c: f2a001e6 movk x6, #0xf, lsl #16
_ts->tv_nsec = ((uint64_t)1000000000 *
40026780: d2994008 mov x8, #0xca00 // #51712
40026784: f2a77348 movk x8, #0x3b9a, lsl #16
if (++ogen == 0)
ogen = 1;
th->th_generation = ogen;
/* Go live with the new struct timehands. */
time_second = th->th_microtime.tv_sec;
40026788: d00006c9 adrp x9, 40100000 <_RTEMS_tasks_Information>
_bt->sec += _bt2->sec;
4002678c: f940306a ldr x10, [x3, #96]
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
40026790: 9b067c86 mul x6, x4, x6
_ts->tv_nsec = ((uint64_t)1000000000 *
40026794: 9b087c84 mul x4, x4, x8
time_uptime = th->th_offset.sec;
40026798: d00006c8 adrp x8, 40100000 <_RTEMS_tasks_Information>
_bt->sec += _bt2->sec;
4002679c: 8b0a00a5 add x5, x5, x10
th->th_generation = ogen;
400267a0: 31000421 adds w1, w1, #0x1
time_second = th->th_microtime.tv_sec;
400267a4: f901a525 str x5, [x9, #840]
th->th_generation = ogen;
400267a8: 1a9f1421 csinc w1, w1, wzr, ne // ne = any
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
400267ac: d360fcc6 lsr x6, x6, #32
(uint32_t)(_bt->frac >> 32)) >> 32;
400267b0: d360fc84 lsr x4, x4, #32
time_uptime = th->th_offset.sec;
400267b4: b9035107 str w7, [x8, #848]
th->th_bintime = bt;
400267b8: a9030065 stp x5, x0, [x3, #48]
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
400267bc: a9041865 stp x5, x6, [x3, #64]
_ts->tv_nsec = ((uint64_t)1000000000 *
400267c0: a9051065 stp x5, x4, [x3, #80]
th->th_generation = ogen;
400267c4: b9007061 str w1, [x3, #112]
_Timecounter_Release(lock_context);
400267c8: b9400040 ldr w0, [x2]
__asm__ volatile (
400267cc: d51b4220 msr daif, x0
_Watchdog_Tick(_Per_CPU_Get_snapshot());
400267d0: b00006e0 adrp x0, 40103000 <_Thread_Heads+0x28>
400267d4: 91220000 add x0, x0, #0x880
400267d8: 14000a52 b 40029120 <_Watchdog_Tick>
_bt->sec++;
400267dc: 910004e5 add x5, x7, #0x1
400267e0: 17ffffe5 b 40026774 <_Timecounter_Tick_simple+0x44>
...
00000000400255a0 <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
400255a0: aa0003e7 mov x7, x0
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
400255a4: d2993fe4 mov x4, #0xc9ff // #51711
400255a8: f2a77344 movk x4, #0x3b9a, lsl #16
time->tv_nsec += add->tv_nsec;
400255ac: a9400820 ldp x0, x2, [x1]
400255b0: a94004e3 ldp x3, x1, [x7]
uint32_t seconds = add->tv_sec;
400255b4: 2a0003e5 mov w5, w0
time->tv_nsec += add->tv_nsec;
400255b8: 8b020021 add x1, x1, x2
time->tv_sec += add->tv_sec;
400255bc: 8b030003 add x3, x0, x3
time->tv_nsec += add->tv_nsec;
400255c0: a90004e3 stp x3, x1, [x7]
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
400255c4: eb04003f cmp x1, x4
400255c8: 5400016d b.le 400255f4 <_Timespec_Add_to+0x54>
400255cc: aa0303e2 mov x2, x3
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
400255d0: 92993fe6 mov x6, #0xffffffffffff3600 // #-51712
400255d4: f2b88ca6 movk x6, #0xc465, lsl #16
time->tv_sec++;
400255d8: 91000442 add x2, x2, #0x1
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
400255dc: 8b060021 add x1, x1, x6
seconds++;
400255e0: 0b0200a0 add w0, w5, w2
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
400255e4: eb04003f cmp x1, x4
400255e8: 4b030000 sub w0, w0, w3
400255ec: 54ffff6c b.gt 400255d8 <_Timespec_Add_to+0x38> <== NEVER TAKEN
400255f0: a90004e2 stp x2, x1, [x7]
}
return seconds;
}
400255f4: d65f03c0 ret
...
00000000400278f0 <_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;
400278f0: b00000a0 adrp x0, 4003c000 <_Scheduler_Table+0x48>
400278f4: f9405c04 ldr x4, [x0, #184]
for ( i = 0 ; i < n ; ++i ) {
400278f8: b4000384 cbz x4, 40027968 <_User_extensions_Handler_initialization+0x78><== NEVER TAKEN
400278fc: b00006c7 adrp x7, 40100000 <_RTEMS_tasks_Information>
40027900: 910f00e7 add x7, x7, #0x3c0
40027904: f00006c0 adrp x0, 40102000 <_Configuration_Scheduler_priority_dflt+0x15d0>
40027908: 913e6000 add x0, x0, #0xf98
4002790c: d2800302 mov x2, #0x18 // #24
40027910: b00000a1 adrp x1, 4003c000 <_Scheduler_Table+0x48>
40027914: 91030021 add x1, x1, #0xc0
the_node->next = tail;
40027918: b00006c5 adrp x5, 40100000 <_RTEMS_tasks_Information>
4002791c: 910f20a5 add x5, x5, #0x3c8
40027920: 9b020084 madd x4, x4, x2, x0
40027924: f94008e3 ldr x3, [x7, #16]
40027928: 52800006 mov w6, #0x0 // #0
4002792c: d503201f nop
User_extensions_thread_switch_extension callout;
callout = initial_table[ i ].thread_switch;
40027930: f9401022 ldr x2, [x1, #32]
for ( i = 0 ; i < n ; ++i ) {
40027934: 91012021 add x1, x1, #0x48
if ( callout != NULL ) {
40027938: b40000e2 cbz x2, 40027954 <_User_extensions_Handler_initialization+0x64>
4002793c: f9000005 str x5, [x0]
}
40027940: 52800026 mov w6, #0x1 // #1
User_extensions_Switch_control *c;
c = &initial_switch_controls[ i ];
c->thread_switch = callout;
40027944: f9000802 str x2, [x0, #16]
old_last->next = the_node;
40027948: f9000060 str x0, [x3]
the_node->previous = old_last;
4002794c: f9000403 str x3, [x0, #8]
}
40027950: aa0003e3 mov x3, x0
for ( i = 0 ; i < n ; ++i ) {
40027954: 91006000 add x0, x0, #0x18
40027958: eb04001f cmp x0, x4
4002795c: 54fffea1 b.ne 40027930 <_User_extensions_Handler_initialization+0x40> // b.any
40027960: 34000046 cbz w6, 40027968 <_User_extensions_Handler_initialization+0x78>
40027964: f90008e3 str x3, [x7, #16]
_Chain_Initialize_node( &c->Node );
_Chain_Append_unprotected( &_User_extensions_Switches_list, &c->Node );
}
}
}
40027968: d65f03c0 ret
4002796c: 00000000 udf #0
0000000040027aa0 <_User_extensions_Iterate>:
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor,
Chain_Iterator_direction direction
)
{
40027aa0: a9b87bfd stp x29, x30, [sp, #-128]!
40027aa4: 910003fd mov x29, sp
40027aa8: a90153f3 stp x19, x20, [sp, #16]
ISR_lock_Context lock_context;
executing = _Thread_Get_executing();
initial_begin = _User_extensions_Initial_extensions;
initial_end = initial_begin + _User_extensions_Initial_count;
40027aac: b00000a3 adrp x3, 4003c000 <_Scheduler_Table+0x48>
40027ab0: f9405c73 ldr x19, [x3, #184]
{
40027ab4: a9025bf5 stp x21, x22, [sp, #32]
initial_end = initial_begin + _User_extensions_Initial_count;
40027ab8: b00000b6 adrp x22, 4003c000 <_Scheduler_Table+0x48>
40027abc: 910302d6 add x22, x22, #0xc0
40027ac0: d2800903 mov x3, #0x48 // #72
{
40027ac4: a90363f7 stp x23, x24, [sp, #48]
40027ac8: aa0103f4 mov x20, x1
40027acc: aa0003f8 mov x24, x0
40027ad0: f90023f9 str x25, [sp, #64]
initial_end = initial_begin + _User_extensions_Initial_count;
40027ad4: 9b035a73 madd x19, x19, x3, x22
40027ad8: d00006e0 adrp x0, 40105000 <Arr_2_Glob+0x1e68>
40027adc: f9453019 ldr x25, [x0, #2656]
{
40027ae0: 2a0203f7 mov w23, w2
if ( direction == CHAIN_ITERATOR_FORWARD ) {
40027ae4: 350009e2 cbnz w2, 40027c20 <_User_extensions_Iterate+0x180>
initial_current = initial_begin;
while ( initial_current != initial_end ) {
40027ae8: eb16027f cmp x19, x22
initial_current = initial_begin;
40027aec: aa1603f5 mov x21, x22
while ( initial_current != initial_end ) {
40027af0: 54000120 b.eq 40027b14 <_User_extensions_Iterate+0x74> // b.none <== NEVER TAKEN
40027af4: d503201f nop
(*visitor)( executing, arg, initial_current );
40027af8: aa1503e2 mov x2, x21
40027afc: aa1803e1 mov x1, x24
++initial_current;
40027b00: 910122b5 add x21, x21, #0x48
(*visitor)( executing, arg, initial_current );
40027b04: aa1903e0 mov x0, x25
40027b08: d63f0280 blr x20
while ( initial_current != initial_end ) {
40027b0c: eb15027f cmp x19, x21
40027b10: 54ffff41 b.ne 40027af8 <_User_extensions_Iterate+0x58> // b.any
}
end = _Chain_Immutable_tail( &_User_extensions_List.Active );
40027b14: b00006c1 adrp x1, 40100000 <_RTEMS_tasks_Information>
40027b18: 910fc020 add x0, x1, #0x3f0
40027b1c: 91002015 add x21, x0, #0x8
__asm__ volatile (
40027b20: d53b4223 mrs x3, daif
40027b24: d50342df msr daifset, #0x2
old_last = tail->previous;
40027b28: f9401404 ldr x4, [x0, #40]
the_node->next = tail;
40027b2c: 91008001 add x1, x0, #0x20
tail->previous = the_node;
40027b30: 910163e2 add x2, sp, #0x58
40027b34: f9001402 str x2, [x0, #40]
the_node->next = tail;
40027b38: f9002fe1 str x1, [sp, #88]
);
the_iterator->direction = direction;
if ( direction == CHAIN_ITERATOR_FORWARD ) {
the_iterator->position = _Chain_Head( the_chain );
40027b3c: 710002ff cmp w23, #0x0
40027b40: 91002001 add x1, x0, #0x8
old_last->next = the_node;
40027b44: f9000082 str x2, [x4]
the_iterator->position = _Chain_Head( the_chain );
40027b48: 9a801021 csel x1, x1, x0, ne // ne = any
the_node->previous = old_last;
40027b4c: f90033e4 str x4, [sp, #96]
the_iterator->direction = direction;
40027b50: b9006bf7 str w23, [sp, #104]
if ( direction == CHAIN_ITERATOR_FORWARD ) {
40027b54: f9003be1 str x1, [sp, #112]
&_User_extensions_List.Iterators,
&iter.Iterator,
direction
);
if ( executing != NULL ) {
40027b58: b4000099 cbz x25, 40027b68 <_User_extensions_Iterate+0xc8>
iter.previous = executing->last_user_extensions_iterator;
40027b5c: f9414f20 ldr x0, [x25, #664]
40027b60: f9003fe0 str x0, [sp, #120]
executing->last_user_extensions_iterator = &iter;
40027b64: f9014f22 str x2, [x25, #664]
the_iterator->position = _Chain_Head( the_chain );
40027b68: 2a1703e0 mov w0, w23
40027b6c: 1400000b b 40027b98 <_User_extensions_Iterate+0xf8>
RTEMS_INLINE_ROUTINE void _Chain_Iterator_set_position(
Chain_Iterator *the_iterator,
Chain_Node *the_node
)
{
the_iterator->position = the_node;
40027b70: f9003be2 str x2, [sp, #112]
__asm__ volatile (
40027b74: d51b4223 msr daif, x3
_Chain_Iterator_set_position( &iter.Iterator, node );
_User_extensions_Release( &lock_context );
extension = (const User_extensions_Control *) node;
( *visitor )( executing, arg, &extension->Callouts );
40027b78: 9100a042 add x2, x2, #0x28
40027b7c: aa1803e1 mov x1, x24
40027b80: aa1903e0 mov x0, x25
40027b84: d63f0280 blr x20
__asm__ volatile (
40027b88: d53b4223 mrs x3, daif
40027b8c: d50342df msr daifset, #0x2
if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) {
40027b90: b9406be0 ldr w0, [sp, #104]
return _Chain_Next( the_iterator->position );
40027b94: f9403be1 ldr x1, [sp, #112]
return _Chain_Previous( the_iterator->position );
40027b98: 7100001f cmp w0, #0x0
return the_node->previous;
40027b9c: a9400022 ldp x2, x0, [x1]
_ISR_lock_Release_and_ISR_enable(
40027ba0: 2a0303e3 mov w3, w3
return _Chain_Previous( the_iterator->position );
40027ba4: 9a800042 csel x2, x2, x0, eq // eq = none
while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) {
40027ba8: eb0202bf cmp x21, x2
40027bac: 54fffe21 b.ne 40027b70 <_User_extensions_Iterate+0xd0> // b.any
_User_extensions_Acquire( &lock_context );
}
if ( executing != NULL ) {
40027bb0: b4000079 cbz x25, 40027bbc <_User_extensions_Iterate+0x11c>
executing->last_user_extensions_iterator = iter.previous;
40027bb4: f9403fe0 ldr x0, [sp, #120]
40027bb8: f9014f20 str x0, [x25, #664]
previous = the_node->previous;
40027bbc: a94583e1 ldp x1, x0, [sp, #88]
next->previous = previous;
40027bc0: f9000420 str x0, [x1, #8]
previous->next = next;
40027bc4: f9000001 str x1, [x0]
__asm__ volatile (
40027bc8: d51b4223 msr daif, x3
_Chain_Iterator_destroy( &iter.Iterator );
_User_extensions_Release( &lock_context );
if ( direction == CHAIN_ITERATOR_BACKWARD ) {
40027bcc: 710006ff cmp w23, #0x1
40027bd0: 54000180 b.eq 40027c00 <_User_extensions_Iterate+0x160> // b.none
while ( initial_current != initial_begin ) {
--initial_current;
(*visitor)( executing, arg, initial_current );
}
}
}
40027bd4: a94153f3 ldp x19, x20, [sp, #16]
40027bd8: a9425bf5 ldp x21, x22, [sp, #32]
40027bdc: a94363f7 ldp x23, x24, [sp, #48]
40027be0: f94023f9 ldr x25, [sp, #64]
40027be4: a8c87bfd ldp x29, x30, [sp], #128
40027be8: d65f03c0 ret
--initial_current;
40027bec: d1012273 sub x19, x19, #0x48
(*visitor)( executing, arg, initial_current );
40027bf0: aa1803e1 mov x1, x24
40027bf4: aa1303e2 mov x2, x19
40027bf8: aa1903e0 mov x0, x25
40027bfc: d63f0280 blr x20
while ( initial_current != initial_begin ) {
40027c00: eb16027f cmp x19, x22
40027c04: 54ffff41 b.ne 40027bec <_User_extensions_Iterate+0x14c> // b.any
}
40027c08: a94153f3 ldp x19, x20, [sp, #16]
40027c0c: a9425bf5 ldp x21, x22, [sp, #32]
40027c10: a94363f7 ldp x23, x24, [sp, #48]
40027c14: f94023f9 ldr x25, [sp, #64]
40027c18: a8c87bfd ldp x29, x30, [sp], #128
40027c1c: d65f03c0 ret
end = _Chain_Immutable_head( &_User_extensions_List.Active );
40027c20: b00006c1 adrp x1, 40100000 <_RTEMS_tasks_Information>
40027c24: 910fc020 add x0, x1, #0x3f0
40027c28: aa0003f5 mov x21, x0
40027c2c: 17ffffbd b 40027b20 <_User_extensions_Iterate+0x80>
0000000040031500 <_User_extensions_Remove_set>:
__asm__ volatile (
40031500: d53b4226 mrs x6, daif
40031504: d50342df msr daifset, #0x2
return the_node->next;
40031508: f0000661 adrp x1, 40100000 <T_case_instance_TestInterruptBlocked>
4003150c: f9421021 ldr x1, [x1, #1056]
while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
40031510: f0000663 adrp x3, 40100000 <T_case_instance_TestInterruptBlocked>
40031514: 9110a063 add x3, x3, #0x428
40031518: eb03003f cmp x1, x3
4003151c: a9401005 ldp x5, x4, [x0]
40031520: 540000a1 b.ne 40031534 <_User_extensions_Remove_set+0x34> // b.any <== NEVER TAKEN
40031524: 1400000e b 4003155c <_User_extensions_Remove_set+0x5c>
return the_node->next;
40031528: f9400021 ldr x1, [x1] <== NOT EXECUTED
while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
4003152c: eb03003f cmp x1, x3 <== NOT EXECUTED
40031530: 54000160 b.eq 4003155c <_User_extensions_Remove_set+0x5c> // b.none<== NOT EXECUTED
if ( iter->position == the_node_to_extract ) {
40031534: f9400c22 ldr x2, [x1, #24] <== NOT EXECUTED
40031538: eb02001f cmp x0, x2 <== NOT EXECUTED
4003153c: 54ffff61 b.ne 40031528 <_User_extensions_Remove_set+0x28> // b.any <== NOT EXECUTED
if ( iter->direction == CHAIN_ITERATOR_FORWARD ) {
40031540: b9401022 ldr w2, [x1, #16] <== NOT EXECUTED
iter->position = _Chain_Previous( the_node_to_extract );
40031544: 7100005f cmp w2, #0x0 <== NOT EXECUTED
40031548: 9a8410a2 csel x2, x5, x4, ne // ne = any <== NOT EXECUTED
4003154c: f9000c22 str x2, [x1, #24] <== NOT EXECUTED
return the_node->next;
40031550: f9400021 ldr x1, [x1] <== NOT EXECUTED
while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
40031554: eb03003f cmp x1, x3 <== NOT EXECUTED
40031558: 54fffee1 b.ne 40031534 <_User_extensions_Remove_set+0x34> // b.any <== NOT EXECUTED
next->previous = previous;
4003155c: f90004a4 str x4, [x5, #8]
previous->next = next;
40031560: f9000085 str x5, [x4]
__asm__ volatile (
40031564: 92407cc1 and x1, x6, #0xffffffff
40031568: d51b4221 msr daif, x1
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL ) {
4003156c: f9402401 ldr x1, [x0, #72]
40031570: b4000101 cbz x1, 40031590 <_User_extensions_Remove_set+0x90>
__asm__ volatile (
40031574: d53b4221 mrs x1, daif
40031578: d50342df msr daifset, #0x2
previous = the_node->previous;
4003157c: a9410002 ldp x2, x0, [x0, #16]
next->previous = previous;
40031580: f9000440 str x0, [x2, #8]
previous->next = next;
40031584: f9000002 str x2, [x0]
__asm__ volatile (
40031588: 92407c20 and x0, x1, #0xffffffff
4003158c: d51b4220 msr daif, x0
_Per_CPU_Acquire_all( &lock_context );
_Chain_Extract_unprotected( &the_extension->Switch.Node );
_Per_CPU_Release_all( &lock_context );
}
}
40031590: d65f03c0 ret
...
0000000040027970 <_User_extensions_Thread_create_visitor>:
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
User_extensions_thread_create_extension callout = callouts->thread_create;
40027970: f9400042 ldr x2, [x2]
if ( callout != NULL ) {
40027974: b40001c2 cbz x2, 400279ac <_User_extensions_Thread_create_visitor+0x3c>
{
40027978: a9be7bfd stp x29, x30, [sp, #-32]!
4002797c: 910003fd mov x29, sp
40027980: f9000bf3 str x19, [sp, #16]
40027984: aa0103f3 mov x19, x1
User_extensions_Thread_create_context *ctx = arg;
ctx->ok = ctx->ok && (*callout)( executing, ctx->created );
40027988: 39402021 ldrb w1, [x1, #8]
4002798c: 34000081 cbz w1, 4002799c <_User_extensions_Thread_create_visitor+0x2c><== NEVER TAKEN
40027990: f9400261 ldr x1, [x19]
40027994: d63f0040 blr x2
40027998: 12001c01 and w1, w0, #0xff
4002799c: 39002261 strb w1, [x19, #8]
} }
400279a0: f9400bf3 ldr x19, [sp, #16]
400279a4: a8c27bfd ldp x29, x30, [sp], #32
400279a8: d65f03c0 ret
400279ac: d65f03c0 ret
0000000040027d30 <_Watchdog_Do_tickle>:
#ifdef RTEMS_SMP
ISR_lock_Control *lock,
#endif
ISR_lock_Context *lock_context
)
{
40027d30: a9bc7bfd stp x29, x30, [sp, #-64]!
40027d34: 910003fd mov x29, sp
40027d38: a90153f3 stp x19, x20, [sp, #16]
40027d3c: aa0003f4 mov x20, x0
40027d40: aa0103f3 mov x19, x1
40027d44: a9025bf5 stp x21, x22, [sp, #32]
40027d48: aa0203f6 mov x22, x2
40027d4c: aa0303f5 mov x21, x3
40027d50: f9001bf7 str x23, [sp, #48]
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
40027d54: 52800057 mov w23, #0x2 // #2
do {
if ( first->expire <= now ) {
40027d58: f9401660 ldr x0, [x19, #40]
40027d5c: eb16001f cmp x0, x22
40027d60: 540002c8 b.hi 40027db8 <_Watchdog_Do_tickle+0x88> // b.pmore
return RB_RIGHT( the_node, Node );
40027d64: f9400664 ldr x4, [x19, #8]
if ( node != NULL ) {
40027d68: b4000324 cbz x4, 40027dcc <_Watchdog_Do_tickle+0x9c>
40027d6c: d503201f nop
return RB_LEFT( the_node, Node );
40027d70: aa0403e1 mov x1, x4
40027d74: f9400084 ldr x4, [x4]
while ( ( left = _RBTree_Left( node ) ) != NULL ) {
40027d78: b5ffffc4 cbnz x4, 40027d70 <_Watchdog_Do_tickle+0x40> <== NEVER TAKEN
header->first = node;
40027d7c: f9000681 str x1, [x20, #8]
Watchdog_Service_routine_entry routine;
_Watchdog_Next_first( header, first );
_RBTree_Extract( &header->Watchdogs, &first->Node.RBTree );
40027d80: aa1303e1 mov x1, x19
40027d84: aa1403e0 mov x0, x20
40027d88: 94000622 bl 40029610 <_RBTree_Extract>
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
40027d8c: b9001a77 str w23, [x19, #24]
_Watchdog_Set_state( first, WATCHDOG_INACTIVE );
routine = first->routine;
40027d90: f9401261 ldr x1, [x19, #32]
_ISR_lock_Release_and_ISR_enable( lock, lock_context );
40027d94: b94002a0 ldr w0, [x21]
40027d98: d51b4220 msr daif, x0
( *routine )( first );
40027d9c: aa1303e0 mov x0, x19
40027da0: d63f0020 blr x1
__asm__ volatile (
40027da4: d53b4220 mrs x0, daif
40027da8: d50342df msr daifset, #0x2
_ISR_lock_ISR_disable_and_acquire( lock, lock_context );
40027dac: b90002a0 str w0, [x21]
return (Watchdog_Control *) header->first;
40027db0: f9400693 ldr x19, [x20, #8]
} else {
break;
}
first = _Watchdog_Header_first( header );
} while ( first != NULL );
40027db4: b5fffd33 cbnz x19, 40027d58 <_Watchdog_Do_tickle+0x28>
}
40027db8: a94153f3 ldp x19, x20, [sp, #16]
40027dbc: a9425bf5 ldp x21, x22, [sp, #32]
40027dc0: f9401bf7 ldr x23, [sp, #48]
40027dc4: a8c47bfd ldp x29, x30, [sp], #64
40027dc8: d65f03c0 ret
header->first = _RBTree_Parent( &the_watchdog->Node.RBTree );
40027dcc: f9400a60 ldr x0, [x19, #16]
40027dd0: f9000680 str x0, [x20, #8]
40027dd4: 17ffffeb b 40027d80 <_Watchdog_Do_tickle+0x50>
...
0000000040027cb0 <_Watchdog_Remove>:
void _Watchdog_Remove(
Watchdog_Header *header,
Watchdog_Control *the_watchdog
)
{
40027cb0: a9be7bfd stp x29, x30, [sp, #-32]!
40027cb4: 910003fd mov x29, sp
40027cb8: f9000bf3 str x19, [sp, #16]
40027cbc: aa0103f3 mov x19, x1
if ( _Watchdog_Is_scheduled( the_watchdog ) ) {
40027cc0: b9401821 ldr w1, [x1, #24]
40027cc4: 7100043f cmp w1, #0x1
40027cc8: 54000089 b.ls 40027cd8 <_Watchdog_Remove+0x28> // b.plast
}
_RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree );
_Watchdog_Set_state( the_watchdog, WATCHDOG_INACTIVE );
}
}
40027ccc: f9400bf3 ldr x19, [sp, #16]
40027cd0: a8c27bfd ldp x29, x30, [sp], #32
40027cd4: d65f03c0 ret
if ( header->first == &the_watchdog->Node.RBTree ) {
40027cd8: f9400401 ldr x1, [x0, #8]
40027cdc: eb13003f cmp x1, x19
40027ce0: 54000100 b.eq 40027d00 <_Watchdog_Remove+0x50> // b.none
_RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree );
40027ce4: aa1303e1 mov x1, x19
40027ce8: 9400064a bl 40029610 <_RBTree_Extract>
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
40027cec: 52800040 mov w0, #0x2 // #2
40027cf0: b9001a60 str w0, [x19, #24]
}
40027cf4: f9400bf3 ldr x19, [sp, #16]
40027cf8: a8c27bfd ldp x29, x30, [sp], #32
40027cfc: d65f03c0 ret
return RB_RIGHT( the_node, Node );
40027d00: f9400661 ldr x1, [x19, #8]
if ( node != NULL ) {
40027d04: b40000c1 cbz x1, 40027d1c <_Watchdog_Remove+0x6c>
return RB_LEFT( the_node, Node );
40027d08: aa0103e2 mov x2, x1
40027d0c: f9400021 ldr x1, [x1]
while ( ( left = _RBTree_Left( node ) ) != NULL ) {
40027d10: b5ffffc1 cbnz x1, 40027d08 <_Watchdog_Remove+0x58> <== NEVER TAKEN
header->first = node;
40027d14: f9000402 str x2, [x0, #8]
40027d18: 17fffff3 b 40027ce4 <_Watchdog_Remove+0x34>
header->first = _RBTree_Parent( &the_watchdog->Node.RBTree );
40027d1c: f9400a61 ldr x1, [x19, #16]
40027d20: f9000401 str x1, [x0, #8]
40027d24: 17fffff0 b 40027ce4 <_Watchdog_Remove+0x34>
...
000000004002b060 <_Workspace_Handler_initialization>:
void _Workspace_Handler_initialization(
const Memory_Information *mem,
Heap_Initialization_or_extend_handler extend
)
{
4002b060: a9ba7bfd stp x29, x30, [sp, #-96]!
4002b064: 910003fd mov x29, sp
uintptr_t page_size;
uintptr_t overhead;
size_t i;
page_size = CPU_HEAP_ALIGNMENT;
remaining = rtems_configuration_get_work_space_size();
4002b068: b0000082 adrp x2, 4003c000 <_Scheduler_Table+0x48>
4002b06c: 397ec042 ldrb w2, [x2, #4016]
{
4002b070: a90363f7 stp x23, x24, [sp, #48]
4002b074: aa0103f7 mov x23, x1
4002b078: a9046bf9 stp x25, x26, [sp, #64]
4002b07c: d280001a mov x26, #0x0 // #0
4002b080: f9002bfb str x27, [sp, #80]
4002b084: aa0003fb mov x27, x0
remaining = rtems_configuration_get_work_space_size();
4002b088: 34000862 cbz w2, 4002b194 <_Workspace_Handler_initialization+0x134> <== ALWAYS TAKEN
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 ) {
4002b08c: f9400360 ldr x0, [x27]
remaining = rtems_configuration_get_work_space_size();
4002b090: b0000081 adrp x1, 4003c000 <_Scheduler_Table+0x48>
4002b094: f940d021 ldr x1, [x1, #416]
unified = rtems_configuration_get_unified_work_area();
4002b098: b0000082 adrp x2, 4003c000 <_Scheduler_Table+0x48>
4002b09c: 397ec459 ldrb w25, [x2, #4017]
remaining = rtems_configuration_get_work_space_size();
4002b0a0: 8b01035a add x26, x26, x1
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
4002b0a4: b40005e0 cbz x0, 4002b160 <_Workspace_Handler_initialization+0x100> <== NEVER TAKEN
init_or_extend = _Heap_Initialize;
4002b0a8: b0ffffc4 adrp x4, 40024000 <memfile_read+0xe0>
4002b0ac: 913e0084 add x4, x4, #0xf80
} else {
size = 0;
}
}
space_available = ( *init_or_extend )(
4002b0b0: d00006d8 adrp x24, 40105000 <Arr_2_Glob+0x1e68>
4002b0b4: 91304318 add x24, x24, #0xc10
4002b0b8: a90153f3 stp x19, x20, [sp, #16]
4002b0bc: a9025bf5 stp x21, x22, [sp, #32]
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
4002b0c0: d2800016 mov x22, #0x0 // #0
4002b0c4: d2800015 mov x21, #0x0 // #0
4002b0c8: 14000008 b 4002b0e8 <_Workspace_Handler_initialization+0x88>
);
_Memory_Consume( area, size );
if ( space_available < remaining ) {
remaining -= space_available;
4002b0cc: cb00035a sub x26, x26, x0 <== NOT EXECUTED
} else {
remaining = 0;
}
init_or_extend = extend;
4002b0d0: aa1703e4 mov x4, x23 <== NOT EXECUTED
4002b0d4: f9400360 ldr x0, [x27] <== NOT EXECUTED
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
4002b0d8: 910006b5 add x21, x21, #0x1
4002b0dc: 910062d6 add x22, x22, #0x18
4002b0e0: eb0002bf cmp x21, x0
4002b0e4: 540003a2 b.cs 4002b158 <_Workspace_Handler_initialization+0xf8> // b.hs, b.nlast<== ALWAYS TAKEN
return &information->areas[ index ];
4002b0e8: f9400773 ldr x19, [x27, #8]
4002b0ec: 8b160273 add x19, x19, x22
return (uintptr_t) area->end - (uintptr_t) area->free;
4002b0f0: a940d261 ldp x1, x20, [x19, #8]
4002b0f4: cb010294 sub x20, x20, x1
if ( free_size > overhead ) {
4002b0f8: f100ba9f cmp x20, #0x2e
4002b0fc: 54fffee9 b.ls 4002b0d8 <_Workspace_Handler_initialization+0x78> // b.plast
if ( unified ) {
4002b100: 350000d9 cbnz w25, 4002b118 <_Workspace_Handler_initialization+0xb8>
if ( remaining > 0 ) {
4002b104: b40003ba cbz x26, 4002b178 <_Workspace_Handler_initialization+0x118> <== NEVER TAKEN
size = remaining < free_size - overhead ?
4002b108: d100ba82 sub x2, x20, #0x2e
remaining + overhead : free_size;
4002b10c: 9100bb40 add x0, x26, #0x2e
4002b110: eb1a005f cmp x2, x26
4002b114: 9a948014 csel x20, x0, x20, hi // hi = pmore
space_available = ( *init_or_extend )(
4002b118: aa1403e2 mov x2, x20
4002b11c: aa1803e0 mov x0, x24
4002b120: d2800203 mov x3, #0x10 // #16
4002b124: d63f0080 blr x4
area->free = (char *) area->free + consume;
4002b128: f9400661 ldr x1, [x19, #8]
if ( space_available < remaining ) {
4002b12c: eb1a001f cmp x0, x26
4002b130: 8b140021 add x1, x1, x20
4002b134: f9000661 str x1, [x19, #8]
4002b138: 54fffca3 b.cc 4002b0cc <_Workspace_Handler_initialization+0x6c> // b.lo, b.ul, b.last<== NEVER TAKEN
4002b13c: f9400360 ldr x0, [x27]
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
4002b140: 910006b5 add x21, x21, #0x1
init_or_extend = extend;
4002b144: aa1703e4 mov x4, x23
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
4002b148: 910062d6 add x22, x22, #0x18
4002b14c: eb0002bf cmp x21, x0
remaining = 0;
4002b150: d280001a mov x26, #0x0 // #0
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
4002b154: 54fffca3 b.cc 4002b0e8 <_Workspace_Handler_initialization+0x88> // b.lo, b.ul, b.last<== NEVER TAKEN
4002b158: a94153f3 ldp x19, x20, [sp, #16]
4002b15c: a9425bf5 ldp x21, x22, [sp, #32]
}
}
if ( remaining > 0 ) {
4002b160: b500021a cbnz x26, 4002b1a0 <_Workspace_Handler_initialization+0x140>
_Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE );
}
_Heap_Protection_set_delayed_free_fraction( &_Workspace_Area, 1 );
}
4002b164: a94363f7 ldp x23, x24, [sp, #48]
4002b168: a9446bf9 ldp x25, x26, [sp, #64]
4002b16c: f9402bfb ldr x27, [sp, #80]
4002b170: a8c67bfd ldp x29, x30, [sp], #96
4002b174: d65f03c0 ret
space_available = ( *init_or_extend )(
4002b178: aa1803e0 mov x0, x24 <== NOT EXECUTED
4002b17c: d2800203 mov x3, #0x10 // #16 <== NOT EXECUTED
4002b180: d2800002 mov x2, #0x0 // #0 <== NOT EXECUTED
4002b184: d63f0080 blr x4 <== NOT EXECUTED
init_or_extend = extend;
4002b188: aa1703e4 mov x4, x23 <== NOT EXECUTED
4002b18c: f9400360 ldr x0, [x27] <== NOT EXECUTED
4002b190: 17ffffd2 b 4002b0d8 <_Workspace_Handler_initialization+0x78> <== NOT EXECUTED
remaining = rtems_configuration_get_work_space_size();
4002b194: 940000ef bl 4002b550 <rtems_configuration_get_stack_space_size>
4002b198: aa0003fa mov x26, x0
4002b19c: 17ffffbc b 4002b08c <_Workspace_Handler_initialization+0x2c>
_Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE );
4002b1a0: 52800040 mov w0, #0x2 // #2
4002b1a4: a90153f3 stp x19, x20, [sp, #16]
4002b1a8: a9025bf5 stp x21, x22, [sp, #32]
4002b1ac: 97ffe83d bl 400252a0 <_Internal_error>