=============================================================================== 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 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 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 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 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 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 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 40024d94: 910a0042 add x2, x2, #0x280 40024d98: 2a1903e0 mov w0, w25 40024d9c: 14000014 b 40024dec <_Heap_Walk+0x16c> (*printer)( 40024da0: f0000082 adrp x2, 40037000 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 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 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 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 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 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 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 40024f10: 91124000 add x0, x0, #0x490 40024f14: f9004be0 str x0, [sp, #144] (*printer)( 40024f18: f0000080 adrp x0, 40037000 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 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 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 40025058: 911100c1 add x1, x6, #0x440 4002505c: eb05031f cmp x24, x5 40025060: d0000086 adrp x6, 40037000 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 4002507c: 91110022 add x2, x1, #0x440 40025080: eb07031f cmp x24, x7 40025084: d0000081 adrp x1, 40037000 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 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 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 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 40025158: 9103a021 add x1, x1, #0xe8 4002515c: 17ffffcd b 40025090 <_Heap_Walk+0x410> 40025160: d0000086 adrp x6, 40037000 40025164: 910320c6 add x6, x6, #0xc8 40025168: 17ffffc1 b 4002506c <_Heap_Walk+0x3ec> (*printer)( 4002516c: d0000082 adrp x2, 40037000 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 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 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 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 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 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 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 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 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 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 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 <== 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 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 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 #include 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 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 /* 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 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 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( 4002912c: f94022c1 ldr x1, [x22, #64] 40029130: d37ffb02 lsl x2, x24, #1 40029134: aa1703e0 mov x0, x23 40029138: 940048ba bl 4003b420 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 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 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 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 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 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 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 #include 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 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 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 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 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 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 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 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 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 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 <== NOT EXECUTED 40025274: 9127e001 add x1, x0, #0x9f8 <== NOT EXECUTED _System_state_Current = state; 40025278: 90000702 adrp x2, 40105000 <== 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 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 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 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 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 ... =============================================================================== 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 ); 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 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 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 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 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 #include 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 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 <== 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 <== 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 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 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 4003150c: f9421021 ldr x1, [x1, #1056] while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) { 40031510: f0000663 adrp x3, 40100000 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 4002b0ac: 913e0084 add x4, x4, #0xf80 } else { size = 0; } } space_available = ( *init_or_extend )( 4002b0b0: d00006d8 adrp x24, 40105000 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 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>