00014b0c <_CORE_message_queue_Broadcast>:
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
14b0c: e590304c ldr r3, [r0, #76] ; 0x4c
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
14b10: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
14b14: e1520003 cmp r2, r3
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
14b18: e1a06000 mov r6, r0 14b1c: e1a0a001 mov sl, r1 14b20: e1a07002 mov r7, r2 14b24: e59d8020 ldr r8, [sp, #32]
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
14b28: 8a000013 bhi 14b7c <_CORE_message_queue_Broadcast+0x70>
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
14b2c: e5905048 ldr r5, [r0, #72] ; 0x48 14b30: e3550000 cmp r5, #0
*count = 0;
14b34: 13a00000 movne r0, #0 14b38: 15880000 strne r0, [r8]
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
14b3c: 0a000007 beq 14b60 <_CORE_message_queue_Broadcast+0x54>
14b40: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
14b44: e594002c ldr r0, [r4, #44] ; 0x2c 14b48: e1a0100a mov r1, sl 14b4c: e1a02007 mov r2, r7 14b50: eb001e40 bl 1c458 <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
14b54: e5943028 ldr r3, [r4, #40] ; 0x28 14b58: e5837000 str r7, [r3]
*/
number_broadcasted = 0;
while ((the_thread =
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
14b5c: e2855001 add r5, r5, #1
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
14b60: e1a00006 mov r0, r6 14b64: eb000a41 bl 17470 <_Thread_queue_Dequeue> 14b68: e2504000 subs r4, r0, #0
14b6c: 1afffff4 bne 14b44 <_CORE_message_queue_Broadcast+0x38>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
14b70: e5885000 str r5, [r8]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
14b74: e1a00004 mov r0, r4
14b78: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
14b7c: e3a00001 mov r0, #1 <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
14b80: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
00009e78 <_CORE_mutex_Seize_interrupt_trylock>:
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
9e78: e1a03000 mov r3, r0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
9e7c: e59f2124 ldr r2, [pc, #292] ; 9fa8 <_CORE_mutex_Seize_interrupt_trylock+0x130>
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
9e80: e593c050 ldr ip, [r3, #80] ; 0x50
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
9e84: e3a00000 mov r0, #0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
9e88: e5922004 ldr r2, [r2, #4]
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
9e8c: e15c0000 cmp ip, r0
9e90: e92d4010 push {r4, lr}
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
9e94: e5820034 str r0, [r2, #52] ; 0x34
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
9e98: 0a00002c beq 9f50 <_CORE_mutex_Seize_interrupt_trylock+0xd8>
the_mutex->lock = CORE_MUTEX_LOCKED;
9e9c: e5830050 str r0, [r3, #80] ; 0x50
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
9ea0: e5920008 ldr r0, [r2, #8]
9ea4: e5830060 str r0, [r3, #96] ; 0x60
the_mutex->nest_count = 1;
9ea8: e3a00001 mov r0, #1
9eac: e5830054 str r0, [r3, #84] ; 0x54
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); }
9eb0: e5930048 ldr r0, [r3, #72] ; 0x48
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
9eb4: e3500002 cmp r0, #2
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
9eb8: e583205c str r2, [r3, #92] ; 0x5c
the_mutex->holder_id = executing->Object.id;
the_mutex->nest_count = 1;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
9ebc: 0a000001 beq 9ec8 <_CORE_mutex_Seize_interrupt_trylock+0x50>
9ec0: e3500003 cmp r0, #3
9ec4: 1a000004 bne 9edc <_CORE_mutex_Seize_interrupt_trylock+0x64>
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
9ec8: e592c01c ldr ip, [r2, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
9ecc: e3500003 cmp r0, #3
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
9ed0: e28c4001 add r4, ip, #1
9ed4: e582401c str r4, [r2, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
9ed8: 0a000000 beq 9ee0 <_CORE_mutex_Seize_interrupt_trylock+0x68>
_ISR_Enable( *level_p );
9edc: ea00002b b 9f90 <_CORE_mutex_Seize_interrupt_trylock+0x118>
*/
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
9ee0: e593004c ldr r0, [r3, #76] ; 0x4c
current = executing->current_priority;
9ee4: e5924014 ldr r4, [r2, #20]
if ( current == ceiling ) {
9ee8: e1540000 cmp r4, r0
9eec: 1a000000 bne 9ef4 <_CORE_mutex_Seize_interrupt_trylock+0x7c>
_ISR_Enable( *level_p );
9ef0: ea000026 b 9f90 <_CORE_mutex_Seize_interrupt_trylock+0x118>
return 0;
}
if ( current > ceiling ) {
9ef4: 9a00000b bls 9f28 <_CORE_mutex_Seize_interrupt_trylock+0xb0>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
9ef8: e59f20ac ldr r2, [pc, #172] ; 9fac <_CORE_mutex_Seize_interrupt_trylock+0x134>
9efc: e5920000 ldr r0, [r2]
9f00: e2800001 add r0, r0, #1
9f04: e5820000 str r0, [r2]
9f08: e5912000 ldr r2, [r1]
9f0c: e129f002 msr CPSR_fc, r2
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
_Thread_Change_priority(
9f10: e3a02000 mov r2, #0
9f14: e593005c ldr r0, [r3, #92] ; 0x5c
9f18: e593104c ldr r1, [r3, #76] ; 0x4c
9f1c: ebfff333 bl 6bf0 <_Thread_Change_priority>
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
9f20: ebfff457 bl 7084 <_Thread_Enable_dispatch>
9f24: ea00001b b 9f98 <_CORE_mutex_Seize_interrupt_trylock+0x120>
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
9f28: e3a00006 mov r0, #6
9f2c: e5820034 str r0, [r2, #52] ; 0x34
the_mutex->lock = CORE_MUTEX_UNLOCKED;
9f30: e3a00001 mov r0, #1
9f34: e5830050 str r0, [r3, #80] ; 0x50
the_mutex->nest_count = 0; /* undo locking above */
9f38: e3a00000 mov r0, #0
9f3c: e5830054 str r0, [r3, #84] ; 0x54
executing->resource_count--; /* undo locking above */
9f40: e582c01c str ip, [r2, #28]
9f44: e5913000 ldr r3, [r1]
9f48: e129f003 msr CPSR_fc, r3
9f4c: e8bd8010 pop {r4, pc}
/*
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
9f50: e593005c ldr r0, [r3, #92] ; 0x5c
9f54: e1500002 cmp r0, r2
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
9f58: 13a00001 movne r0, #1
/*
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
9f5c: 18bd8010 popne {r4, pc}
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
9f60: e5932040 ldr r2, [r3, #64] ; 0x40
9f64: e3520000 cmp r2, #0
9f68: 0a000002 beq 9f78 <_CORE_mutex_Seize_interrupt_trylock+0x100>
9f6c: e3520001 cmp r2, #1
9f70: 1a00000a bne 9fa0 <_CORE_mutex_Seize_interrupt_trylock+0x128>
9f74: ea000003 b 9f88 <_CORE_mutex_Seize_interrupt_trylock+0x110><== NOT EXECUTED
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
9f78: e5932054 ldr r2, [r3, #84] ; 0x54
9f7c: e2822001 add r2, r2, #1
9f80: e5832054 str r2, [r3, #84] ; 0x54
_ISR_Enable( *level_p );
9f84: ea000001 b 9f90 <_CORE_mutex_Seize_interrupt_trylock+0x118>
return 0;
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
9f88: e3a03002 mov r3, #2 <== NOT EXECUTED
9f8c: e5803034 str r3, [r0, #52] ; 0x34 <== NOT EXECUTED
9f90: e5913000 ldr r3, [r1]
9f94: e129f003 msr CPSR_fc, r3
_ISR_Enable( *level_p );
return 0;
9f98: e3a00000 mov r0, #0
9f9c: e8bd8010 pop {r4, pc}
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
9fa0: e3a00001 mov r0, #1
9fa4: e8bd8010 pop {r4, pc}
0000a530 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
a530: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
a534: e1a05001 mov r5, r1
Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block;
a538: e5901020 ldr r1, [r0, #32]
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
a53c: e24dd028 sub sp, sp, #40 ; 0x28
a540: e58d3018 str r3, [sp, #24]
Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block;
a544: e58d1010 str r1, [sp, #16]
Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size;
a548: e5903010 ldr r3, [r0, #16]
uintptr_t const min_block_size = heap->min_block_size; uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; uintptr_t const free_size = stats->free_size;
a54c: e5901030 ldr r1, [r0, #48] ; 0x30
Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL;
a550: e3a08000 mov r8, #0
uintptr_t const free_size = stats->free_size;
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
a554: e0956002 adds r6, r5, r2
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
a558: e1a04000 mov r4, r0
Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size;
a55c: e58d3014 str r3, [sp, #20]
Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL;
a560: e58d8024 str r8, [sp, #36] ; 0x24
Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size;
a564: e5903014 ldr r3, [r0, #20]
Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL;
a568: e58d8020 str r8, [sp, #32]
uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; uintptr_t const free_size = stats->free_size;
a56c: e58d101c str r1, [sp, #28]
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
return false;
a570: 21a00008 movcs r0, r8
uintptr_t const free_size = stats->free_size;
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
a574: 2a00009d bcs a7f0 <_Heap_Extend+0x2c0>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
a578: e28d1024 add r1, sp, #36 ; 0x24
a57c: e58d1000 str r1, [sp]
a580: e28d1020 add r1, sp, #32
a584: e58d1004 str r1, [sp, #4]
a588: e1a00005 mov r0, r5
a58c: e1a01002 mov r1, r2
a590: e59d2014 ldr r2, [sp, #20]
a594: ebffeeda bl 6104 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
a598: e3500000 cmp r0, #0
a59c: 0a000093 beq a7f0 <_Heap_Extend+0x2c0>
a5a0: e59da010 ldr sl, [sp, #16]
a5a4: e1a07008 mov r7, r8
a5a8: e1a09008 mov r9, r8
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
a5ac: e5941018 ldr r1, [r4, #24]
a5b0: e1a03008 mov r3, r8
a5b4: e1a0c004 mov ip, r4
a5b8: ea000000 b a5c0 <_Heap_Extend+0x90>
a5bc: e1a0100a mov r1, sl
uintptr_t const sub_area_end = start_block->prev_size;
a5c0: e59a4000 ldr r4, [sl]
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
a5c4: e1560001 cmp r6, r1
a5c8: 93a00000 movls r0, #0
a5cc: 83a00001 movhi r0, #1
a5d0: e1550004 cmp r5, r4
a5d4: 23a00000 movcs r0, #0
a5d8: e3500000 cmp r0, #0
a5dc: 1a000082 bne a7ec <_Heap_Extend+0x2bc>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
a5e0: e1560001 cmp r6, r1
a5e4: 01a0300a moveq r3, sl
a5e8: 0a000001 beq a5f4 <_Heap_Extend+0xc4>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
a5ec: e1560004 cmp r6, r4
a5f0: 31a0900a movcc r9, sl
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
a5f4: e1a00004 mov r0, r4
a5f8: e59d1014 ldr r1, [sp, #20]
a5fc: e58d300c str r3, [sp, #12]
a600: e58dc008 str ip, [sp, #8]
a604: eb001531 bl fad0 <__umodsi3>
a608: e244b008 sub fp, r4, #8
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
a60c: e1540005 cmp r4, r5
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
a610: e060000b rsb r0, r0, fp
a614: e59d300c ldr r3, [sp, #12]
a618: e59dc008 ldr ip, [sp, #8]
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area(
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
a61c: 01a07000 moveq r7, r0
start_block->prev_size = extend_area_end;
a620: 058a6000 streq r6, [sl]
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
a624: 0a000000 beq a62c <_Heap_Extend+0xfc>
a628: 31a08000 movcc r8, r0
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
a62c: e590a004 ldr sl, [r0, #4]
} else if ( sub_area_end < extend_area_begin ) {
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
a630: e59d2010 ldr r2, [sp, #16]
a634: e3caa001 bic sl, sl, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
a638: e080a00a add sl, r0, sl
a63c: e15a0002 cmp sl, r2
a640: 1affffdd bne a5bc <_Heap_Extend+0x8c>
a644: e1a02009 mov r2, r9
a648: e1a09003 mov r9, r3
if ( extend_area_begin < heap->area_begin ) {
a64c: e59c3018 ldr r3, [ip, #24]
a650: e1550003 cmp r5, r3
a654: e1a0400c mov r4, ip
heap->area_begin = extend_area_begin;
a658: 358c5018 strcc r5, [ip, #24]
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
if ( extend_area_begin < heap->area_begin ) {
a65c: 3a000002 bcc a66c <_Heap_Extend+0x13c>
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
a660: e59c301c ldr r3, [ip, #28]
a664: e1530006 cmp r3, r6
heap->area_end = extend_area_end;
a668: 358c601c strcc r6, [ip, #28]
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
a66c: e59d1024 ldr r1, [sp, #36] ; 0x24
a670: e59d3020 ldr r3, [sp, #32]
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
a674: e0610003 rsb r0, r1, r3
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
a678: e5816000 str r6, [r1]
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
a67c: e380c001 orr ip, r0, #1
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
a680: e5830000 str r0, [r3]
extend_last_block->size_and_flag = 0;
a684: e3a00000 mov r0, #0
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
a688: e581c004 str ip, [r1, #4]
extend_first_block_size | HEAP_PREV_BLOCK_USED;
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
extend_last_block->size_and_flag = 0;
a68c: e5830004 str r0, [r3, #4]
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
a690: e5940020 ldr r0, [r4, #32]
a694: e1500001 cmp r0, r1
heap->first_block = extend_first_block;
a698: 85841020 strhi r1, [r4, #32]
extend_last_block->prev_size = extend_first_block_size;
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
a69c: 8a000002 bhi a6ac <_Heap_Extend+0x17c>
heap->first_block = extend_first_block;
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
a6a0: e5941024 ldr r1, [r4, #36] ; 0x24
a6a4: e1510003 cmp r1, r3
heap->last_block = extend_last_block;
a6a8: 35843024 strcc r3, [r4, #36] ; 0x24
}
if ( merge_below_block != NULL ) {
a6ac: e3590000 cmp r9, #0
a6b0: 0a000010 beq a6f8 <_Heap_Extend+0x1c8>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
a6b4: e594a010 ldr sl, [r4, #16] <== NOT EXECUTED
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
a6b8: e2855008 add r5, r5, #8 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
a6bc: e1a00005 mov r0, r5 <== NOT EXECUTED
a6c0: e1a0100a mov r1, sl <== NOT EXECUTED
a6c4: eb001501 bl fad0 <__umodsi3> <== NOT EXECUTED
if ( remainder != 0 ) {
a6c8: e3500000 cmp r0, #0 <== NOT EXECUTED
return value - remainder + alignment;
a6cc: 1085500a addne r5, r5, sl <== NOT EXECUTED
a6d0: 10605005 rsbne r5, r0, r5 <== NOT EXECUTED
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
a6d4: e5993000 ldr r3, [r9] <== NOT EXECUTED
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
a6d8: e2451008 sub r1, r5, #8 <== NOT EXECUTED
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
a6dc: e5053008 str r3, [r5, #-8] <== NOT EXECUTED
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
a6e0: e0613009 rsb r3, r1, r9 <== NOT EXECUTED
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
a6e4: e3833001 orr r3, r3, #1 <== NOT EXECUTED
a6e8: e5053004 str r3, [r5, #-4] <== NOT EXECUTED
_Heap_Free_block( heap, new_first_block );
a6ec: e1a00004 mov r0, r4 <== NOT EXECUTED
a6f0: ebffff86 bl a510 <_Heap_Free_block> <== NOT EXECUTED
a6f4: ea000004 b a70c <_Heap_Extend+0x1dc> <== NOT EXECUTED
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
_Heap_Merge_below( heap, extend_area_begin, merge_below_block );
} else if ( link_below_block != NULL ) {
a6f8: e3520000 cmp r2, #0
_Heap_Link_below(
a6fc: 159d3020 ldrne r3, [sp, #32]
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
a700: 10632002 rsbne r2, r3, r2
a704: 13822001 orrne r2, r2, #1
)
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
a708: 15832004 strne r2, [r3, #4]
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
a70c: e3570000 cmp r7, #0
a710: 0a000012 beq a760 <_Heap_Extend+0x230>
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE,
a714: e2466008 sub r6, r6, #8
uintptr_t extend_area_end
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
a718: e0676006 rsb r6, r7, r6
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
a71c: e5941010 ldr r1, [r4, #16]
a720: e1a00006 mov r0, r6
a724: eb0014e9 bl fad0 <__umodsi3>
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
(last_block->size_and_flag - last_block_new_size)
a728: e5972004 ldr r2, [r7, #4]
a72c: e0606006 rsb r6, r0, r6
a730: e0662002 rsb r2, r6, r2
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
a734: e0863007 add r3, r6, r7
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
a738: e3822001 orr r2, r2, #1
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
a73c: e5832004 str r2, [r3, #4]
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
a740: e5973004 ldr r3, [r7, #4]
a744: e2033001 and r3, r3, #1
block->size_and_flag = size | flag;
a748: e1866003 orr r6, r6, r3
a74c: e5876004 str r6, [r7, #4]
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
a750: e1a00004 mov r0, r4
a754: e1a01007 mov r1, r7
a758: ebffff6c bl a510 <_Heap_Free_block>
a75c: ea00000b b a790 <_Heap_Extend+0x260>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
a760: e3580000 cmp r8, #0
a764: 0a000009 beq a790 <_Heap_Extend+0x260>
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
a768: e5982004 ldr r2, [r8, #4]
)
{
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
a76c: e59d1024 ldr r1, [sp, #36] ; 0x24
a770: e2022001 and r2, r2, #1
a774: e0681001 rsb r1, r8, r1
block->size_and_flag = size | flag;
a778: e1812002 orr r2, r1, r2
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
_Heap_Link_above(
a77c: e59d3020 ldr r3, [sp, #32]
a780: e5882004 str r2, [r8, #4]
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
a784: e5932004 ldr r2, [r3, #4]
a788: e3822001 orr r2, r2, #1
a78c: e5832004 str r2, [r3, #4]
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
a790: e3570000 cmp r7, #0
a794: 03590000 cmpeq r9, #0
_Heap_Free_block( heap, extend_first_block );
a798: 01a00004 moveq r0, r4
a79c: 059d1024 ldreq r1, [sp, #36] ; 0x24
a7a0: 0bffff5a bleq a510 <_Heap_Free_block>
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
heap->last_block,
(uintptr_t) heap->first_block - (uintptr_t) heap->last_block
a7a4: e2841020 add r1, r4, #32
a7a8: e891000a ldm r1, {r1, r3}
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
a7ac: e5932004 ldr r2, [r3, #4]
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
a7b0: e0631001 rsb r1, r3, r1
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
a7b4: e2022001 and r2, r2, #1
block->size_and_flag = size | flag;
a7b8: e1812002 orr r2, r1, r2
a7bc: e5832004 str r2, [r3, #4]
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
a7c0: e59d101c ldr r1, [sp, #28]
a7c4: e284202c add r2, r4, #44 ; 0x2c
a7c8: e892000c ldm r2, {r2, r3}
a7cc: e0613003 rsb r3, r1, r3
/* Statistics */
stats->size += extended_size;
a7d0: e0822003 add r2, r2, r3
a7d4: e584202c str r2, [r4, #44] ; 0x2c
if ( extended_size_ptr != NULL )
a7d8: e59d2018 ldr r2, [sp, #24]
a7dc: e3520000 cmp r2, #0
*extended_size_ptr = extended_size;
a7e0: 15823000 strne r3, [r2]
return true;
a7e4: e3a00001 mov r0, #1
a7e8: ea000000 b a7f0 <_Heap_Extend+0x2c0>
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
a7ec: e3a00000 mov r0, #0
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
a7f0: e28dd028 add sp, sp, #40 ; 0x28
a7f4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00006c64 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
6c64: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size;
6c68: e5903014 ldr r3, [r0, #20]
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
6c6c: e24dd030 sub sp, sp, #48 ; 0x30
uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size;
6c70: e58d3024 str r3, [sp, #36] ; 0x24
Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block;
6c74: e5903024 ldr r3, [r0, #36] ; 0x24
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
6c78: e59f4500 ldr r4, [pc, #1280] ; 7180 <_Heap_Walk+0x51c>
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
6c7c: e58d3028 str r3, [sp, #40] ; 0x28
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
6c80: e59f34fc ldr r3, [pc, #1276] ; 7184 <_Heap_Walk+0x520>
6c84: e31200ff tst r2, #255 ; 0xff
6c88: 11a04003 movne r4, r3
if ( !_System_state_Is_up( _System_state_Get() ) ) {
6c8c: e59f34f4 ldr r3, [pc, #1268] ; 7188 <_Heap_Walk+0x524>
6c90: e5933000 ldr r3, [r3]
bool dump
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
6c94: e590c020 ldr ip, [r0, #32]
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
6c98: e3530003 cmp r3, #3
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
6c9c: e1a06000 mov r6, r0
6ca0: e1a05001 mov r5, r1
uintptr_t const page_size = heap->page_size;
6ca4: e5909010 ldr r9, [r0, #16]
uintptr_t const min_block_size = heap->min_block_size; Heap_Block *const first_block = heap->first_block;
6ca8: e58dc020 str ip, [sp, #32]
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
6cac: 1a000127 bne 7150 <_Heap_Walk+0x4ec>
Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
(*printer)(
6cb0: e59dc024 ldr ip, [sp, #36] ; 0x24
6cb4: e58dc000 str ip, [sp]
6cb8: e5903018 ldr r3, [r0, #24]
6cbc: e58d3004 str r3, [sp, #4]
6cc0: e590301c ldr r3, [r0, #28]
6cc4: e59d2020 ldr r2, [sp, #32]
6cc8: e58d3008 str r3, [sp, #8]
6ccc: e59d3028 ldr r3, [sp, #40] ; 0x28
6cd0: e58d200c str r2, [sp, #12]
6cd4: e58d3010 str r3, [sp, #16]
6cd8: e5903008 ldr r3, [r0, #8]
6cdc: e58d3014 str r3, [sp, #20]
6ce0: e590300c ldr r3, [r0, #12]
6ce4: e59f24a0 ldr r2, [pc, #1184] ; 718c <_Heap_Walk+0x528>
6ce8: e58d3018 str r3, [sp, #24]
6cec: e1a00001 mov r0, r1
6cf0: e1a03009 mov r3, r9
6cf4: e3a01000 mov r1, #0
6cf8: e1a0e00f mov lr, pc
6cfc: e12fff14 bx r4
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
6d00: e3590000 cmp r9, #0
6d04: 1a000006 bne 6d24 <_Heap_Walk+0xc0>
(*printer)( source, true, "page size is zero\n" );
6d08: e1a00005 mov r0, r5
6d0c: e3a01001 mov r1, #1
6d10: e59f2478 ldr r2, [pc, #1144] ; 7190 <_Heap_Walk+0x52c>
6d14: e1a0e00f mov lr, pc
6d18: e12fff14 bx r4
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
6d1c: e1a08009 mov r8, r9
6d20: ea00010b b 7154 <_Heap_Walk+0x4f0>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
6d24: e2198007 ands r8, r9, #7
(*printer)(
6d28: 11a00005 movne r0, r5
6d2c: 13a01001 movne r1, #1
6d30: 159f245c ldrne r2, [pc, #1116] ; 7194 <_Heap_Walk+0x530>
6d34: 11a03009 movne r3, r9
6d38: 1a00010c bne 7170 <_Heap_Walk+0x50c>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
6d3c: e59d0024 ldr r0, [sp, #36] ; 0x24
6d40: e1a01009 mov r1, r9
6d44: ebffe796 bl ba4 <__umodsi3>
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
6d48: e250b000 subs fp, r0, #0
6d4c: 0a000006 beq 6d6c <_Heap_Walk+0x108>
(*printer)(
6d50: e1a00005 mov r0, r5
6d54: e3a01001 mov r1, #1
6d58: e59f2438 ldr r2, [pc, #1080] ; 7198 <_Heap_Walk+0x534>
6d5c: e59d3024 ldr r3, [sp, #36] ; 0x24
6d60: e1a0e00f mov lr, pc
6d64: e12fff14 bx r4
6d68: ea0000f9 b 7154 <_Heap_Walk+0x4f0>
6d6c: e59dc020 ldr ip, [sp, #32]
6d70: e1a01009 mov r1, r9
6d74: e28c0008 add r0, ip, #8
6d78: ebffe789 bl ba4 <__umodsi3>
);
return false;
}
if (
6d7c: e250a000 subs sl, r0, #0
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
6d80: 11a00005 movne r0, r5
6d84: 13a01001 movne r1, #1
6d88: 159f240c ldrne r2, [pc, #1036] ; 719c <_Heap_Walk+0x538>
6d8c: 159d3020 ldrne r3, [sp, #32]
6d90: 1a0000cc bne 70c8 <_Heap_Walk+0x464>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
6d94: e59d2020 ldr r2, [sp, #32]
6d98: e5928004 ldr r8, [r2, #4]
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
6d9c: e2188001 ands r8, r8, #1
(*printer)(
6da0: 01a00005 moveq r0, r5
6da4: 03a01001 moveq r1, #1
6da8: 059f23f0 ldreq r2, [pc, #1008] ; 71a0 <_Heap_Walk+0x53c>
6dac: 0a000009 beq 6dd8 <_Heap_Walk+0x174>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
6db0: e59d3028 ldr r3, [sp, #40] ; 0x28
6db4: e5937004 ldr r7, [r3, #4]
6db8: e3c77001 bic r7, r7, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
6dbc: e0837007 add r7, r3, r7
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
6dc0: e5978004 ldr r8, [r7, #4]
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
6dc4: e2188001 ands r8, r8, #1
6dc8: 1a000005 bne 6de4 <_Heap_Walk+0x180>
(*printer)(
6dcc: e59f23d0 ldr r2, [pc, #976] ; 71a4 <_Heap_Walk+0x540>
6dd0: e1a00005 mov r0, r5
6dd4: e3a01001 mov r1, #1
6dd8: e1a0e00f mov lr, pc
6ddc: e12fff14 bx r4
6de0: ea0000db b 7154 <_Heap_Walk+0x4f0>
);
return false;
}
if (
6de4: e59dc020 ldr ip, [sp, #32]
6de8: e157000c cmp r7, ip
6dec: 0a000006 beq 6e0c <_Heap_Walk+0x1a8>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
6df0: e1a00005 mov r0, r5 <== NOT EXECUTED
6df4: e3a01001 mov r1, #1 <== NOT EXECUTED
6df8: e59f23a8 ldr r2, [pc, #936] ; 71a8 <_Heap_Walk+0x544> <== NOT EXECUTED
6dfc: e1a0e00f mov lr, pc <== NOT EXECUTED
6e00: e12fff14 bx r4 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
6e04: e1a0800a mov r8, sl <== NOT EXECUTED
6e08: ea0000d1 b 7154 <_Heap_Walk+0x4f0> <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
6e0c: e596b010 ldr fp, [r6, #16]
block = next_block;
} while ( block != first_block );
return true;
}
6e10: e5968008 ldr r8, [r6, #8]
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
6e14: e1a0a006 mov sl, r6
6e18: ea000034 b 6ef0 <_Heap_Walk+0x28c>
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
6e1c: e5963020 ldr r3, [r6, #32]
6e20: e1530008 cmp r3, r8
6e24: 83a0c000 movhi ip, #0
6e28: 8a000003 bhi 6e3c <_Heap_Walk+0x1d8>
6e2c: e596c024 ldr ip, [r6, #36] ; 0x24
6e30: e15c0008 cmp ip, r8
6e34: 33a0c000 movcc ip, #0
6e38: 23a0c001 movcs ip, #1
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
6e3c: e21cc0ff ands ip, ip, #255 ; 0xff
(*printer)(
6e40: 01a00005 moveq r0, r5
6e44: 03a01001 moveq r1, #1
6e48: 059f235c ldreq r2, [pc, #860] ; 71ac <_Heap_Walk+0x548>
6e4c: 0a000012 beq 6e9c <_Heap_Walk+0x238>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
6e50: e2880008 add r0, r8, #8
6e54: e1a0100b mov r1, fp
6e58: ebffe751 bl ba4 <__umodsi3>
);
return false;
}
if (
6e5c: e250c000 subs ip, r0, #0
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
6e60: 11a00005 movne r0, r5
6e64: 13a01001 movne r1, #1
6e68: 159f2340 ldrne r2, [pc, #832] ; 71b0 <_Heap_Walk+0x54c>
6e6c: 11a03008 movne r3, r8
6e70: 1a0000be bne 7170 <_Heap_Walk+0x50c>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
6e74: e5983004 ldr r3, [r8, #4]
6e78: e3c33001 bic r3, r3, #1
block = next_block;
} while ( block != first_block );
return true;
}
6e7c: e0883003 add r3, r8, r3
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
6e80: e5933004 ldr r3, [r3, #4]
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
6e84: e2133001 ands r3, r3, #1
6e88: e58d302c str r3, [sp, #44] ; 0x2c
6e8c: 0a000009 beq 6eb8 <_Heap_Walk+0x254>
(*printer)(
6e90: e59f231c ldr r2, [pc, #796] ; 71b4 <_Heap_Walk+0x550>
6e94: e1a00005 mov r0, r5
6e98: e3a01001 mov r1, #1
6e9c: e1a03008 mov r3, r8
6ea0: e58dc01c str ip, [sp, #28]
6ea4: e1a0e00f mov lr, pc
6ea8: e12fff14 bx r4
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
6eac: e59dc01c ldr ip, [sp, #28]
6eb0: e1a0800c mov r8, ip
6eb4: ea0000a6 b 7154 <_Heap_Walk+0x4f0>
);
return false;
}
if ( free_block->prev != prev_block ) {
6eb8: e598300c ldr r3, [r8, #12]
6ebc: e153000a cmp r3, sl
6ec0: 0a000008 beq 6ee8 <_Heap_Walk+0x284>
(*printer)(
6ec4: e58d3000 str r3, [sp]
6ec8: e1a00005 mov r0, r5
6ecc: e1a03008 mov r3, r8
6ed0: e3a01001 mov r1, #1
6ed4: e59f22dc ldr r2, [pc, #732] ; 71b8 <_Heap_Walk+0x554>
6ed8: e1a0e00f mov lr, pc
6edc: e12fff14 bx r4
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
6ee0: e59d802c ldr r8, [sp, #44] ; 0x2c
6ee4: ea00009a b 7154 <_Heap_Walk+0x4f0>
return false;
}
prev_block = free_block;
free_block = free_block->next;
6ee8: e1a0a008 mov sl, r8
6eec: e5988008 ldr r8, [r8, #8]
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
6ef0: e1580006 cmp r8, r6
6ef4: 1affffc8 bne 6e1c <_Heap_Walk+0x1b8>
6ef8: ea000000 b 6f00 <_Heap_Walk+0x29c>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
6efc: e1a07008 mov r7, r8
return true;
}
6f00: e5973004 ldr r3, [r7, #4]
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
6f04: e5962020 ldr r2, [r6, #32]
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
6f08: e3c3a001 bic sl, r3, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
6f0c: e087800a add r8, r7, sl
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
6f10: e1520008 cmp r2, r8
6f14: 83a0b000 movhi fp, #0
6f18: 8a000003 bhi 6f2c <_Heap_Walk+0x2c8>
6f1c: e596b024 ldr fp, [r6, #36] ; 0x24
6f20: e15b0008 cmp fp, r8
6f24: 33a0b000 movcc fp, #0
6f28: 23a0b001 movcs fp, #1
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
6f2c: e21bb0ff ands fp, fp, #255 ; 0xff
6f30: 1a000007 bne 6f54 <_Heap_Walk+0x2f0>
(*printer)(
6f34: e58d8000 str r8, [sp]
6f38: e1a00005 mov r0, r5
6f3c: e3a01001 mov r1, #1
6f40: e59f2274 ldr r2, [pc, #628] ; 71bc <_Heap_Walk+0x558>
6f44: e1a03007 mov r3, r7
6f48: e1a0e00f mov lr, pc
6f4c: e12fff14 bx r4
6f50: ea00005e b 70d0 <_Heap_Walk+0x46c>
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
6f54: e59d2028 ldr r2, [sp, #40] ; 0x28
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
6f58: e1a0000a mov r0, sl
6f5c: e1a01009 mov r1, r9
6f60: e057b002 subs fp, r7, r2
6f64: 13a0b001 movne fp, #1
6f68: e58d301c str r3, [sp, #28]
6f6c: ebffe70c bl ba4 <__umodsi3>
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
6f70: e3500000 cmp r0, #0
6f74: e59d301c ldr r3, [sp, #28]
6f78: 0a000005 beq 6f94 <_Heap_Walk+0x330>
6f7c: e35b0000 cmp fp, #0
(*printer)(
6f80: 158da000 strne sl, [sp]
6f84: 11a00005 movne r0, r5
6f88: 13a01001 movne r1, #1
6f8c: 159f222c ldrne r2, [pc, #556] ; 71c0 <_Heap_Walk+0x55c>
6f90: 1a000014 bne 6fe8 <_Heap_Walk+0x384>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
6f94: e59dc024 ldr ip, [sp, #36] ; 0x24
6f98: e15a000c cmp sl, ip
6f9c: 2a000009 bcs 6fc8 <_Heap_Walk+0x364>
6fa0: e35b0000 cmp fp, #0
6fa4: 0a000007 beq 6fc8 <_Heap_Walk+0x364>
(*printer)(
6fa8: e88d1400 stm sp, {sl, ip}
6fac: e1a00005 mov r0, r5
6fb0: e3a01001 mov r1, #1
6fb4: e59f2208 ldr r2, [pc, #520] ; 71c4 <_Heap_Walk+0x560>
6fb8: e1a03007 mov r3, r7
6fbc: e1a0e00f mov lr, pc
6fc0: e12fff14 bx r4
6fc4: ea00006b b 7178 <_Heap_Walk+0x514>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
6fc8: e1580007 cmp r8, r7
6fcc: 8a000009 bhi 6ff8 <_Heap_Walk+0x394>
6fd0: e35b0000 cmp fp, #0
6fd4: 0a000007 beq 6ff8 <_Heap_Walk+0x394>
(*printer)(
6fd8: e58d8000 str r8, [sp]
6fdc: e59f21e4 ldr r2, [pc, #484] ; 71c8 <_Heap_Walk+0x564>
6fe0: e1a00005 mov r0, r5
6fe4: e3a01001 mov r1, #1
6fe8: e1a03007 mov r3, r7
6fec: e1a0e00f mov lr, pc
6ff0: e12fff14 bx r4
6ff4: ea00005f b 7178 <_Heap_Walk+0x514>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
6ff8: e203b001 and fp, r3, #1
6ffc: e5983004 ldr r3, [r8, #4]
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
7000: e3130001 tst r3, #1
7004: 1a00003b bne 70f8 <_Heap_Walk+0x494>
false,
"block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",
block,
block_size,
block->prev,
block->prev == first_free_block ?
7008: e597200c ldr r2, [r7, #12]
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
700c: e5963008 ldr r3, [r6, #8]
7010: e1520003 cmp r2, r3
block = next_block;
} while ( block != first_block );
return true;
}
7014: e596100c ldr r1, [r6, #12]
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
7018: 059f01ac ldreq r0, [pc, #428] ; 71cc <_Heap_Walk+0x568>
701c: 0a000003 beq 7030 <_Heap_Walk+0x3cc>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
7020: e59f31a8 ldr r3, [pc, #424] ; 71d0 <_Heap_Walk+0x56c>
7024: e1520006 cmp r2, r6
7028: e59f01a4 ldr r0, [pc, #420] ; 71d4 <_Heap_Walk+0x570>
702c: 01a00003 moveq r0, r3
block->next,
block->next == last_free_block ?
7030: e5973008 ldr r3, [r7, #8]
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
7034: e1530001 cmp r3, r1
7038: 059f1198 ldreq r1, [pc, #408] ; 71d8 <_Heap_Walk+0x574>
703c: 0a000003 beq 7050 <_Heap_Walk+0x3ec>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
7040: e59fc194 ldr ip, [pc, #404] ; 71dc <_Heap_Walk+0x578>
7044: e1530006 cmp r3, r6
7048: e59f1184 ldr r1, [pc, #388] ; 71d4 <_Heap_Walk+0x570>
704c: 01a0100c moveq r1, ip
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
7050: e58d2004 str r2, [sp, #4]
7054: e58d0008 str r0, [sp, #8]
7058: e58d300c str r3, [sp, #12]
705c: e58d1010 str r1, [sp, #16]
7060: e1a03007 mov r3, r7
7064: e58da000 str sl, [sp]
7068: e1a00005 mov r0, r5
706c: e3a01000 mov r1, #0
7070: e59f2168 ldr r2, [pc, #360] ; 71e0 <_Heap_Walk+0x57c>
7074: e1a0e00f mov lr, pc
7078: e12fff14 bx r4
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
707c: e5983000 ldr r3, [r8]
7080: e15a0003 cmp sl, r3
7084: 0a000009 beq 70b0 <_Heap_Walk+0x44c>
(*printer)(
7088: e58d3004 str r3, [sp, #4]
708c: e58da000 str sl, [sp]
7090: e58d8008 str r8, [sp, #8]
7094: e1a00005 mov r0, r5
7098: e3a01001 mov r1, #1
709c: e59f2140 ldr r2, [pc, #320] ; 71e4 <_Heap_Walk+0x580>
70a0: e1a03007 mov r3, r7
70a4: e1a0e00f mov lr, pc
70a8: e12fff14 bx r4
70ac: ea000031 b 7178 <_Heap_Walk+0x514>
);
return false;
}
if ( !prev_used ) {
70b0: e35b0000 cmp fp, #0
70b4: 1a000007 bne 70d8 <_Heap_Walk+0x474>
(*printer)(
70b8: e59f2128 ldr r2, [pc, #296] ; 71e8 <_Heap_Walk+0x584>
70bc: e1a00005 mov r0, r5
70c0: e3a01001 mov r1, #1
70c4: e1a03007 mov r3, r7
70c8: e1a0e00f mov lr, pc
70cc: e12fff14 bx r4
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
70d0: e1a0800b mov r8, fp
70d4: ea00001e b 7154 <_Heap_Walk+0x4f0>
block = next_block;
} while ( block != first_block );
return true;
}
70d8: e5963008 ldr r3, [r6, #8]
70dc: ea000002 b 70ec <_Heap_Walk+0x488>
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
if ( free_block == block ) {
70e0: e1530007 cmp r3, r7
70e4: 0a000016 beq 7144 <_Heap_Walk+0x4e0>
return true;
}
free_block = free_block->next;
70e8: e5933008 ldr r3, [r3, #8]
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
70ec: e1530006 cmp r3, r6
70f0: 1afffffa bne 70e0 <_Heap_Walk+0x47c>
70f4: ea000019 b 7160 <_Heap_Walk+0x4fc>
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
70f8: e35b0000 cmp fp, #0
70fc: 0a000007 beq 7120 <_Heap_Walk+0x4bc>
(*printer)(
7100: e58da000 str sl, [sp]
7104: e1a00005 mov r0, r5
7108: e3a01000 mov r1, #0
710c: e59f20d8 ldr r2, [pc, #216] ; 71ec <_Heap_Walk+0x588>
7110: e1a03007 mov r3, r7
7114: e1a0e00f mov lr, pc
7118: e12fff14 bx r4
711c: ea000008 b 7144 <_Heap_Walk+0x4e0>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
7120: e58da000 str sl, [sp]
7124: e5973000 ldr r3, [r7]
7128: e1a00005 mov r0, r5
712c: e58d3004 str r3, [sp, #4]
7130: e1a0100b mov r1, fp
7134: e59f20b4 ldr r2, [pc, #180] ; 71f0 <_Heap_Walk+0x58c>
7138: e1a03007 mov r3, r7
713c: e1a0e00f mov lr, pc
7140: e12fff14 bx r4
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
7144: e59d2020 ldr r2, [sp, #32]
7148: e1580002 cmp r8, r2
714c: 1affff6a bne 6efc <_Heap_Walk+0x298>
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
7150: e3a08001 mov r8, #1
block = next_block;
} while ( block != first_block );
return true;
}
7154: e1a00008 mov r0, r8
7158: e28dd030 add sp, sp, #48 ; 0x30
715c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
7160: e59f208c ldr r2, [pc, #140] ; 71f4 <_Heap_Walk+0x590>
7164: e1a00005 mov r0, r5
7168: e3a01001 mov r1, #1
716c: e1a03007 mov r3, r7
7170: e1a0e00f mov lr, pc
7174: e12fff14 bx r4
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
7178: e3a08000 mov r8, #0
717c: eafffff4 b 7154 <_Heap_Walk+0x4f0>
000075a0 <_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 );
75a0: e281303c add r3, r1, #60 ; 0x3c
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
75a4: e591c014 ldr ip, [r1, #20]
head->next = tail;
75a8: e5813038 str r3, [r1, #56] ; 0x38
head->previous = NULL;
75ac: e3a03000 mov r3, #0
75b0: e581303c str r3, [r1, #60] ; 0x3c
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 ) )
75b4: e31c0020 tst ip, #32
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
75b8: 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
)
{
75bc: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
75c0: 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 ];
block_state = the_thread_queue->state;
75c4: e5908038 ldr r8, [r0, #56] ; 0x38
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
75c8: e1a0332c lsr r3, ip, #6
if ( _Thread_queue_Is_reverse_search( priority ) )
75cc: 1a000027 bne 7670 <_Thread_queue_Enqueue_priority+0xd0>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
75d0: e3a0700c mov r7, #12
75d4: e0030397 mul r3, r7, r3
75d8: e080a003 add sl, r0, r3
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
75dc: e2833004 add r3, r3, #4
75e0: e0807003 add r7, r0, r3
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
75e4: e10f4000 mrs r4, CPSR
75e8: e3843080 orr r3, r4, #128 ; 0x80
75ec: e129f003 msr CPSR_fc, r3
75f0: e1a05004 mov r5, r4
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
75f4: e3e06000 mvn r6, #0
_ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header );
75f8: e59a3000 ldr r3, [sl]
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
75fc: ea00000b b 7630 <_Thread_queue_Enqueue_priority+0x90>
search_priority = search_thread->current_priority;
7600: e5936014 ldr r6, [r3, #20]
if ( priority <= search_priority )
7604: e15c0006 cmp ip, r6
7608: 9a00000a bls 7638 <_Thread_queue_Enqueue_priority+0x98>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
760c: e10f9000 mrs r9, CPSR
7610: e129f004 msr CPSR_fc, r4
7614: 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);
7618: 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) ) {
761c: e1180009 tst r8, r9
7620: 1a000001 bne 762c <_Thread_queue_Enqueue_priority+0x8c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
7624: e129f004 msr CPSR_fc, r4
7628: eaffffed b 75e4 <_Thread_queue_Enqueue_priority+0x44>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
762c: 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 ) ) {
7630: e1530007 cmp r3, r7
7634: 1afffff1 bne 7600 <_Thread_queue_Enqueue_priority+0x60>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
7638: e5907030 ldr r7, [r0, #48] ; 0x30
763c: e3570001 cmp r7, #1
7640: 1a00003b bne 7734 <_Thread_queue_Enqueue_priority+0x194>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
7644: e3a02000 mov r2, #0
if ( priority == search_priority )
7648: e15c0006 cmp ip, r6
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
764c: e5802030 str r2, [r0, #48] ; 0x30
if ( priority == search_priority )
7650: 0a00002d beq 770c <_Thread_queue_Enqueue_priority+0x16c>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
7654: e5932004 ldr r2, [r3, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
7658: e5813000 str r3, [r1]
the_node->previous = previous_node;
765c: e5812004 str r2, [r1, #4]
previous_node->next = the_node;
7660: e5821000 str r1, [r2]
search_node->previous = the_node;
7664: e5831004 str r1, [r3, #4]
the_thread->Wait.queue = the_thread_queue;
7668: e5810044 str r0, [r1, #68] ; 0x44
_ISR_Enable( level );
766c: ea000024 b 7704 <_Thread_queue_Enqueue_priority+0x164>
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
7670: e3a0700c mov r7, #12
7674: e0270793 mla r7, r3, r7, r0
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
7678: e59fa0c0 ldr sl, [pc, #192] ; 7740 <_Thread_queue_Enqueue_priority+0x1a0>
767c: e5da6000 ldrb r6, [sl]
7680: e2866001 add r6, r6, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
7684: e10f4000 mrs r4, CPSR
7688: e3843080 orr r3, r4, #128 ; 0x80
768c: e129f003 msr CPSR_fc, r3
7690: e1a05004 mov r5, r4
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
7694: e5973008 ldr r3, [r7, #8]
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
7698: ea00000b b 76cc <_Thread_queue_Enqueue_priority+0x12c>
search_priority = search_thread->current_priority;
769c: e5936014 ldr r6, [r3, #20]
if ( priority >= search_priority )
76a0: e15c0006 cmp ip, r6
76a4: 2a00000a bcs 76d4 <_Thread_queue_Enqueue_priority+0x134>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
76a8: e10f9000 mrs r9, CPSR
76ac: e129f004 msr CPSR_fc, r4
76b0: e129f009 msr CPSR_fc, r9
76b4: 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) ) {
76b8: e1180009 tst r8, r9
76bc: 1a000001 bne 76c8 <_Thread_queue_Enqueue_priority+0x128>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
76c0: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
76c4: eaffffec b 767c <_Thread_queue_Enqueue_priority+0xdc> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
76c8: 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 ) ) {
76cc: e1530007 cmp r3, r7
76d0: 1afffff1 bne 769c <_Thread_queue_Enqueue_priority+0xfc>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
76d4: e5907030 ldr r7, [r0, #48] ; 0x30
76d8: e3570001 cmp r7, #1
76dc: 1a000014 bne 7734 <_Thread_queue_Enqueue_priority+0x194>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
76e0: e3a02000 mov r2, #0
if ( priority == search_priority )
76e4: e15c0006 cmp ip, r6
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
76e8: e5802030 str r2, [r0, #48] ; 0x30
if ( priority == search_priority )
76ec: 0a000006 beq 770c <_Thread_queue_Enqueue_priority+0x16c>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
76f0: e5932000 ldr r2, [r3]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
76f4: e881000c stm r1, {r2, r3}
search_node->next = the_node; next_node->previous = the_node;
76f8: e5821004 str r1, [r2, #4]
next_node = search_node->next;
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
search_node->next = the_node;
76fc: e5831000 str r1, [r3]
next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
7700: e5810044 str r0, [r1, #68] ; 0x44
7704: e129f004 msr CPSR_fc, r4
7708: ea000007 b 772c <_Thread_queue_Enqueue_priority+0x18c>
_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;
770c: 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 );
7710: e283c03c add ip, r3, #60 ; 0x3c
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
7714: e581c000 str ip, [r1]
the_node->previous = previous_node;
7718: e5812004 str r2, [r1, #4]
previous_node->next = the_node;
771c: e5821000 str r1, [r2]
search_node->previous = the_node;
7720: e5831040 str r1, [r3, #64] ; 0x40
the_thread->Wait.queue = the_thread_queue;
7724: e5810044 str r0, [r1, #68] ; 0x44
7728: e129f005 msr CPSR_fc, r5
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
772c: e3a00001 mov r0, #1
7730: 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;
7734: e5825000 str r5, [r2]
return the_thread_queue->sync_state;
7738: e5900030 ldr r0, [r0, #48] ; 0x30
}
773c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
00009708 <_Timespec_Greater_than>:
bool _Timespec_Greater_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec > rhs->tv_sec )
9708: e5902000 ldr r2, [r0]
970c: e5913000 ldr r3, [r1]
9710: e1520003 cmp r2, r3
return true;
9714: c3a00001 movgt r0, #1
bool _Timespec_Greater_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec > rhs->tv_sec )
9718: c12fff1e bxgt lr
return true;
if ( lhs->tv_sec < rhs->tv_sec )
971c: ba000005 blt 9738 <_Timespec_Greater_than+0x30>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Greater_than(
9720: e5900004 ldr r0, [r0, #4]
9724: e5913004 ldr r3, [r1, #4]
9728: e1500003 cmp r0, r3
972c: d3a00000 movle r0, #0
9730: c3a00001 movgt r0, #1
9734: e12fff1e bx lr
{
if ( lhs->tv_sec > rhs->tv_sec )
return true;
if ( lhs->tv_sec < rhs->tv_sec )
return false;
9738: e3a00000 mov r0, #0
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec > rhs->tv_nsec )
return true;
return false;
}
973c: e12fff1e bx lr
0000b858 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
b858: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
b85c: e252a000 subs sl, r2, #0
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
b860: e1a04000 mov r4, r0
b864: e1a05001 mov r5, r1
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
b868: 03a00009 moveq r0, #9
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
b86c: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc}
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
b870: e59f313c ldr r3, [pc, #316] ; b9b4 <rtems_task_mode+0x15c>
b874: e5937004 ldr r7, [r3, #4]
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
b878: e5d78074 ldrb r8, [r7, #116] ; 0x74
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
b87c: e59760f4 ldr r6, [r7, #244] ; 0xf4
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
b880: e597307c ldr r3, [r7, #124] ; 0x7c
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
b884: e3580000 cmp r8, #0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
b888: e5d69008 ldrb r9, [r6, #8]
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
b88c: 03a08c01 moveq r8, #256 ; 0x100
b890: 13a08000 movne r8, #0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
b894: e3530000 cmp r3, #0
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
b898: 13888c02 orrne r8, r8, #512 ; 0x200
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
b89c: e3590000 cmp r9, #0
b8a0: 03a09b01 moveq r9, #1024 ; 0x400
b8a4: 13a09000 movne r9, #0
old_mode |= _ISR_Get_level();
b8a8: ebfff31d bl 8524 <_CPU_ISR_Get_level>
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
b8ac: e1899000 orr r9, r9, r0
old_mode |= _ISR_Get_level();
b8b0: e1898008 orr r8, r9, r8
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
b8b4: e3150c01 tst r5, #256 ; 0x100
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
old_mode |= _ISR_Get_level();
*previous_mode_set = old_mode;
b8b8: e58a8000 str r8, [sl]
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
b8bc: 0a000003 beq b8d0 <rtems_task_mode+0x78>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
b8c0: e3140c01 tst r4, #256 ; 0x100
b8c4: 13a03000 movne r3, #0
b8c8: 03a03001 moveq r3, #1
b8cc: e5c73074 strb r3, [r7, #116] ; 0x74
if ( mask & RTEMS_TIMESLICE_MASK ) {
b8d0: e3150c02 tst r5, #512 ; 0x200
b8d4: 0a000006 beq b8f4 <rtems_task_mode+0x9c>
if ( _Modes_Is_timeslice(mode_set) ) {
b8d8: e2143c02 ands r3, r4, #512 ; 0x200
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
b8dc: 13a03001 movne r3, #1
b8e0: 1587307c strne r3, [r7, #124] ; 0x7c
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
b8e4: 159f30cc ldrne r3, [pc, #204] ; b9b8 <rtems_task_mode+0x160>
b8e8: 15933000 ldrne r3, [r3]
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
b8ec: 0587307c streq r3, [r7, #124] ; 0x7c
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
b8f0: 15873078 strne r3, [r7, #120] ; 0x78
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
b8f4: e3150080 tst r5, #128 ; 0x80
b8f8: 0a000001 beq b904 <rtems_task_mode+0xac>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
b8fc: e2040080 and r0, r4, #128 ; 0x80
b900: ebfff302 bl 8510 <_CPU_ISR_Set_level>
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
b904: e2150b01 ands r0, r5, #1024 ; 0x400
b908: 0a000013 beq b95c <rtems_task_mode+0x104>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
b90c: e3140b01 tst r4, #1024 ; 0x400
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
b910: e5d62008 ldrb r2, [r6, #8]
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
b914: 13a03000 movne r3, #0
b918: 03a03001 moveq r3, #1
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
b91c: e1520003 cmp r2, r3
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
b920: 03a00000 moveq r0, #0
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
b924: 0a00000c beq b95c <rtems_task_mode+0x104>
asr->is_enabled = is_asr_enabled;
b928: e5c63008 strb r3, [r6, #8]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
b92c: e10f3000 mrs r3, CPSR
b930: e3832080 orr r2, r3, #128 ; 0x80
b934: e129f002 msr CPSR_fc, r2
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
b938: e2861014 add r1, r6, #20
b93c: e8910006 ldm r1, {r1, r2}
information->signals_pending = information->signals_posted;
information->signals_posted = _signals;
b940: e5862014 str r2, [r6, #20]
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
b944: e5861018 str r1, [r6, #24]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
b948: e129f003 msr CPSR_fc, r3
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
b94c: e5960014 ldr r0, [r6, #20]
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
b950: e3500000 cmp r0, #0
b954: 13a00001 movne r0, #1
b958: 03a00000 moveq r0, #0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
b95c: e59f3058 ldr r3, [pc, #88] ; b9bc <rtems_task_mode+0x164>
b960: e5933000 ldr r3, [r3]
b964: e3530003 cmp r3, #3
b968: 1a00000f bne b9ac <rtems_task_mode+0x154>
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
b96c: e59f2040 ldr r2, [pc, #64] ; b9b4 <rtems_task_mode+0x15c>
if ( are_signals_pending ||
b970: e3500000 cmp r0, #0
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
b974: e5923004 ldr r3, [r2, #4]
if ( are_signals_pending ||
b978: 1a000005 bne b994 <rtems_task_mode+0x13c>
b97c: e5922008 ldr r2, [r2, #8]
b980: e1530002 cmp r3, r2
b984: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc}
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
b988: e5d33074 ldrb r3, [r3, #116] ; 0x74
b98c: e3530000 cmp r3, #0
b990: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc}
_Thread_Dispatch_necessary = true;
b994: e59f3018 ldr r3, [pc, #24] ; b9b4 <rtems_task_mode+0x15c>
b998: e3a02001 mov r2, #1
b99c: e5c32010 strb r2, [r3, #16]
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
b9a0: ebffed73 bl 6f74 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
b9a4: e3a00000 mov r0, #0
b9a8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
b9ac: e3a00000 mov r0, #0 <== NOT EXECUTED
}
b9b0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED