=============================================================================== 0000e8e0 <_CORE_message_queue_Initialize>: CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, size_t maximum_message_size ) { e8e0: e92d40f0 push {r4, r5, r6, r7, lr} /* * Check if allocated_message_size is aligned to uintptr-size boundary. * If not, it will increase allocated_message_size to multiplicity of pointer * size. */ if (allocated_message_size & (sizeof(uintptr_t) - 1)) { e8e4: e3130003 tst r3, #3 CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, size_t maximum_message_size ) { e8e8: e1a04000 mov r4, r0 size_t message_buffering_required = 0; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; the_message_queue->number_of_pending_messages = 0; e8ec: e3a00000 mov r0, #0 CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, size_t maximum_message_size ) { e8f0: e1a07001 mov r7, r1 e8f4: e1a05002 mov r5, r2 size_t message_buffering_required = 0; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; e8f8: e5842044 str r2, [r4, #68] ; 0x44 the_message_queue->number_of_pending_messages = 0; e8fc: e5840048 str r0, [r4, #72] ; 0x48 the_message_queue->maximum_message_size = maximum_message_size; e900: e584304c str r3, [r4, #76] ; 0x4c /* * Check if allocated_message_size is aligned to uintptr-size boundary. * If not, it will increase allocated_message_size to multiplicity of pointer * size. */ if (allocated_message_size & (sizeof(uintptr_t) - 1)) { e904: 01a06003 moveq r6, r3 e908: 0a000003 beq e91c <_CORE_message_queue_Initialize+0x3c> allocated_message_size += sizeof(uintptr_t); e90c: e2836004 add r6, r3, #4 allocated_message_size &= ~(sizeof(uintptr_t) - 1); e910: e3c66003 bic r6, r6, #3 /* * Check for an overflow. It can occur while increasing allocated_message_size * to multiplicity of uintptr_t above. */ if (allocated_message_size < maximum_message_size) e914: e1560003 cmp r6, r3 e918: 38bd80f0 popcc {r4, r5, r6, r7, pc} /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ if ( !size_t_mult32_with_overflow( e91c: e2866010 add r6, r6, #16 size_t a, size_t b, size_t *c ) { long long x = (long long)a*b; e920: e0810695 umull r0, r1, r5, r6 if ( x > SIZE_MAX ) e924: e3e02000 mvn r2, #0 e928: e3a03000 mov r3, #0 e92c: e1520000 cmp r2, r0 e930: e0d3c001 sbcs ip, r3, r1 */ if ( !size_t_mult32_with_overflow( (size_t) maximum_pending_messages, allocated_message_size + sizeof(CORE_message_queue_Buffer_control), &message_buffering_required ) ) return false; e934: b3a00000 movlt r0, #0 size_t *c ) { long long x = (long long)a*b; if ( x > SIZE_MAX ) e938: b8bd80f0 poplt {r4, r5, r6, r7, pc} /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); e93c: eb000b1d bl 115b8 <_Workspace_Allocate> if (the_message_queue->message_buffers == 0) e940: e3500000 cmp r0, #0 /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); e944: e1a01000 mov r1, r0 return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) e948: e584005c str r0, [r4, #92] ; 0x5c _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) e94c: 0a000013 beq e9a0 <_CORE_message_queue_Initialize+0xc0> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( e950: e2840060 add r0, r4, #96 ; 0x60 e954: e1a02005 mov r2, r5 e958: e1a03006 mov r3, r6 e95c: ebffffcf bl e8a0 <_Chain_Initialize> allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); _Thread_queue_Initialize( e960: e5971000 ldr r1, [r7] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); e964: e2843050 add r3, r4, #80 ; 0x50 e968: e2842054 add r2, r4, #84 ; 0x54 head->next = tail; head->previous = NULL; tail->previous = head; e96c: e5843058 str r3, [r4, #88] ; 0x58 e970: e2413001 sub r3, r1, #1 e974: e2731000 rsbs r1, r3, #0 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; e978: e5842050 str r2, [r4, #80] ; 0x50 head->previous = NULL; e97c: e3a02000 mov r2, #0 e980: e5842054 str r2, [r4, #84] ; 0x54 e984: e1a00004 mov r0, r4 e988: e0a11003 adc r1, r1, r3 e98c: e3a02080 mov r2, #128 ; 0x80 e990: e3a03006 mov r3, #6 e994: eb00090b bl 10dc8 <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; e998: e3a00001 mov r0, #1 e99c: e8bd80f0 pop {r4, r5, r6, r7, pc} } e9a0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 000072b0 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 72b0: e92d4007 push {r0, r1, r2, lr} 72b4: e20160ff and r6, r1, #255 ; 0xff 72b8: e1a04000 mov r4, r0 Internal_errors_Source source, bool is_internal, Internal_errors_t error ) { User_extensions_Fatal_context ctx = { source, is_internal, error }; 72bc: e58d0000 str r0, [sp] _User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor ); 72c0: e59f1040 ldr r1, [pc, #64] ; 7308 <_Internal_error_Occurred+0x58> 72c4: e1a0000d mov r0, sp 72c8: e1a05002 mov r5, r2 Internal_errors_Source source, bool is_internal, Internal_errors_t error ) { User_extensions_Fatal_context ctx = { source, is_internal, error }; 72cc: e58d2008 str r2, [sp, #8] 72d0: e5cd6004 strb r6, [sp, #4] _User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor ); 72d4: eb000755 bl 9030 <_User_extensions_Iterate> _User_extensions_Fatal( the_source, is_internal, the_error ); _Internal_errors_What_happened.the_source = the_source; 72d8: e59f302c ldr r3, [pc, #44] ; 730c <_Internal_error_Occurred+0x5c><== NOT EXECUTED 72dc: e5834000 str r4, [r3] <== NOT EXECUTED _Internal_errors_What_happened.is_internal = is_internal; 72e0: e5c36004 strb r6, [r3, #4] <== NOT EXECUTED _Internal_errors_What_happened.the_error = the_error; 72e4: e5835008 str r5, [r3, #8] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 72e8: e59f3020 ldr r3, [pc, #32] ; 7310 <_Internal_error_Occurred+0x60><== NOT EXECUTED 72ec: e3a02005 mov r2, #5 <== NOT EXECUTED 72f0: e5832000 str r2, [r3] <== NOT EXECUTED uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 72f4: e10f2000 mrs r2, CPSR <== NOT EXECUTED 72f8: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 72fc: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 7300: e1a00005 mov r0, r5 <== NOT EXECUTED 7304: eafffffe b 7304 <_Internal_error_Occurred+0x54> <== NOT EXECUTED =============================================================================== 00008684 <_RBTree_Sibling>: */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { if(!the_node) return NULL; 8684: e2502000 subs r2, r0, #0 8688: 01a00002 moveq r0, r2 868c: 012fff1e bxeq lr if(!(the_node->parent)) return NULL; 8690: e5923000 ldr r3, [r2] 8694: e3530000 cmp r3, #0 8698: 0a000006 beq 86b8 <_RBTree_Sibling+0x34> if(!(the_node->parent->parent)) return NULL; 869c: e5930000 ldr r0, [r3] 86a0: e3500000 cmp r0, #0 86a4: 012fff1e bxeq lr if(the_node == the_node->parent->child[RBT_LEFT]) 86a8: e5930004 ldr r0, [r3, #4] 86ac: e1520000 cmp r2, r0 return the_node->parent->child[RBT_RIGHT]; 86b0: 05930008 ldreq r0, [r3, #8] 86b4: e12fff1e bx lr RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; 86b8: e1a00003 mov r0, r3 <== NOT EXECUTED if(the_node == the_node->parent->child[RBT_LEFT]) return the_node->parent->child[RBT_RIGHT]; else return the_node->parent->child[RBT_LEFT]; } 86bc: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 00009418 <_Scheduler_CBS_Create_server>: ) { unsigned int i; Scheduler_CBS_Server *the_server; if ( params->budget <= 0 || 9418: e5903004 ldr r3, [r0, #4] 941c: e3530000 cmp r3, #0 int _Scheduler_CBS_Create_server ( Scheduler_CBS_Parameters *params, Scheduler_CBS_Budget_overrun budget_overrun_callback, rtems_id *server_id ) { 9420: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} 9424: e1a04000 mov r4, r0 9428: e1a05001 mov r5, r1 942c: e1a0a002 mov sl, r2 unsigned int i; Scheduler_CBS_Server *the_server; if ( params->budget <= 0 || 9430: da000023 ble 94c4 <_Scheduler_CBS_Create_server+0xac> 9434: e5903000 ldr r3, [r0] 9438: e3530000 cmp r3, #0 943c: da000020 ble 94c4 <_Scheduler_CBS_Create_server+0xac> 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++ ) { 9440: e59f308c ldr r3, [pc, #140] ; 94d4 <_Scheduler_CBS_Create_server+0xbc> 9444: e5932000 ldr r2, [r3] 9448: e59f3088 ldr r3, [pc, #136] ; 94d8 <_Scheduler_CBS_Create_server+0xc0> if ( !_Scheduler_CBS_Server_list[i] ) 944c: e3a06000 mov r6, #0 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++ ) { 9450: e5933000 ldr r3, [r3] 9454: ea00000f b 9498 <_Scheduler_CBS_Create_server+0x80> if ( !_Scheduler_CBS_Server_list[i] ) 9458: e4937004 ldr r7, [r3], #4 945c: e3570000 cmp r7, #0 9460: 1a00000b bne 9494 <_Scheduler_CBS_Create_server+0x7c> if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) 9464: e59f806c ldr r8, [pc, #108] ; 94d8 <_Scheduler_CBS_Create_server+0xc0> } if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; 9468: e58a6000 str r6, [sl] _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); 946c: e3a00010 mov r0, #16 if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) 9470: e5989000 ldr r9, [r8] _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); 9474: eb00071e bl b0f4 <_Workspace_Allocate> if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) 9478: e7890106 str r0, [r9, r6, lsl #2] _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; 947c: e59a2000 ldr r2, [sl] 9480: e5983000 ldr r3, [r8] 9484: e7933102 ldr r3, [r3, r2, lsl #2] if ( !the_server ) 9488: e3530000 cmp r3, #0 948c: 1a000005 bne 94a8 <_Scheduler_CBS_Create_server+0x90> 9490: ea00000d b 94cc <_Scheduler_CBS_Create_server+0xb4> <== NOT EXECUTED 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++ ) { 9494: e2866001 add r6, r6, #1 9498: e1560002 cmp r6, r2 949c: 1affffed bne 9458 <_Scheduler_CBS_Create_server+0x40> if ( !_Scheduler_CBS_Server_list[i] ) break; } if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; 94a0: e3e00019 mvn r0, #25 94a4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; if ( !the_server ) return SCHEDULER_CBS_ERROR_NO_MEMORY; the_server->parameters = *params; 94a8: e8940003 ldm r4, {r0, r1} the_server->task_id = -1; 94ac: e3e02000 mvn r2, #0 _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; if ( !the_server ) return SCHEDULER_CBS_ERROR_NO_MEMORY; the_server->parameters = *params; 94b0: e9830003 stmib r3, {r0, r1} the_server->task_id = -1; 94b4: e5832000 str r2, [r3] the_server->cbs_budget_overrun = budget_overrun_callback; 94b8: e583500c str r5, [r3, #12] return SCHEDULER_CBS_OK; 94bc: e1a00007 mov r0, r7 94c0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} if ( params->budget <= 0 || params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 94c4: e3e00011 mvn r0, #17 94c8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} *server_id = i; _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; if ( !the_server ) return SCHEDULER_CBS_ERROR_NO_MEMORY; 94cc: e3e00010 mvn r0, #16 <== NOT EXECUTED the_server->parameters = *params; the_server->task_id = -1; the_server->cbs_budget_overrun = budget_overrun_callback; return SCHEDULER_CBS_OK; } 94d0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED =============================================================================== 00009844 <_Scheduler_CBS_Initialize>: int _Scheduler_CBS_Initialize(void) { 9844: e92d4010 push {r4, lr} unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( 9848: e59f4050 ldr r4, [pc, #80] ; 98a0 <_Scheduler_CBS_Initialize+0x5c> 984c: e5940000 ldr r0, [r4] 9850: e1a00100 lsl r0, r0, #2 9854: eb000626 bl b0f4 <_Workspace_Allocate> 9858: e59f3044 ldr r3, [pc, #68] ; 98a4 <_Scheduler_CBS_Initialize+0x60> _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) 985c: e3500000 cmp r0, #0 } int _Scheduler_CBS_Initialize(void) { unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( 9860: e5830000 str r0, [r3] 9864: e1a00003 mov r0, r3 _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) return SCHEDULER_CBS_ERROR_NO_MEMORY; for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { 9868: 13a03000 movne r3, #0 986c: 15941000 ldrne r1, [r4] 9870: 11a02003 movne r2, r3 int _Scheduler_CBS_Initialize(void) { unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) 9874: 1a000003 bne 9888 <_Scheduler_CBS_Initialize+0x44> 9878: ea000006 b 9898 <_Scheduler_CBS_Initialize+0x54> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_NO_MEMORY; for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { _Scheduler_CBS_Server_list[i] = NULL; 987c: e590c000 ldr ip, [r0] 9880: e78c2103 str r2, [ip, r3, lsl #2] unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) return SCHEDULER_CBS_ERROR_NO_MEMORY; for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { 9884: e2833001 add r3, r3, #1 9888: e1530001 cmp r3, r1 988c: 1afffffa bne 987c <_Scheduler_CBS_Initialize+0x38> _Scheduler_CBS_Server_list[i] = NULL; } return SCHEDULER_CBS_OK; 9890: e3a00000 mov r0, #0 9894: e8bd8010 pop {r4, pc} { unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) return SCHEDULER_CBS_ERROR_NO_MEMORY; 9898: e3e00010 mvn r0, #16 <== NOT EXECUTED for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { _Scheduler_CBS_Server_list[i] = NULL; } return SCHEDULER_CBS_OK; } 989c: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 00008ae4 <_Thread_queue_Enqueue_priority>: RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 8ae4: e281c03c add ip, r1, #60 ; 0x3c head->next = tail; 8ae8: e581c038 str ip, [r1, #56] ; 0x38 head->previous = NULL; 8aec: e3a0c000 mov ip, #0 8af0: e581c03c str ip, [r1, #60] ; 0x3c Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 8af4: e591c014 ldr ip, [r1, #20] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 8af8: e2813038 add r3, r1, #56 ; 0x38 Thread_blocking_operation_States _Thread_queue_Enqueue_priority ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 8afc: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} head->next = tail; head->previous = NULL; tail->previous = head; 8b00: e5813040 str r3, [r1, #64] ; 0x40 _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 8b04: e3a0500c mov r5, #12 RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number ( Priority_Control the_priority ) { return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER); 8b08: e1a0332c lsr r3, ip, #6 block_state = the_thread_queue->state; if ( _Thread_queue_Is_reverse_search( priority ) ) 8b0c: e31c0020 tst ip, #32 _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 8b10: e0250593 mla r5, r3, r5, r0 block_state = the_thread_queue->state; 8b14: e5908038 ldr r8, [r0, #56] ; 0x38 the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 8b18: 159fa150 ldrne sl, [pc, #336] ; 8c70 <_Thread_queue_Enqueue_priority+0x18c> priority = the_thread->current_priority; header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state; if ( _Thread_queue_Is_reverse_search( priority ) ) 8b1c: 1a000022 bne 8bac <_Thread_queue_Enqueue_priority+0xc8> RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( const Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Immutable_tail( the_chain )); 8b20: e285a004 add sl, r5, #4 uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 8b24: e10f4000 mrs r4, CPSR 8b28: e3843080 orr r3, r4, #128 ; 0x80 8b2c: e129f003 msr CPSR_fc, r3 8b30: e1a06004 mov r6, r4 goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; 8b34: e3e07000 mvn r7, #0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 8b38: e5953000 ldr r3, [r5] _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header ); while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 8b3c: ea00000b b 8b70 <_Thread_queue_Enqueue_priority+0x8c> search_priority = search_thread->current_priority; 8b40: e5937014 ldr r7, [r3, #20] if ( priority <= search_priority ) 8b44: e15c0007 cmp ip, r7 8b48: 9a00000a bls 8b78 <_Thread_queue_Enqueue_priority+0x94> static inline void arm_interrupt_flash( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 8b4c: e10f9000 mrs r9, CPSR 8b50: e129f004 msr CPSR_fc, r4 8b54: e129f009 msr CPSR_fc, r9 RTEMS_INLINE_ROUTINE bool _States_Are_set ( States_Control the_states, States_Control mask ) { return ( (the_states & mask) != STATES_READY); 8b58: e5939010 ldr r9, [r3, #16] search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { 8b5c: e1180009 tst r8, r9 8b60: 1a000001 bne 8b6c <_Thread_queue_Enqueue_priority+0x88> static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 8b64: e129f004 msr CPSR_fc, r4 8b68: eaffffed b 8b24 <_Thread_queue_Enqueue_priority+0x40> _ISR_Enable( level ); goto restart_forward_search; } search_thread = 8b6c: e5933000 ldr r3, [r3] restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header ); while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 8b70: e153000a cmp r3, sl 8b74: 1afffff1 bne 8b40 <_Thread_queue_Enqueue_priority+0x5c> } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 8b78: e5905030 ldr r5, [r0, #48] ; 0x30 8b7c: e3550001 cmp r5, #1 8b80: 1a000037 bne 8c64 <_Thread_queue_Enqueue_priority+0x180> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 8b84: e3a02000 mov r2, #0 if ( priority == search_priority ) 8b88: e15c0007 cmp ip, r7 if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 8b8c: e5802030 str r2, [r0, #48] ; 0x30 if ( priority == search_priority ) 8b90: 0a000029 beq 8c3c <_Thread_queue_Enqueue_priority+0x158> goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 8b94: e5932004 ldr r2, [r3, #4] the_node = (Chain_Node *) the_thread; the_node->next = search_node; 8b98: e5813000 str r3, [r1] the_node->previous = previous_node; 8b9c: e5812004 str r2, [r1, #4] previous_node->next = the_node; 8ba0: e5821000 str r1, [r2] search_node->previous = the_node; 8ba4: e5831004 str r1, [r3, #4] 8ba8: ea000020 b 8c30 <_Thread_queue_Enqueue_priority+0x14c> the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 8bac: e5da7000 ldrb r7, [sl] 8bb0: e2877001 add r7, r7, #1 uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 8bb4: e10f4000 mrs r4, CPSR 8bb8: e3843080 orr r3, r4, #128 ; 0x80 8bbc: e129f003 msr CPSR_fc, r3 8bc0: e1a06004 mov r6, r4 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last( Chain_Control *the_chain ) { return _Chain_Tail( the_chain )->previous; 8bc4: e5953008 ldr r3, [r5, #8] _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_Last( header ); while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 8bc8: ea00000b b 8bfc <_Thread_queue_Enqueue_priority+0x118> search_priority = search_thread->current_priority; 8bcc: e5937014 ldr r7, [r3, #20] if ( priority >= search_priority ) 8bd0: e15c0007 cmp ip, r7 8bd4: 2a00000a bcs 8c04 <_Thread_queue_Enqueue_priority+0x120> static inline void arm_interrupt_flash( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 8bd8: e10f9000 mrs r9, CPSR 8bdc: e129f004 msr CPSR_fc, r4 8be0: e129f009 msr CPSR_fc, r9 8be4: e5939010 ldr r9, [r3, #16] search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { 8be8: e1180009 tst r8, r9 8bec: 1a000001 bne 8bf8 <_Thread_queue_Enqueue_priority+0x114> static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 8bf0: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 8bf4: eaffffec b 8bac <_Thread_queue_Enqueue_priority+0xc8> <== NOT EXECUTED _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) 8bf8: e5933004 ldr r3, [r3, #4] restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_Last( header ); while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 8bfc: e1530005 cmp r3, r5 8c00: 1afffff1 bne 8bcc <_Thread_queue_Enqueue_priority+0xe8> } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 8c04: e5905030 ldr r5, [r0, #48] ; 0x30 8c08: e3550001 cmp r5, #1 8c0c: 1a000014 bne 8c64 <_Thread_queue_Enqueue_priority+0x180> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 8c10: e3a02000 mov r2, #0 if ( priority == search_priority ) 8c14: e15c0007 cmp ip, r7 if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 8c18: e5802030 str r2, [r0, #48] ; 0x30 if ( priority == search_priority ) 8c1c: 0a000006 beq 8c3c <_Thread_queue_Enqueue_priority+0x158> goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 8c20: e5932000 ldr r2, [r3] the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; 8c24: e881000c stm r1, {r2, r3} search_node->next = the_node; 8c28: e5831000 str r1, [r3] next_node->previous = the_node; 8c2c: e5821004 str r1, [r2, #4] the_thread->Wait.queue = the_thread_queue; 8c30: e5810044 str r0, [r1, #68] ; 0x44 8c34: e129f004 msr CPSR_fc, r4 8c38: ea000007 b 8c5c <_Thread_queue_Enqueue_priority+0x178> _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 8c3c: e5932040 ldr r2, [r3, #64] ; 0x40 the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); 8c40: e283c03c add ip, r3, #60 ; 0x3c previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; 8c44: e581c000 str ip, [r1] the_node->previous = previous_node; 8c48: e5812004 str r2, [r1, #4] previous_node->next = the_node; 8c4c: e5821000 str r1, [r2] search_node->previous = the_node; 8c50: e5831040 str r1, [r3, #64] ; 0x40 the_thread->Wait.queue = the_thread_queue; 8c54: e5810044 str r0, [r1, #68] ; 0x44 8c58: e129f006 msr CPSR_fc, r6 _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 8c5c: e3a00001 mov r0, #1 8c60: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 8c64: e5826000 str r6, [r2] return the_thread_queue->sync_state; 8c68: e5900030 ldr r0, [r0, #48] ; 0x30 } 8c6c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} =============================================================================== 00014f84 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 14f84: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} 14f88: e24dd01c sub sp, sp, #28 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 14f8c: e28d8004 add r8, sp, #4 14f90: e28d5010 add r5, sp, #16 head->previous = NULL; 14f94: e3a03000 mov r3, #0 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 14f98: e2889004 add r9, r8, #4 14f9c: e2856004 add r6, r5, #4 14fa0: e58d9004 str r9, [sp, #4] head->previous = NULL; 14fa4: e58d3008 str r3, [sp, #8] tail->previous = head; 14fa8: e58d800c str r8, [sp, #12] ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 14fac: e58d6010 str r6, [sp, #16] head->previous = NULL; 14fb0: e58d3014 str r3, [sp, #20] tail->previous = head; 14fb4: e58d5018 str r5, [sp, #24] 14fb8: e1a04000 mov r4, r0 { /* * Afterwards all timer inserts are directed to this chain and the interval * and TOD chains will be no more modified by other parties. */ ts->insert_chain = insert_chain; 14fbc: e5848078 str r8, [r4, #120] ; 0x78 static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 14fc0: e59f7174 ldr r7, [pc, #372] ; 1513c <_Timer_server_Body+0x1b8> 14fc4: e5973000 ldr r3, [r7] /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 14fc8: e594103c ldr r1, [r4, #60] ; 0x3c watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 14fcc: e2840030 add r0, r4, #48 ; 0x30 14fd0: e0611003 rsb r1, r1, r3 /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; 14fd4: e584303c str r3, [r4, #60] ; 0x3c _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 14fd8: e1a02005 mov r2, r5 14fdc: eb001078 bl 191c4 <_Watchdog_Adjust_to_chain> 14fe0: e59f3158 ldr r3, [pc, #344] ; 15140 <_Timer_server_Body+0x1bc> 14fe4: e59f2158 ldr r2, [pc, #344] ; 15144 <_Timer_server_Body+0x1c0> 14fe8: e8930003 ldm r3, {r0, r1} 14fec: e3a03000 mov r3, #0 14ff0: eb004b3d bl 27cec <__divdi3> Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 14ff4: e5942074 ldr r2, [r4, #116] ; 0x74 /* * Process the seconds chain. Start by checking that the Time * of Day (TOD) has not been set backwards. If it has then * we want to adjust the watchdogs->Chain to indicate this. */ if ( snapshot > last_snapshot ) { 14ff8: e1500002 cmp r0, r2 14ffc: e1a0a000 mov sl, r0 15000: 9a000004 bls 15018 <_Timer_server_Body+0x94> /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 15004: e062100a rsb r1, r2, sl 15008: e2840068 add r0, r4, #104 ; 0x68 1500c: e1a02005 mov r2, r5 15010: eb00106b bl 191c4 <_Watchdog_Adjust_to_chain> 15014: ea000003 b 15028 <_Timer_server_Body+0xa4> /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ delta = last_snapshot - snapshot; _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 15018: 32840068 addcc r0, r4, #104 ; 0x68 1501c: 33a01001 movcc r1, #1 15020: 306a2002 rsbcc r2, sl, r2 15024: 3b00103e blcc 19124 <_Watchdog_Adjust> } watchdogs->last_snapshot = snapshot; 15028: e584a074 str sl, [r4, #116] ; 0x74 ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 1502c: e284b068 add fp, r4, #104 ; 0x68 Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 15030: e284a030 add sl, r4, #48 ; 0x30 } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 15034: e5940078 ldr r0, [r4, #120] ; 0x78 15038: eb0002aa bl 15ae8 <_Chain_Get> if ( timer == NULL ) { 1503c: e2501000 subs r1, r0, #0 15040: 0a000009 beq 1506c <_Timer_server_Body+0xe8> static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 15044: e5913038 ldr r3, [r1, #56] ; 0x38 15048: e3530001 cmp r3, #1 _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 1504c: 01a0000a moveq r0, sl static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 15050: 0a000002 beq 15060 <_Timer_server_Body+0xdc> _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 15054: e3530003 cmp r3, #3 15058: 1afffff5 bne 15034 <_Timer_server_Body+0xb0> _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 1505c: e1a0000b mov r0, fp 15060: e2811010 add r1, r1, #16 15064: eb00107b bl 19258 <_Watchdog_Insert> 15068: eafffff1 b 15034 <_Timer_server_Body+0xb0> * of zero it will be processed in the next iteration of the timer server * body loop. */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); 1506c: e58d1000 str r1, [sp] 15070: ebffff97 bl 14ed4 if ( _Chain_Is_empty( insert_chain ) ) { 15074: e59d3004 ldr r3, [sp, #4] 15078: e1530009 cmp r3, r9 1507c: e59d1000 ldr r1, [sp] 15080: 1a000006 bne 150a0 <_Timer_server_Body+0x11c> ts->insert_chain = NULL; 15084: e5841078 str r1, [r4, #120] ; 0x78 15088: e129f000 msr CPSR_fc, r0 _Chain_Initialize_empty( &fire_chain ); while ( true ) { _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain ); if ( !_Chain_Is_empty( &fire_chain ) ) { 1508c: e59d3010 ldr r3, [sp, #16] 15090: e1530006 cmp r3, r6 * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; 15094: 13a07000 movne r7, #0 _Chain_Initialize_empty( &fire_chain ); while ( true ) { _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain ); if ( !_Chain_Is_empty( &fire_chain ) ) { 15098: 1a000002 bne 150a8 <_Timer_server_Body+0x124> 1509c: ea000011 b 150e8 <_Timer_server_Body+0x164> 150a0: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 150a4: eaffffc6 b 14fc4 <_Timer_server_Body+0x40> <== NOT EXECUTED /* * It is essential that interrupts are disable here since an interrupt * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); 150a8: ebffff89 bl 14ed4 */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 150ac: e59d3010 ldr r3, [sp, #16] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 150b0: e1530006 cmp r3, r6 150b4: 0a000009 beq 150e0 <_Timer_server_Body+0x15c> Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 150b8: e5932000 ldr r2, [r3] head->next = new_first; new_first->previous = head; 150bc: e5825004 str r5, [r2, #4] { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; head->next = new_first; 150c0: e58d2010 str r2, [sp, #16] watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; 150c4: e5837008 str r7, [r3, #8] 150c8: e129f000 msr CPSR_fc, r0 /* * The timer server may block here and wait for resources or time. * The system watchdogs are inactive and will remain inactive since * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); 150cc: e2830020 add r0, r3, #32 150d0: e8900003 ldm r0, {r0, r1} 150d4: e1a0e00f mov lr, pc 150d8: e593f01c ldr pc, [r3, #28] } 150dc: eafffff1 b 150a8 <_Timer_server_Body+0x124> 150e0: e129f000 msr CPSR_fc, r0 150e4: eaffffb4 b 14fbc <_Timer_server_Body+0x38> } else { ts->active = false; 150e8: e3a03000 mov r3, #0 150ec: e5c4307c strb r3, [r4, #124] ; 0x7c * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 150f0: e59f3050 ldr r3, [pc, #80] ; 15148 <_Timer_server_Body+0x1c4> 150f4: e5932000 ldr r2, [r3] ++level; 150f8: e2822001 add r2, r2, #1 _Thread_Dispatch_disable_level = level; 150fc: e5832000 str r2, [r3] /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( ts->thread, STATES_DELAYING ); 15100: e3a01008 mov r1, #8 15104: e5940000 ldr r0, [r4] 15108: eb000f2e bl 18dc8 <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 1510c: e1a00004 mov r0, r4 15110: ebffff73 bl 14ee4 <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 15114: e1a00004 mov r0, r4 15118: ebffff85 bl 14f34 <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 1511c: eb000d06 bl 1853c <_Thread_Enable_dispatch> ts->active = true; 15120: e3a03001 mov r3, #1 15124: e5c4307c strb r3, [r4, #124] ; 0x7c static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 15128: e2840008 add r0, r4, #8 1512c: eb0010a0 bl 193b4 <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 15130: e2840040 add r0, r4, #64 ; 0x40 15134: eb00109e bl 193b4 <_Watchdog_Remove> 15138: eaffff9f b 14fbc <_Timer_server_Body+0x38> =============================================================================== 00008fe8 <_User_extensions_Thread_exitted_visitor>: Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { User_extensions_thread_exitted_extension callout = callouts->thread_exitted; 8fe8: e5923018 ldr r3, [r2, #24] if ( callout != NULL ) { 8fec: e3530000 cmp r3, #0 void _User_extensions_Thread_exitted_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 8ff0: e52de004 push {lr} ; (str lr, [sp, #-4]!) User_extensions_thread_exitted_extension callout = callouts->thread_exitted; if ( callout != NULL ) { 8ff4: 049df004 popeq {pc} ; (ldreq pc, [sp], #4) (*callout)( executing ); 8ff8: e1a0e00f mov lr, pc 8ffc: e12fff13 bx r3 9000: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 00007064 : return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { 7064: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} void *ptr = NULL; rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; uintptr_t alignment = control->alignment; 7068: e5906030 ldr r6, [r0, #48] ; 0x30 return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { 706c: e1a05001 mov r5, r1 7070: e1a04000 mov r4, r0 #include static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; 7074: e1a00001 mov r0, r1 7078: e1a01006 mov r1, r6 707c: eb003f17 bl 16ce0 <__umodsi3> if (excess > 0) { 7080: e3500000 cmp r0, #0 value += alignment - excess; 7084: 10856006 addne r6, r5, r6 7088: 10606006 rsbne r6, r0, r6 static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; if (excess > 0) { 708c: 01a06005 moveq r6, r5 rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; uintptr_t alignment = control->alignment; uintptr_t aligned_size = align_up(alignment, size); if (size > 0 && size <= aligned_size) { 7090: e1550006 cmp r5, r6 7094: 83a00000 movhi r0, #0 7098: 93a00001 movls r0, #1 709c: e3550000 cmp r5, #0 70a0: 03a00000 moveq r0, #0 70a4: e3500000 cmp r0, #0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 70a8: 11a02004 movne r2, r4 70ac: 14923004 ldrne r3, [r2], #4 size_t size ) { rtems_chain_node *current = rtems_chain_first(free_chain); const rtems_chain_node *tail = rtems_chain_tail(free_chain); rtems_rbheap_chunk *big_enough = NULL; 70b0: 13a07000 movne r7, #0 rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; uintptr_t alignment = control->alignment; uintptr_t aligned_size = align_up(alignment, size); if (size > 0 && size <= aligned_size) { 70b4: 1a000005 bne 70d0 70b8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} rtems_rbheap_chunk *big_enough = NULL; while (current != tail && big_enough == NULL) { rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current; if (free_chunk->size >= size) { 70bc: e593701c ldr r7, [r3, #28] 70c0: e1570006 cmp r7, r6 70c4: 21a07003 movcs r7, r3 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next( Chain_Node *the_node ) { return the_node->next; 70c8: e5933000 ldr r3, [r3] 70cc: 33a07000 movcc r7, #0 { rtems_chain_node *current = rtems_chain_first(free_chain); const rtems_chain_node *tail = rtems_chain_tail(free_chain); rtems_rbheap_chunk *big_enough = NULL; while (current != tail && big_enough == NULL) { 70d0: e2778001 rsbs r8, r7, #1 70d4: 33a08000 movcc r8, #0 70d8: e1530002 cmp r3, r2 70dc: 03a08000 moveq r8, #0 70e0: e3580000 cmp r8, #0 70e4: 1afffff4 bne 70bc uintptr_t aligned_size = align_up(alignment, size); if (size > 0 && size <= aligned_size) { rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size); if (free_chunk != NULL) { 70e8: e3570000 cmp r7, #0 return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { void *ptr = NULL; 70ec: 01a00007 moveq r0, r7 uintptr_t aligned_size = align_up(alignment, size); if (size > 0 && size <= aligned_size) { rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size); if (free_chunk != NULL) { 70f0: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc} uintptr_t free_size = free_chunk->size; 70f4: e597901c ldr r9, [r7, #28] if (free_size > aligned_size) { 70f8: e1590006 cmp r9, r6 70fc: 9a00001f bls 7180 */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 7100: e1a0a004 mov sl, r4 7104: e5ba500c ldr r5, [sl, #12]! RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 7108: e2843010 add r3, r4, #16 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 710c: e1550003 cmp r5, r3 Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 7110: 15953000 ldrne r3, [r5] head->next = new_first; 7114: 1584300c strne r3, [r4, #12] new_first->previous = head; 7118: 1583a004 strne sl, [r3, #4] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 711c: 1a000009 bne 7148 { rtems_chain_control *chain = &control->spare_descriptor_chain; rtems_chain_node *chunk = rtems_chain_get_unprotected(chain); if (chunk == NULL) { (*control->extend_descriptors)(control); 7120: e1a00004 mov r0, r4 <== NOT EXECUTED 7124: e1a0e00f mov lr, pc <== NOT EXECUTED 7128: e594f034 ldr pc, [r4, #52] ; 0x34 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 712c: e594300c ldr r3, [r4, #12] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 7130: e1530005 cmp r3, r5 <== NOT EXECUTED 7134: 0a000018 beq 719c <== NOT EXECUTED Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 7138: e5932000 ldr r2, [r3] <== NOT EXECUTED head->next = new_first; 713c: e584200c str r2, [r4, #12] <== NOT EXECUTED new_first->previous = head; 7140: e582a004 str sl, [r2, #4] <== NOT EXECUTED 7144: e1a05003 mov r5, r3 <== NOT EXECUTED if (new_chunk != NULL) { uintptr_t new_free_size = free_size - aligned_size; free_chunk->size = new_free_size; new_chunk->begin = free_chunk->begin + new_free_size; 7148: e5973018 ldr r3, [r7, #24] if (free_size > aligned_size) { rtems_rbheap_chunk *new_chunk = get_chunk(control); if (new_chunk != NULL) { uintptr_t new_free_size = free_size - aligned_size; 714c: e0669009 rsb r9, r6, r9 free_chunk->size = new_free_size; 7150: e587901c str r9, [r7, #28] */ RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain( Chain_Node *node ) { node->next = node->previous = NULL; 7154: e1a01005 mov r1, r5 new_chunk->begin = free_chunk->begin + new_free_size; 7158: e0899003 add r9, r9, r3 715c: e3a03000 mov r3, #0 7160: e5859018 str r9, [r5, #24] new_chunk->size = aligned_size; 7164: e585601c str r6, [r5, #28] 7168: e5853004 str r3, [r5, #4] 716c: e4813008 str r3, [r1], #8 static void insert_into_tree( rtems_rbtree_control *tree, rtems_rbheap_chunk *chunk ) { _RBTree_Insert_unprotected(tree, &chunk->tree_node); 7170: e2840018 add r0, r4, #24 7174: eb000648 bl 8a9c <_RBTree_Insert_unprotected> free_chunk->size = new_free_size; new_chunk->begin = free_chunk->begin + new_free_size; new_chunk->size = aligned_size; rtems_chain_set_off_chain(&new_chunk->chain_node); insert_into_tree(chunk_tree, new_chunk); ptr = (void *) new_chunk->begin; 7178: e5950018 ldr r0, [r5, #24] 717c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 7180: e897000c ldm r7, {r2, r3} } } else { rtems_chain_extract_unprotected(&free_chunk->chain_node); rtems_chain_set_off_chain(&free_chunk->chain_node); ptr = (void *) free_chunk->begin; 7184: e5970018 ldr r0, [r7, #24] next->previous = previous; 7188: e5823004 str r3, [r2, #4] previous->next = next; 718c: e5832000 str r2, [r3] */ RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain( Chain_Node *node ) { node->next = node->previous = NULL; 7190: e5878004 str r8, [r7, #4] 7194: e5878000 str r8, [r7] 7198: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { void *ptr = NULL; 719c: e1a00008 mov r0, r8 <== NOT EXECUTED } } } return ptr; } 71a0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED =============================================================================== 00007328 : void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control) { 7328: e92d4010 push {r4, lr} <== NOT EXECUTED 732c: e1a04000 mov r4, r0 <== NOT EXECUTED rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk)); 7330: e3a00020 mov r0, #32 <== NOT EXECUTED 7334: ebffeea1 bl 2dc0 <== NOT EXECUTED if (chunk != NULL) { 7338: e3500000 cmp r0, #0 <== NOT EXECUTED 733c: 08bd8010 popeq {r4, pc} <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert_unprotected(_Chain_Head(the_chain), the_node); 7340: e284300c add r3, r4, #12 <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 7344: e5803004 str r3, [r0, #4] <== NOT EXECUTED before_node = after_node->next; 7348: e594300c ldr r3, [r4, #12] <== NOT EXECUTED after_node->next = the_node; 734c: e584000c str r0, [r4, #12] <== NOT EXECUTED the_node->next = before_node; before_node->previous = the_node; 7350: e5830004 str r0, [r3, #4] <== NOT EXECUTED Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; 7354: e5803000 str r3, [r0] <== NOT EXECUTED 7358: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 000071a4 : _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) { 71a4: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} rtems_status_code sc = RTEMS_SUCCESSFUL; if (ptr != NULL) { 71a8: e2516000 subs r6, r1, #0 _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) { 71ac: e24dd020 sub sp, sp, #32 71b0: e1a05000 mov r5, r0 rtems_status_code sc = RTEMS_SUCCESSFUL; if (ptr != NULL) { 71b4: 0a000057 beq 7318 #define NULL_PAGE rtems_rbheap_chunk_of_node(NULL) static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key) { rtems_rbheap_chunk chunk = { .begin = key }; 71b8: e1a0000d mov r0, sp 71bc: e3a01000 mov r1, #0 71c0: e3a02020 mov r2, #32 RBTree_Control *the_rbtree, RBTree_Node *the_node ) { RBTree_Node* iter_node = the_rbtree->root; RBTree_Node* found = NULL; 71c4: e3a04000 mov r4, #0 71c8: eb001cfd bl e5c4 return rtems_rbheap_chunk_of_node( 71cc: e08d3004 add r3, sp, r4 #define NULL_PAGE rtems_rbheap_chunk_of_node(NULL) static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key) { rtems_rbheap_chunk chunk = { .begin = key }; 71d0: e58d6018 str r6, [sp, #24] return rtems_rbheap_chunk_of_node( 71d4: e2837008 add r7, r3, #8 RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { RBTree_Node* iter_node = the_rbtree->root; 71d8: e595601c ldr r6, [r5, #28] 71dc: ea00000d b 7218 RBTree_Node* found = NULL; int compare_result; while (iter_node) { compare_result = the_rbtree->compare_function(the_node, iter_node); 71e0: e1a00007 mov r0, r7 71e4: e1a01006 mov r1, r6 71e8: e1a0e00f mov lr, pc 71ec: e595f028 ldr pc, [r5, #40] ; 0x28 if ( _RBTree_Is_equal( compare_result ) ) { 71f0: e3500000 cmp r0, #0 71f4: 1a000003 bne 7208 found = iter_node; if ( the_rbtree->is_unique ) 71f8: e5d5302c ldrb r3, [r5, #44] ; 0x2c 71fc: e3530000 cmp r3, #0 7200: 1a000007 bne 7224 7204: e1a04006 mov r4, r6 <== NOT EXECUTED break; } RBTree_Direction dir = (RBTree_Direction) _RBTree_Is_greater( compare_result ); iter_node = iter_node->child[dir]; 7208: e3500000 cmp r0, #0 720c: c3a00008 movgt r0, #8 7210: d3a00004 movle r0, #4 7214: e7906006 ldr r6, [r0, r6] ) { RBTree_Node* iter_node = the_rbtree->root; RBTree_Node* found = NULL; int compare_result; while (iter_node) { 7218: e3560000 cmp r6, #0 721c: 1affffef bne 71e0 7220: e1a06004 mov r6, r4 7224: e2464008 sub r4, r6, #8 if (ptr != NULL) { rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr); if (chunk != NULL_PAGE) { 7228: e3740008 cmn r4, #8 check_and_merge(free_chain, chunk_tree, chunk, pred); } else { sc = RTEMS_INCORRECT_STATE; } } else { sc = RTEMS_INVALID_ID; 722c: 03a06004 moveq r6, #4 if (ptr != NULL) { rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr); if (chunk != NULL_PAGE) { 7230: 0a000038 beq 7318 */ RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain( const Chain_Node *node ) { return (node->next == NULL) && (node->previous == NULL); 7234: e5163008 ldr r3, [r6, #-8] 7238: e3530000 cmp r3, #0 723c: 13a0a000 movne sl, #0 7240: 1a000002 bne 7250 add_to_chain(free_chain, b); _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) 7244: e594a004 ldr sl, [r4, #4] 7248: e27aa001 rsbs sl, sl, #1 724c: 33a0a000 movcc sl, #0 rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr); if (chunk != NULL_PAGE) { if (!rtems_rbheap_is_chunk_free(chunk)) { 7250: e23aa001 eors sl, sl, #1 check_and_merge(free_chain, chunk_tree, chunk, succ); add_to_chain(free_chain, chunk); check_and_merge(free_chain, chunk_tree, chunk, pred); } else { sc = RTEMS_INCORRECT_STATE; 7254: 13a0600e movne r6, #14 rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr); if (chunk != NULL_PAGE) { if (!rtems_rbheap_is_chunk_free(chunk)) { 7258: 1a00002e bne 7318 static rtems_rbheap_chunk *get_next( const rtems_rbheap_chunk *chunk, RBTree_Direction dir ) { return rtems_rbheap_chunk_of_node( 725c: e2849008 add r9, r4, #8 7260: e1a0100a mov r1, sl 7264: e1a00009 mov r0, r9 7268: eb000690 bl 8cb0 <_RBTree_Next_unprotected> 726c: e3a01001 mov r1, #1 7270: e1a06000 mov r6, r0 7274: e2408008 sub r8, r0, #8 7278: e1a00009 mov r0, r9 727c: eb00068b bl 8cb0 <_RBTree_Next_unprotected> 7280: e2403008 sub r3, r0, #8 rtems_rbtree_control *chunk_tree, rtems_rbheap_chunk *a, rtems_rbheap_chunk *b ) { if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) { 7284: e3730008 cmn r3, #8 { rtems_status_code sc = RTEMS_SUCCESSFUL; if (ptr != NULL) { rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; 7288: e2857018 add r7, r5, #24 rtems_rbtree_control *chunk_tree, rtems_rbheap_chunk *a, rtems_rbheap_chunk *b ) { if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) { 728c: 0a00000a beq 72bc 7290: e5102008 ldr r2, [r0, #-8] 7294: e3520000 cmp r2, #0 7298: 1a000002 bne 72a8 add_to_chain(free_chain, b); _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) 729c: e510a004 ldr sl, [r0, #-4] 72a0: e27aa001 rsbs sl, sl, #1 72a4: 33a0a000 movcc sl, #0 rtems_rbtree_control *chunk_tree, rtems_rbheap_chunk *a, rtems_rbheap_chunk *b ) { if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) { 72a8: e35a0000 cmp sl, #0 72ac: 01a00005 moveq r0, r5 72b0: 01a01007 moveq r1, r7 72b4: 01a02004 moveq r2, r4 72b8: 0bffff08 bleq 6ee0 ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 72bc: e5953000 ldr r3, [r5] 72c0: e3780008 cmn r8, #8 Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 72c4: e5845004 str r5, [r4, #4] before_node = after_node->next; after_node->next = the_node; 72c8: e5854000 str r4, [r5] the_node->next = before_node; before_node->previous = the_node; 72cc: e5834004 str r4, [r3, #4] Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; 72d0: e5843000 str r3, [r4] 72d4: 0a00000e beq 7314 */ RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain( const Chain_Node *node ) { return (node->next == NULL) && (node->previous == NULL); 72d8: e5163008 ldr r3, [r6, #-8] 72dc: e3530000 cmp r3, #0 72e0: 13a06000 movne r6, #0 72e4: 1a000002 bne 72f4 add_to_chain(free_chain, b); _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) 72e8: e5166004 ldr r6, [r6, #-4] 72ec: e2766001 rsbs r6, r6, #1 72f0: 33a06000 movcc r6, #0 rtems_rbtree_control *chunk_tree, rtems_rbheap_chunk *a, rtems_rbheap_chunk *b ) { if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) { 72f4: e21660ff ands r6, r6, #255 ; 0xff 72f8: 1a000005 bne 7314 72fc: e1a00005 mov r0, r5 7300: e1a01007 mov r1, r7 7304: e1a02004 mov r2, r4 7308: e1a03008 mov r3, r8 730c: ebfffef3 bl 6ee0 7310: ea000000 b 7318 } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) { rtems_status_code sc = RTEMS_SUCCESSFUL; 7314: e3a06000 mov r6, #0 sc = RTEMS_INVALID_ID; } } return sc; } 7318: e1a00006 mov r0, r6 731c: e28dd020 add sp, sp, #32 7320: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}