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 <arm_interrupt_disable>
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 <arm_interrupt_disable>
*/
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 <rtems_rbheap_allocate>:
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 <stdlib.h>
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 <rtems_rbheap_allocate+0x6c>
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 <rtems_rbheap_allocate+0x58>
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_rbheap_allocate+0x11c>
*/
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_rbheap_allocate+0xe4>
{
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 <rtems_rbheap_allocate+0x138> <== 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 <rtems_rbheap_extend_descriptors_with_malloc>:
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 <malloc> <== 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 <rtems_rbheap_free>:
_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 <rtems_rbheap_free+0x174>
#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 <memset>
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 <rtems_rbheap_free+0x74>
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 <rtems_rbheap_free+0x64>
found = iter_node;
if ( the_rbtree->is_unique )
71f8: e5d5302c ldrb r3, [r5, #44] ; 0x2c
71fc: e3530000 cmp r3, #0
7200: 1a000007 bne 7224 <rtems_rbheap_free+0x80>
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 <rtems_rbheap_free+0x3c>
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_rbheap_free+0x174>
*/
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 <rtems_rbheap_free+0xac>
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 <rtems_rbheap_free+0x174>
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 <rtems_rbheap_free+0x118>
7290: e5102008 ldr r2, [r0, #-8]
7294: e3520000 cmp r2, #0
7298: 1a000002 bne 72a8 <rtems_rbheap_free+0x104>
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 <check_and_merge.part.1>
)
{
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_rbheap_free+0x170>
*/
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 <rtems_rbheap_free+0x150>
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 <rtems_rbheap_free+0x170>
72fc: e1a00005 mov r0, r5
7300: e1a01007 mov r1, r7
7304: e1a02004 mov r2, r4
7308: e1a03008 mov r3, r8
730c: ebfffef3 bl 6ee0 <check_and_merge.part.1>
7310: ea000000 b 7318 <rtems_rbheap_free+0x174>
}
}
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}