00016b50 <_CORE_message_queue_Broadcast>:
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
16b50: 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
)
{
16b54: 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 ) {
16b58: e1530002 cmp r3, r2
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
16b5c: e1a07000 mov r7, r0 16b60: e1a05002 mov r5, r2 16b64: e1a08001 mov r8, r1 16b68: e59da020 ldr sl, [sp, #32]
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
16b6c: 3a000016 bcc 16bcc <_CORE_message_queue_Broadcast+0x7c>
* 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 ) {
16b70: e5906048 ldr r6, [r0, #72] ; 0x48 16b74: e3560000 cmp r6, #0
*count = 0;
16b78: 13a00000 movne r0, #0 16b7c: 158a0000 strne r0, [sl]
* 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 ) {
16b80: 18bd85f0 popne {r4, r5, r6, r7, r8, sl, pc}
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
16b84: e1a00007 mov r0, r7 16b88: eb000a60 bl 19510 <_Thread_queue_Dequeue> 16b8c: e2504000 subs r4, r0, #0
16b90: 0a00000a beq 16bc0 <_CORE_message_queue_Broadcast+0x70>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
16b94: e594002c ldr r0, [r4, #44] ; 0x2c 16b98: e1a01008 mov r1, r8 16b9c: e1a02005 mov r2, r5 16ba0: eb00246b bl 1fd54 <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
16ba4: e5943028 ldr r3, [r4, #40] ; 0x28
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
16ba8: e1a00007 mov r0, r7
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
16bac: e5835000 str r5, [r3]
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
16bb0: eb000a56 bl 19510 <_Thread_queue_Dequeue> 16bb4: e2504000 subs r4, r0, #0
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
16bb8: e2866001 add r6, r6, #1
/*
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
number_broadcasted = 0;
while ((the_thread =
16bbc: 1afffff4 bne 16b94 <_CORE_message_queue_Broadcast+0x44>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
16bc0: e58a6000 str r6, [sl]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
16bc4: e1a00004 mov r0, r4
16bc8: 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;
16bcc: e3a00001 mov r0, #1 <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
16bd0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
0000b46c <_Chain_Initialize>:
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
next = starting_address;
while ( count-- ) {
b46c: e3520000 cmp r2, #0
Chain_Node *current;
Chain_Node *next;
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
b470: e3a0c000 mov ip, #0
next = starting_address;
while ( count-- ) {
b474: 12422001 subne r2, r2, #1
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
b478: e92d0070 push {r4, r5, r6}
Chain_Node *current;
Chain_Node *next;
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
b47c: e580c004 str ip, [r0, #4]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
Chain_Control *the_chain
)
{
return (Chain_Node *) the_chain;
b480: e1a04000 mov r4, r0
next = starting_address;
while ( count-- ) {
b484: 11a06002 movne r6, r2
Chain_Node *next;
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
next = starting_address;
b488: 11a0c001 movne ip, r1
while ( count-- ) {
b48c: 1a000003 bne b4a0 <_Chain_Initialize+0x34>
b490: ea000008 b b4b8 <_Chain_Initialize+0x4c> <== NOT EXECUTED
b494: e1a0400c mov r4, ip
b498: e2422001 sub r2, r2, #1
current->next = next;
next->previous = current;
current = next;
next = (Chain_Node *)
b49c: e1a0c005 mov ip, r5
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
next = starting_address;
while ( count-- ) {
b4a0: e3520000 cmp r2, #0
current->next = next;
b4a4: e584c000 str ip, [r4]
next->previous = current;
b4a8: e58c4004 str r4, [ip, #4]
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
b4ac: e08c5003 add r5, ip, r3
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
next = starting_address;
while ( count-- ) {
b4b0: 1afffff7 bne b494 <_Chain_Initialize+0x28>
b4b4: e0241396 mla r4, r6, r3, r1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
b4b8: e2803004 add r3, r0, #4
next->previous = current;
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = _Chain_Tail( the_chain );
b4bc: e5843000 str r3, [r4]
the_chain->last = current;
b4c0: e5804008 str r4, [r0, #8]
}
b4c4: e8bd0070 pop {r4, r5, r6}
b4c8: e12fff1e bx lr
0000b6ac <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
b6ac: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
b6b0: e1a08002 mov r8, r2
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
b6b4: e5902010 ldr r2, [r0, #16]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
b6b8: e24dd01c sub sp, sp, #28
b6bc: e1a05001 mov r5, r1
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
b6c0: e2911004 adds r1, r1, #4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
b6c4: e1a07000 mov r7, r0
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
b6c8: e58d1000 str r1, [sp]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
b6cc: e1a0b003 mov fp, r3
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
b6d0: e58d200c str r2, [sp, #12]
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
b6d4: 2a00007a bcs b8c4 <_Heap_Allocate_aligned_with_boundary+0x218>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
b6d8: e3530000 cmp r3, #0
b6dc: 1a000076 bne b8bc <_Heap_Allocate_aligned_with_boundary+0x210>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
b6e0: e5979008 ldr r9, [r7, #8]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
b6e4: e1570009 cmp r7, r9
b6e8: 0a000075 beq b8c4 <_Heap_Allocate_aligned_with_boundary+0x218>
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
b6ec: e59d300c ldr r3, [sp, #12]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
b6f0: e2651004 rsb r1, r5, #4
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
b6f4: e2833007 add r3, r3, #7
b6f8: e58d3010 str r3, [sp, #16]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
b6fc: e58d1014 str r1, [sp, #20]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
b700: e3a06001 mov r6, #1
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
b704: e599a004 ldr sl, [r9, #4]
b708: e59d2000 ldr r2, [sp]
b70c: e152000a cmp r2, sl
b710: 2a000050 bcs b858 <_Heap_Allocate_aligned_with_boundary+0x1ac>
if ( alignment == 0 ) {
b714: e3580000 cmp r8, #0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
b718: 02894008 addeq r4, r9, #8
b71c: 0a000053 beq b870 <_Heap_Allocate_aligned_with_boundary+0x1c4>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
b720: e5973014 ldr r3, [r7, #20]
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
b724: e59d1014 ldr r1, [sp, #20]
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
b728: e59d2010 ldr r2, [sp, #16]
- 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;
b72c: e3caa001 bic sl, sl, #1
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
b730: e089a00a add sl, r9, sl
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
b734: e081400a add r4, r1, sl
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
b738: e58d3004 str r3, [sp, #4]
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
b73c: e0633002 rsb r3, r3, r2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
b740: e1a00004 mov r0, r4
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
b744: e083a00a add sl, r3, sl
b748: e1a01008 mov r1, r8
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
b74c: e2893008 add r3, r9, #8
b750: e58d3008 str r3, [sp, #8]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
b754: eb001697 bl 111b8 <__umodsi3>
b758: e0604004 rsb r4, r0, r4
uintptr_t alloc_begin = alloc_end - alloc_size;
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
b75c: e15a0004 cmp sl, r4
b760: 2a000003 bcs b774 <_Heap_Allocate_aligned_with_boundary+0xc8>
b764: e1a0000a mov r0, sl
b768: e1a01008 mov r1, r8
b76c: eb001691 bl 111b8 <__umodsi3>
b770: e060400a rsb r4, r0, sl
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
b774: e35b0000 cmp fp, #0
b778: 0a000026 beq b818 <_Heap_Allocate_aligned_with_boundary+0x16c>
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment );
}
alloc_end = alloc_begin + alloc_size;
b77c: e084a005 add sl, r4, r5
b780: e1a0000a mov r0, sl
b784: e1a0100b mov r1, fp
b788: eb00168a bl 111b8 <__umodsi3>
b78c: e060000a rsb r0, r0, sl
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
b790: e15a0000 cmp sl, r0
b794: 93a0a000 movls sl, #0
b798: 83a0a001 movhi sl, #1
b79c: e1540000 cmp r4, r0
b7a0: 23a0a000 movcs sl, #0
b7a4: e35a0000 cmp sl, #0
b7a8: 0a00001a beq b818 <_Heap_Allocate_aligned_with_boundary+0x16c>
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
b7ac: e59d1008 ldr r1, [sp, #8]
b7b0: e0813005 add r3, r1, r5
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
b7b4: e1530000 cmp r3, r0
b7b8: 958d9018 strls r9, [sp, #24]
b7bc: 91a09003 movls r9, r3
b7c0: 9a000002 bls b7d0 <_Heap_Allocate_aligned_with_boundary+0x124>
b7c4: ea000023 b b858 <_Heap_Allocate_aligned_with_boundary+0x1ac>
b7c8: e1590000 cmp r9, r0
b7cc: 8a00003e bhi b8cc <_Heap_Allocate_aligned_with_boundary+0x220>
return 0;
}
alloc_begin = boundary_line - alloc_size;
b7d0: e0654000 rsb r4, r5, r0
b7d4: e1a01008 mov r1, r8
b7d8: e1a00004 mov r0, r4
b7dc: eb001675 bl 111b8 <__umodsi3>
b7e0: e0604004 rsb r4, r0, r4
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
b7e4: e084a005 add sl, r4, r5
b7e8: e1a0000a mov r0, sl
b7ec: e1a0100b mov r1, fp
b7f0: eb001670 bl 111b8 <__umodsi3>
b7f4: e060000a rsb r0, r0, sl
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
b7f8: e15a0000 cmp sl, r0
b7fc: 93a0a000 movls sl, #0
b800: 83a0a001 movhi sl, #1
b804: e1540000 cmp r4, r0
b808: 23a0a000 movcs sl, #0
b80c: e35a0000 cmp sl, #0
b810: 1affffec bne b7c8 <_Heap_Allocate_aligned_with_boundary+0x11c>
b814: e59d9018 ldr r9, [sp, #24]
boundary_line = _Heap_Align_down( alloc_end, boundary );
}
}
/* Ensure that the we have a valid new block at the beginning */
if ( alloc_begin >= alloc_begin_floor ) {
b818: e59d2008 ldr r2, [sp, #8]
b81c: e1520004 cmp r2, r4
b820: 8a00000c bhi b858 <_Heap_Allocate_aligned_with_boundary+0x1ac>
b824: e59d100c ldr r1, [sp, #12]
b828: e1a00004 mov r0, r4
b82c: eb001661 bl 111b8 <__umodsi3>
b830: e269a4ff rsb sl, r9, #-16777216 ; 0xff000000
b834: e28aa8ff add sl, sl, #16711680 ; 0xff0000
b838: e28aacff add sl, sl, #65280 ; 0xff00
b83c: e28aa0f8 add sl, sl, #248 ; 0xf8
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
b840: e08aa004 add sl, sl, r4
uintptr_t const alloc_block_begin =
(uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size );
uintptr_t const free_size = alloc_block_begin - block_begin;
if ( free_size >= min_block_size || free_size == 0 ) {
b844: e59d1004 ldr r1, [sp, #4]
b848: e060300a rsb r3, r0, sl
b84c: e15a0000 cmp sl, r0
b850: 11510003 cmpne r1, r3
b854: 9a000005 bls b870 <_Heap_Allocate_aligned_with_boundary+0x1c4>
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
b858: e5999008 ldr r9, [r9, #8]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
b85c: e1570009 cmp r7, r9
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
b860: e2863001 add r3, r6, #1
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
b864: 0a00001d beq b8e0 <_Heap_Allocate_aligned_with_boundary+0x234>
b868: e1a06003 mov r6, r3
b86c: eaffffa4 b b704 <_Heap_Allocate_aligned_with_boundary+0x58>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
b870: e3540000 cmp r4, #0
b874: 0afffff7 beq b858 <_Heap_Allocate_aligned_with_boundary+0x1ac>
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
b878: e2872048 add r2, r7, #72 ; 0x48
b87c: e892000c ldm r2, {r2, r3}
b880: e2822001 add r2, r2, #1
stats->searches += search_count;
b884: e0833006 add r3, r3, r6
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
b888: e5872048 str r2, [r7, #72] ; 0x48
stats->searches += search_count;
b88c: e587304c str r3, [r7, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
b890: e1a00007 mov r0, r7
b894: e1a01009 mov r1, r9
b898: e1a02004 mov r2, r4
b89c: e1a03005 mov r3, r5
b8a0: ebffebcb bl 67d4 <_Heap_Block_allocate>
b8a4: e1a00004 mov r0, r4
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
b8a8: e5973044 ldr r3, [r7, #68] ; 0x44
b8ac: e1530006 cmp r3, r6
stats->max_search = search_count;
b8b0: 35876044 strcc r6, [r7, #68] ; 0x44
}
return (void *) alloc_begin;
}
b8b4: e28dd01c add sp, sp, #28
b8b8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
b8bc: e1550003 cmp r5, r3
b8c0: 9a000008 bls b8e8 <_Heap_Allocate_aligned_with_boundary+0x23c>
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
b8c4: e3a00000 mov r0, #0
b8c8: eafffff9 b b8b4 <_Heap_Allocate_aligned_with_boundary+0x208>
b8cc: e59d9018 ldr r9, [sp, #24] <== NOT EXECUTED
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
b8d0: e5999008 ldr r9, [r9, #8] <== NOT EXECUTED
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
b8d4: e1570009 cmp r7, r9 <== NOT EXECUTED
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
b8d8: e2863001 add r3, r6, #1 <== NOT EXECUTED
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
b8dc: 1affffe1 bne b868 <_Heap_Allocate_aligned_with_boundary+0x1bc><== NOT EXECUTED
b8e0: e3a00000 mov r0, #0
b8e4: eaffffef b b8a8 <_Heap_Allocate_aligned_with_boundary+0x1fc>
if ( boundary < alloc_size ) {
return NULL;
}
if ( alignment == 0 ) {
alignment = page_size;
b8e8: e3580000 cmp r8, #0
b8ec: 01a08002 moveq r8, r2
b8f0: eaffff7a b b6e0 <_Heap_Allocate_aligned_with_boundary+0x34>
0000b8f4 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
b8f4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
b8f8: e1a04000 mov r4, r0
b8fc: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
b900: e1a00001 mov r0, r1
b904: e5941010 ldr r1, [r4, #16]
b908: eb00162a bl 111b8 <__umodsi3>
b90c: e2455008 sub r5, r5, #8
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
b910: e5943020 ldr r3, [r4, #32]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
b914: e0605005 rsb r5, r0, r5
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;
b918: e1550003 cmp r5, r3
b91c: 3a00002f bcc b9e0 <_Heap_Free+0xec>
b920: e5941024 ldr r1, [r4, #36] ; 0x24
b924: e1550001 cmp r5, r1
b928: 8a00002c bhi b9e0 <_Heap_Free+0xec>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
b92c: e595c004 ldr ip, [r5, #4]
- 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;
b930: e3cc6001 bic r6, ip, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
b934: e0852006 add r2, r5, r6
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;
b938: e1530002 cmp r3, r2
b93c: 8a000027 bhi b9e0 <_Heap_Free+0xec>
b940: e1510002 cmp r1, r2
b944: 3a000027 bcc b9e8 <_Heap_Free+0xf4>
b948: e5927004 ldr r7, [r2, #4]
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
b94c: e2170001 ands r0, r7, #1
b950: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
b954: e1510002 cmp r1, r2
- 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;
b958: e3c77001 bic r7, r7, #1
b95c: 03a08000 moveq r8, #0
b960: 0a000004 beq b978 <_Heap_Free+0x84>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
b964: e0820007 add r0, r2, 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;
b968: e5900004 ldr r0, [r0, #4]
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
b96c: e3100001 tst r0, #1
b970: 13a08000 movne r8, #0
b974: 03a08001 moveq r8, #1
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
b978: e21c0001 ands r0, ip, #1
b97c: 1a00001b bne b9f0 <_Heap_Free+0xfc>
uintptr_t const prev_size = block->prev_size;
b980: e595c000 ldr ip, [r5]
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
b984: e06ca005 rsb sl, ip, r5
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;
b988: e153000a cmp r3, sl
b98c: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
b990: e151000a cmp r1, sl
b994: 38bd85f0 popcc {r4, r5, r6, r7, r8, sl, pc}
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;
b998: e59a0004 ldr r0, [sl, #4]
return( false );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
b99c: e2100001 ands r0, r0, #1
b9a0: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
b9a4: e3580000 cmp r8, #0
b9a8: 0a000039 beq ba94 <_Heap_Free+0x1a0>
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
b9ac: e5940038 ldr r0, [r4, #56] ; 0x38
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
b9b0: e0867007 add r7, r6, r7
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
b9b4: e5923008 ldr r3, [r2, #8]
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
b9b8: e087c00c add ip, r7, ip
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
b9bc: e592200c ldr r2, [r2, #12]
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
b9c0: e2400001 sub r0, r0, #1
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
b9c4: e38c1001 orr r1, ip, #1
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
b9c8: e5823008 str r3, [r2, #8]
next->prev = prev;
b9cc: e583200c str r2, [r3, #12]
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
b9d0: e5840038 str r0, [r4, #56] ; 0x38
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
b9d4: e58a1004 str r1, [sl, #4]
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
b9d8: e78ac00c str ip, [sl, ip]
b9dc: ea00000f b ba20 <_Heap_Free+0x12c>
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
b9e0: e3a00000 mov r0, #0
b9e4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
b9e8: e3a00000 mov r0, #0 <== NOT EXECUTED
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
b9ec: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
b9f0: e3580000 cmp r8, #0
b9f4: 0a000014 beq ba4c <_Heap_Free+0x158>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
b9f8: e5923008 ldr r3, [r2, #8]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
b9fc: e0877006 add r7, r7, r6
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
ba00: e592200c ldr r2, [r2, #12]
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
ba04: e3871001 orr r1, r7, #1
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
ba08: e5853008 str r3, [r5, #8]
new_block->prev = prev;
ba0c: e585200c str r2, [r5, #12]
next->prev = new_block;
prev->next = new_block;
ba10: e5825008 str r5, [r2, #8]
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
ba14: e583500c str r5, [r3, #12]
ba18: e5851004 str r1, [r5, #4]
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
ba1c: e7857007 str r7, [r5, r7]
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
ba20: e5942040 ldr r2, [r4, #64] ; 0x40
++stats->frees;
ba24: e5943050 ldr r3, [r4, #80] ; 0x50
stats->free_size += block_size;
ba28: e5941030 ldr r1, [r4, #48] ; 0x30
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
ba2c: e2422001 sub r2, r2, #1
++stats->frees;
ba30: e2833001 add r3, r3, #1
stats->free_size += block_size;
ba34: e0816006 add r6, r1, r6
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
ba38: e5842040 str r2, [r4, #64] ; 0x40
++stats->frees;
ba3c: e5843050 str r3, [r4, #80] ; 0x50
stats->free_size += block_size;
ba40: e5846030 str r6, [r4, #48] ; 0x30
return( true );
ba44: e3a00001 mov r0, #1
ba48: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
ba4c: e3863001 orr r3, r6, #1
ba50: e5853004 str r3, [r5, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
ba54: e2843038 add r3, r4, #56 ; 0x38
ba58: e8931008 ldm r3, {r3, ip}
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
ba5c: e5920004 ldr r0, [r2, #4]
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
ba60: e5941008 ldr r1, [r4, #8]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
ba64: e2833001 add r3, r3, #1
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
ba68: e3c00001 bic r0, r0, #1
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
if ( stats->max_free_blocks < stats->free_blocks ) {
ba6c: e153000c cmp r3, ip
new_block->next = next;
ba70: e5851008 str r1, [r5, #8]
new_block->prev = block_before;
ba74: e585400c str r4, [r5, #12]
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
ba78: e5820004 str r0, [r2, #4]
block_before->next = new_block; next->prev = new_block;
ba7c: e581500c str r5, [r1, #12]
next_block->prev_size = block_size;
ba80: e7856006 str r6, [r5, r6]
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
ba84: e5845008 str r5, [r4, #8]
/* Statistics */
++stats->free_blocks;
ba88: e5843038 str r3, [r4, #56] ; 0x38
if ( stats->max_free_blocks < stats->free_blocks ) {
stats->max_free_blocks = stats->free_blocks;
ba8c: 8584303c strhi r3, [r4, #60] ; 0x3c
ba90: eaffffe2 b ba20 <_Heap_Free+0x12c>
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
ba94: e086c00c add ip, r6, ip
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
ba98: e38c3001 orr r3, ip, #1
ba9c: e58a3004 str r3, [sl, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
baa0: e5923004 ldr r3, [r2, #4]
baa4: e3c33001 bic r3, r3, #1
baa8: e5823004 str r3, [r2, #4]
next_block->prev_size = size;
baac: e785c006 str ip, [r5, r6]
bab0: eaffffda b ba20 <_Heap_Free+0x12c>
00012fe4 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
12fe4: e92d40f0 push {r4, r5, r6, r7, lr}
12fe8: e1a04000 mov r4, r0
12fec: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
12ff0: e1a00001 mov r0, r1 12ff4: e5941010 ldr r1, [r4, #16] 12ff8: e1a07002 mov r7, r2 12ffc: ebfff86d bl 111b8 <__umodsi3> 13000: e2456008 sub r6, r5, #8
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
13004: e5943020 ldr r3, [r4, #32]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
13008: e0600006 rsb r0, r0, r6
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;
1300c: e1500003 cmp r0, r3
13010: 3a000010 bcc 13058 <_Heap_Size_of_alloc_area+0x74>
13014: e5942024 ldr r2, [r4, #36] ; 0x24 13018: e1500002 cmp r0, r2
1301c: 8a00000d bhi 13058 <_Heap_Size_of_alloc_area+0x74>
- 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;
13020: e5906004 ldr r6, [r0, #4] 13024: e3c66001 bic r6, r6, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
13028: e0806006 add r6, r0, r6
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;
1302c: e1530006 cmp r3, r6
13030: 8a000008 bhi 13058 <_Heap_Size_of_alloc_area+0x74>
13034: e1520006 cmp r2, r6
13038: 3a000008 bcc 13060 <_Heap_Size_of_alloc_area+0x7c>
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;
1303c: e5960004 ldr r0, [r6, #4]
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
13040: e2100001 ands r0, r0, #1
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
13044: 12655004 rsbne r5, r5, #4 13048: 10856006 addne r6, r5, r6 1304c: 15876000 strne r6, [r7]
return true;
13050: 13a00001 movne r0, #1
13054: e8bd80f0 pop {r4, r5, r6, r7, pc}
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
13058: e3a00000 mov r0, #0
1305c: e8bd80f0 pop {r4, r5, r6, r7, pc}
13060: e3a00000 mov r0, #0 <== NOT EXECUTED
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
13064: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00007544 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
7544: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
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() ) ) {
7548: e59f35cc ldr r3, [pc, #1484] ; 7b1c <_Heap_Walk+0x5d8>
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
754c: e31200ff tst r2, #255 ; 0xff
if ( !_System_state_Is_up( _System_state_Get() ) ) {
7550: e5933000 ldr r3, [r3]
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
7554: e59f25c4 ldr r2, [pc, #1476] ; 7b20 <_Heap_Walk+0x5dc>
7558: e59f95c4 ldr r9, [pc, #1476] ; 7b24 <_Heap_Walk+0x5e0>
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
755c: e1a0a001 mov sl, r1
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
7560: 11a09002 movne r9, r2
Heap_Control *heap,
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
7564: e5901010 ldr r1, [r0, #16]
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() ) ) {
7568: e3530003 cmp r3, #3
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
756c: e5902014 ldr r2, [r0, #20]
Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block;
7570: e5903024 ldr r3, [r0, #36] ; 0x24
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
7574: e24dd038 sub sp, sp, #56 ; 0x38
7578: e1a04000 mov r4, r0
uintptr_t const page_size = heap->page_size;
757c: e58d1024 str r1, [sp, #36] ; 0x24
uintptr_t const min_block_size = heap->min_block_size;
7580: e58d2028 str r2, [sp, #40] ; 0x28
Heap_Block *const first_block = heap->first_block;
7584: e5908020 ldr r8, [r0, #32]
Heap_Block *const last_block = heap->last_block;
7588: e58d302c str r3, [sp, #44] ; 0x2c
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() ) ) {
758c: 0a000002 beq 759c <_Heap_Walk+0x58>
}
block = next_block;
} while ( block != first_block );
return true;
7590: e3a00001 mov r0, #1
}
7594: e28dd038 add sp, sp, #56 ; 0x38
7598: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
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)(
759c: e594101c ldr r1, [r4, #28]
75a0: e5900018 ldr r0, [r0, #24]
75a4: e2842008 add r2, r4, #8
75a8: e892000c ldm r2, {r2, r3}
75ac: e59dc028 ldr ip, [sp, #40] ; 0x28
75b0: e58d1008 str r1, [sp, #8]
75b4: e59d102c ldr r1, [sp, #44] ; 0x2c
75b8: e58d0004 str r0, [sp, #4]
75bc: e58d1010 str r1, [sp, #16]
75c0: e58d2014 str r2, [sp, #20]
75c4: e58d3018 str r3, [sp, #24]
75c8: e59f2558 ldr r2, [pc, #1368] ; 7b28 <_Heap_Walk+0x5e4>
75cc: e58dc000 str ip, [sp]
75d0: e58d800c str r8, [sp, #12]
75d4: e1a0000a mov r0, sl
75d8: e3a01000 mov r1, #0
75dc: e59d3024 ldr r3, [sp, #36] ; 0x24
75e0: e1a0e00f mov lr, pc
75e4: e12fff19 bx r9
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
75e8: e59d2024 ldr r2, [sp, #36] ; 0x24
75ec: e3520000 cmp r2, #0
75f0: 0a000026 beq 7690 <_Heap_Walk+0x14c>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
75f4: e59d3024 ldr r3, [sp, #36] ; 0x24
75f8: e2135003 ands r5, r3, #3
75fc: 1a00002a bne 76ac <_Heap_Walk+0x168>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
7600: e59d0028 ldr r0, [sp, #40] ; 0x28
7604: e59d1024 ldr r1, [sp, #36] ; 0x24
7608: ebffe564 bl ba0 <__umodsi3>
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
760c: e250b000 subs fp, r0, #0
7610: 1a00002c bne 76c8 <_Heap_Walk+0x184>
7614: e2880008 add r0, r8, #8
7618: e59d1024 ldr r1, [sp, #36] ; 0x24
761c: ebffe55f bl ba0 <__umodsi3>
);
return false;
}
if (
7620: e2506000 subs r6, r0, #0
7624: 1a00002f bne 76e8 <_Heap_Walk+0x1a4>
block = next_block;
} while ( block != first_block );
return true;
}
7628: e598b004 ldr fp, [r8, #4]
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
762c: e21b5001 ands r5, fp, #1
7630: 0a0000cd beq 796c <_Heap_Walk+0x428>
- 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;
7634: e59dc02c ldr ip, [sp, #44] ; 0x2c
7638: e59c3004 ldr r3, [ip, #4]
763c: e3c33001 bic r3, r3, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
7640: e08c3003 add r3, ip, 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;
7644: e5935004 ldr r5, [r3, #4]
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
7648: e2155001 ands r5, r5, #1
764c: 0a000008 beq 7674 <_Heap_Walk+0x130>
);
return false;
}
if (
7650: e1580003 cmp r8, r3
7654: 0a00002b beq 7708 <_Heap_Walk+0x1c4>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
7658: e1a0000a mov r0, sl <== NOT EXECUTED
765c: e3a01001 mov r1, #1 <== NOT EXECUTED
7660: e59f24c4 ldr r2, [pc, #1220] ; 7b2c <_Heap_Walk+0x5e8> <== NOT EXECUTED
7664: e1a0e00f mov lr, pc <== NOT EXECUTED
7668: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
766c: e1a00006 mov r0, r6 <== NOT EXECUTED
7670: eaffffc7 b 7594 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
7674: e1a0000a mov r0, sl
7678: e3a01001 mov r1, #1
767c: e59f24ac ldr r2, [pc, #1196] ; 7b30 <_Heap_Walk+0x5ec>
7680: e1a0e00f mov lr, pc
7684: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7688: e1a00005 mov r0, r5
768c: eaffffc0 b 7594 <_Heap_Walk+0x50>
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
(*printer)( source, true, "page size is zero\n" );
7690: e1a0000a mov r0, sl
7694: e3a01001 mov r1, #1
7698: e59f2494 ldr r2, [pc, #1172] ; 7b34 <_Heap_Walk+0x5f0>
769c: e1a0e00f mov lr, pc
76a0: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
76a4: e59d0024 ldr r0, [sp, #36] ; 0x24
76a8: eaffffb9 b 7594 <_Heap_Walk+0x50>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
76ac: e1a0000a mov r0, sl
76b0: e3a01001 mov r1, #1
76b4: e59f247c ldr r2, [pc, #1148] ; 7b38 <_Heap_Walk+0x5f4>
76b8: e1a0e00f mov lr, pc
76bc: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
76c0: e3a00000 mov r0, #0
76c4: eaffffb2 b 7594 <_Heap_Walk+0x50>
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
76c8: e1a0000a mov r0, sl
76cc: e3a01001 mov r1, #1
76d0: e59f2464 ldr r2, [pc, #1124] ; 7b3c <_Heap_Walk+0x5f8>
76d4: e59d3028 ldr r3, [sp, #40] ; 0x28
76d8: e1a0e00f mov lr, pc
76dc: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
76e0: e1a00005 mov r0, r5
76e4: eaffffaa b 7594 <_Heap_Walk+0x50>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
76e8: e1a0000a mov r0, sl
76ec: e3a01001 mov r1, #1
76f0: e59f2448 ldr r2, [pc, #1096] ; 7b40 <_Heap_Walk+0x5fc>
76f4: e1a03008 mov r3, r8
76f8: e1a0e00f mov lr, pc
76fc: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7700: e1a0000b mov r0, fp
7704: eaffffa2 b 7594 <_Heap_Walk+0x50>
block = next_block;
} while ( block != first_block );
return true;
}
7708: e5945008 ldr r5, [r4, #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 ) {
770c: e1540005 cmp r4, r5
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
7710: e5947010 ldr r7, [r4, #16]
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 ) {
7714: 05943020 ldreq r3, [r4, #32]
7718: 0a00000d beq 7754 <_Heap_Walk+0x210>
block = next_block;
} while ( block != first_block );
return true;
}
771c: e5943020 ldr r3, [r4, #32]
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;
7720: e1530005 cmp r3, r5
7724: 9a000097 bls 7988 <_Heap_Walk+0x444>
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 ) ) {
(*printer)(
7728: e1a0000a mov r0, sl
772c: e3a01001 mov r1, #1
7730: e59f240c ldr r2, [pc, #1036] ; 7b44 <_Heap_Walk+0x600>
7734: e1a03005 mov r3, r5
7738: e1a0e00f mov lr, pc
773c: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7740: e3a00000 mov r0, #0
7744: eaffff92 b 7594 <_Heap_Walk+0x50>
7748: e1a03008 mov r3, r8
774c: e28d8030 add r8, sp, #48 ; 0x30
7750: e8980900 ldm r8, {r8, fp}
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
7754: e1a06008 mov r6, r8
- 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;
7758: e3cb7001 bic r7, fp, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
775c: e0875006 add r5, r7, r6
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;
7760: e1530005 cmp r3, r5
7764: 9a000008 bls 778c <_Heap_Walk+0x248>
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 ) ) {
(*printer)(
7768: e1a0000a mov r0, sl
776c: e58d5000 str r5, [sp]
7770: e3a01001 mov r1, #1
7774: e59f23cc ldr r2, [pc, #972] ; 7b48 <_Heap_Walk+0x604>
7778: e1a03006 mov r3, r6
777c: e1a0e00f mov lr, pc
7780: e12fff19 bx r9
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
7784: e3a00000 mov r0, #0
7788: eaffff81 b 7594 <_Heap_Walk+0x50>
778c: e5943024 ldr r3, [r4, #36] ; 0x24
7790: e1530005 cmp r3, r5
7794: 3afffff3 bcc 7768 <_Heap_Walk+0x224>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
7798: e59d1024 ldr r1, [sp, #36] ; 0x24
779c: e1a00007 mov r0, r7
77a0: ebffe4fe bl ba0 <__umodsi3>
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;
77a4: e59d102c ldr r1, [sp, #44] ; 0x2c
77a8: e0563001 subs r3, r6, r1
77ac: 13a03001 movne r3, #1
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
77b0: e3500000 cmp r0, #0
77b4: 0a000001 beq 77c0 <_Heap_Walk+0x27c>
77b8: e3530000 cmp r3, #0
77bc: 1a0000aa bne 7a6c <_Heap_Walk+0x528>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
77c0: e59d2028 ldr r2, [sp, #40] ; 0x28
77c4: e1520007 cmp r2, r7
77c8: 9a000001 bls 77d4 <_Heap_Walk+0x290>
77cc: e3530000 cmp r3, #0
77d0: 1a0000ae bne 7a90 <_Heap_Walk+0x54c>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
77d4: e1560005 cmp r6, r5
77d8: 3a000001 bcc 77e4 <_Heap_Walk+0x2a0>
77dc: e3530000 cmp r3, #0
77e0: 1a0000b4 bne 7ab8 <_Heap_Walk+0x574>
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;
77e4: e5953004 ldr r3, [r5, #4]
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
77e8: e3130001 tst r3, #1
77ec: e20bb001 and fp, fp, #1
77f0: 0a000018 beq 7858 <_Heap_Walk+0x314>
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
77f4: e35b0000 cmp fp, #0
77f8: 0a00000c beq 7830 <_Heap_Walk+0x2ec>
(*printer)(
77fc: e58d7000 str r7, [sp]
7800: e1a0000a mov r0, sl
7804: e3a01000 mov r1, #0
7808: e59f233c ldr r2, [pc, #828] ; 7b4c <_Heap_Walk+0x608>
780c: e1a03006 mov r3, r6
7810: e1a0e00f mov lr, pc
7814: e12fff19 bx r9
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
7818: e1580005 cmp r8, r5
781c: 0affff5b beq 7590 <_Heap_Walk+0x4c>
7820: e595b004 ldr fp, [r5, #4]
7824: e5943020 ldr r3, [r4, #32]
7828: e1a06005 mov r6, r5
782c: eaffffc9 b 7758 <_Heap_Walk+0x214>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
7830: e58d7000 str r7, [sp]
7834: e5963000 ldr r3, [r6]
7838: e1a0000a mov r0, sl
783c: e58d3004 str r3, [sp, #4]
7840: e1a0100b mov r1, fp
7844: e59f2304 ldr r2, [pc, #772] ; 7b50 <_Heap_Walk+0x60c>
7848: e1a03006 mov r3, r6
784c: e1a0e00f mov lr, pc
7850: e12fff19 bx r9
7854: eaffffef b 7818 <_Heap_Walk+0x2d4>
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 ?
7858: e596200c ldr r2, [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)(
785c: e5943008 ldr r3, [r4, #8]
7860: e1530002 cmp r3, r2
block = next_block;
} while ( block != first_block );
return true;
}
7864: e594100c ldr r1, [r4, #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)(
7868: 059f02e4 ldreq r0, [pc, #740] ; 7b54 <_Heap_Walk+0x610>
786c: 0a000003 beq 7880 <_Heap_Walk+0x33c>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
7870: e59f32e0 ldr r3, [pc, #736] ; 7b58 <_Heap_Walk+0x614>
7874: e1540002 cmp r4, r2
7878: e59f02dc ldr r0, [pc, #732] ; 7b5c <_Heap_Walk+0x618>
787c: 01a00003 moveq r0, r3
block->next,
block->next == last_free_block ?
7880: e5963008 ldr r3, [r6, #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)(
7884: e1510003 cmp r1, r3
7888: 059f12d0 ldreq r1, [pc, #720] ; 7b60 <_Heap_Walk+0x61c>
788c: 0a000003 beq 78a0 <_Heap_Walk+0x35c>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
7890: e59fc2cc ldr ip, [pc, #716] ; 7b64 <_Heap_Walk+0x620>
7894: e1540003 cmp r4, r3
7898: e59f12bc ldr r1, [pc, #700] ; 7b5c <_Heap_Walk+0x618>
789c: 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)(
78a0: e58d2004 str r2, [sp, #4]
78a4: e58d0008 str r0, [sp, #8]
78a8: e58d300c str r3, [sp, #12]
78ac: e58d1010 str r1, [sp, #16]
78b0: e1a03006 mov r3, r6
78b4: e58d7000 str r7, [sp]
78b8: e1a0000a mov r0, sl
78bc: e3a01000 mov r1, #0
78c0: e59f22a0 ldr r2, [pc, #672] ; 7b68 <_Heap_Walk+0x624>
78c4: e1a0e00f mov lr, pc
78c8: e12fff19 bx r9
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
78cc: e5953000 ldr r3, [r5]
78d0: e1570003 cmp r7, r3
78d4: 1a000011 bne 7920 <_Heap_Walk+0x3dc>
);
return false;
}
if ( !prev_used ) {
78d8: e35b0000 cmp fp, #0
78dc: 0a00001a beq 794c <_Heap_Walk+0x408>
block = next_block;
} while ( block != first_block );
return true;
}
78e0: e5943008 ldr r3, [r4, #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 ) {
78e4: e1540003 cmp r4, r3
78e8: 0a000004 beq 7900 <_Heap_Walk+0x3bc>
if ( free_block == block ) {
78ec: e1560003 cmp r6, r3
78f0: 0affffc8 beq 7818 <_Heap_Walk+0x2d4>
return true;
}
free_block = free_block->next;
78f4: 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 ) {
78f8: e1540003 cmp r4, r3
78fc: 1afffffa bne 78ec <_Heap_Walk+0x3a8>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
7900: e1a0000a mov r0, sl
7904: e3a01001 mov r1, #1
7908: e59f225c ldr r2, [pc, #604] ; 7b6c <_Heap_Walk+0x628>
790c: e1a03006 mov r3, r6
7910: e1a0e00f mov lr, pc
7914: e12fff19 bx r9
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
7918: e3a00000 mov r0, #0
791c: eaffff1c b 7594 <_Heap_Walk+0x50>
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
7920: e58d3004 str r3, [sp, #4]
7924: e1a0000a mov r0, sl
7928: e58d7000 str r7, [sp]
792c: e58d5008 str r5, [sp, #8]
7930: e3a01001 mov r1, #1
7934: e59f2234 ldr r2, [pc, #564] ; 7b70 <_Heap_Walk+0x62c>
7938: e1a03006 mov r3, r6
793c: e1a0e00f mov lr, pc
7940: e12fff19 bx r9
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
7944: e3a00000 mov r0, #0
7948: eaffff11 b 7594 <_Heap_Walk+0x50>
return false;
}
if ( !prev_used ) {
(*printer)(
794c: e1a0000a mov r0, sl
7950: e3a01001 mov r1, #1
7954: e59f2218 ldr r2, [pc, #536] ; 7b74 <_Heap_Walk+0x630>
7958: e1a03006 mov r3, r6
795c: e1a0e00f mov lr, pc
7960: e12fff19 bx r9
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
7964: e1a0000b mov r0, fp
7968: eaffff09 b 7594 <_Heap_Walk+0x50>
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
796c: e1a0000a mov r0, sl
7970: e3a01001 mov r1, #1
7974: e59f21fc ldr r2, [pc, #508] ; 7b78 <_Heap_Walk+0x634>
7978: e1a0e00f mov lr, pc
797c: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7980: e1a00005 mov r0, r5
7984: eaffff02 b 7594 <_Heap_Walk+0x50>
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;
7988: e594c024 ldr ip, [r4, #36] ; 0x24
798c: e15c0005 cmp ip, r5
7990: 3affff64 bcc 7728 <_Heap_Walk+0x1e4>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
7994: e2850008 add r0, r5, #8
7998: e1a01007 mov r1, r7
799c: e58d3020 str r3, [sp, #32]
79a0: e58dc01c str ip, [sp, #28]
79a4: ebffe47d bl ba0 <__umodsi3>
);
return false;
}
if (
79a8: e3500000 cmp r0, #0
79ac: e59d3020 ldr r3, [sp, #32]
79b0: e59dc01c ldr ip, [sp, #28]
79b4: 1a000048 bne 7adc <_Heap_Walk+0x598>
- 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;
79b8: e5952004 ldr r2, [r5, #4]
79bc: e3c22001 bic r2, r2, #1
block = next_block;
} while ( block != first_block );
return true;
}
79c0: e0852002 add r2, r5, r2
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;
79c4: e5922004 ldr r2, [r2, #4]
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
79c8: e3120001 tst r2, #1
79cc: 1a00004a bne 7afc <_Heap_Walk+0x5b8>
79d0: e58d8030 str r8, [sp, #48] ; 0x30
79d4: e58db034 str fp, [sp, #52] ; 0x34
79d8: e1a01004 mov r1, r4
79dc: e1a06005 mov r6, r5
79e0: e1a08003 mov r8, r3
79e4: e1a0b00c mov fp, ip
79e8: ea000013 b 7a3c <_Heap_Walk+0x4f8>
return false;
}
prev_block = free_block;
free_block = free_block->next;
79ec: e5955008 ldr r5, [r5, #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 ) {
79f0: e1540005 cmp r4, r5
79f4: 0affff53 beq 7748 <_Heap_Walk+0x204>
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;
79f8: e1580005 cmp r8, r5
79fc: 8affff49 bhi 7728 <_Heap_Walk+0x1e4>
7a00: e155000b cmp r5, fp
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
7a04: e2850008 add r0, r5, #8
7a08: e1a01007 mov r1, r7
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;
7a0c: 8affff45 bhi 7728 <_Heap_Walk+0x1e4>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
7a10: ebffe462 bl ba0 <__umodsi3>
);
return false;
}
if (
7a14: e3500000 cmp r0, #0
7a18: 1a00002f bne 7adc <_Heap_Walk+0x598>
- 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;
7a1c: e5953004 ldr r3, [r5, #4]
7a20: e3c33001 bic r3, r3, #1
block = next_block;
} while ( block != first_block );
return true;
}
7a24: e0833005 add r3, r3, r5
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;
7a28: e5933004 ldr r3, [r3, #4]
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
7a2c: e3130001 tst r3, #1
7a30: 1a000031 bne 7afc <_Heap_Walk+0x5b8>
7a34: e1a01006 mov r1, r6
7a38: e1a06005 mov r6, r5
);
return false;
}
if ( free_block->prev != prev_block ) {
7a3c: e595200c ldr r2, [r5, #12]
7a40: e1520001 cmp r2, r1
7a44: 0affffe8 beq 79ec <_Heap_Walk+0x4a8>
(*printer)(
7a48: e58d2000 str r2, [sp]
7a4c: e1a0000a mov r0, sl
7a50: e3a01001 mov r1, #1
7a54: e59f2120 ldr r2, [pc, #288] ; 7b7c <_Heap_Walk+0x638>
7a58: e1a03005 mov r3, r5
7a5c: e1a0e00f mov lr, pc
7a60: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7a64: e3a00000 mov r0, #0
7a68: eafffec9 b 7594 <_Heap_Walk+0x50>
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
7a6c: e1a0000a mov r0, sl
7a70: e58d7000 str r7, [sp]
7a74: e3a01001 mov r1, #1
7a78: e59f2100 ldr r2, [pc, #256] ; 7b80 <_Heap_Walk+0x63c>
7a7c: e1a03006 mov r3, r6
7a80: e1a0e00f mov lr, pc
7a84: e12fff19 bx r9
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
7a88: e3a00000 mov r0, #0
7a8c: eafffec0 b 7594 <_Heap_Walk+0x50>
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
7a90: e58d2004 str r2, [sp, #4]
7a94: e1a0000a mov r0, sl
7a98: e58d7000 str r7, [sp]
7a9c: e3a01001 mov r1, #1
7aa0: e59f20dc ldr r2, [pc, #220] ; 7b84 <_Heap_Walk+0x640>
7aa4: e1a03006 mov r3, r6
7aa8: e1a0e00f mov lr, pc
7aac: e12fff19 bx r9
block,
block_size,
min_block_size
);
return false;
7ab0: e3a00000 mov r0, #0
7ab4: eafffeb6 b 7594 <_Heap_Walk+0x50>
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
7ab8: e1a0000a mov r0, sl
7abc: e58d5000 str r5, [sp]
7ac0: e3a01001 mov r1, #1
7ac4: e59f20bc ldr r2, [pc, #188] ; 7b88 <_Heap_Walk+0x644>
7ac8: e1a03006 mov r3, r6
7acc: e1a0e00f mov lr, pc
7ad0: e12fff19 bx r9
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
7ad4: e3a00000 mov r0, #0
7ad8: eafffead b 7594 <_Heap_Walk+0x50>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
7adc: e1a0000a mov r0, sl
7ae0: e3a01001 mov r1, #1
7ae4: e59f20a0 ldr r2, [pc, #160] ; 7b8c <_Heap_Walk+0x648>
7ae8: e1a03005 mov r3, r5
7aec: e1a0e00f mov lr, pc
7af0: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7af4: e3a00000 mov r0, #0
7af8: eafffea5 b 7594 <_Heap_Walk+0x50>
return false;
}
if ( _Heap_Is_used( free_block ) ) {
(*printer)(
7afc: e1a0000a mov r0, sl
7b00: e3a01001 mov r1, #1
7b04: e59f2084 ldr r2, [pc, #132] ; 7b90 <_Heap_Walk+0x64c>
7b08: e1a03005 mov r3, r5
7b0c: e1a0e00f mov lr, pc
7b10: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7b14: e3a00000 mov r0, #0
7b18: eafffe9d b 7594 <_Heap_Walk+0x50>
00006a20 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
6a20: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
6a24: e5904034 ldr r4, [r0, #52] ; 0x34
6a28: e3540000 cmp r4, #0
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
6a2c: e24dd014 sub sp, sp, #20
6a30: e1a05000 mov r5, r0
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
6a34: e1d070b8 ldrh r7, [r0, #8]
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
6a38: 0a00009b beq 6cac <_Objects_Extend_information+0x28c>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
6a3c: e1d081b4 ldrh r8, [r0, #20]
6a40: e1d0a1b0 ldrh sl, [r0, #16]
6a44: e1a01008 mov r1, r8
6a48: e1a0000a mov r0, sl
6a4c: eb002993 bl 110a0 <__aeabi_uidiv>
6a50: e1a03800 lsl r3, r0, #16
for ( ; block < block_count; block++ ) {
6a54: e1b03823 lsrs r3, r3, #16
6a58: 0a000099 beq 6cc4 <_Objects_Extend_information+0x2a4>
if ( information->object_blocks[ block ] == NULL ) {
6a5c: e5949000 ldr r9, [r4]
6a60: e3590000 cmp r9, #0
6a64: 01a01008 moveq r1, r8
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
6a68: 01a06007 moveq r6, r7
index_base = minimum_index; block = 0;
6a6c: 01a04009 moveq r4, r9
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
6a70: 0a00000c beq 6aa8 <_Objects_Extend_information+0x88>
6a74: e1a02004 mov r2, r4
6a78: e1a01008 mov r1, r8
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
6a7c: e1a06007 mov r6, r7
index_base = minimum_index; block = 0;
6a80: e3a04000 mov r4, #0
6a84: ea000002 b 6a94 <_Objects_Extend_information+0x74>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
6a88: e5b29004 ldr r9, [r2, #4]!
6a8c: e3590000 cmp r9, #0
6a90: 0a000004 beq 6aa8 <_Objects_Extend_information+0x88>
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
6a94: e2844001 add r4, r4, #1
6a98: e1530004 cmp r3, r4
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
break;
} else
index_base += information->allocation_size;
6a9c: e0866008 add r6, r6, r8
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
6aa0: 8afffff8 bhi 6a88 <_Objects_Extend_information+0x68>
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
6aa4: e3a09001 mov r9, #1
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
6aa8: e08aa001 add sl, sl, r1
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
6aac: e35a0801 cmp sl, #65536 ; 0x10000
6ab0: 2a000063 bcs 6c44 <_Objects_Extend_information+0x224>
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
if ( information->auto_extend ) {
6ab4: e5d52012 ldrb r2, [r5, #18]
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
6ab8: e5950018 ldr r0, [r5, #24]
if ( information->auto_extend ) {
6abc: e3520000 cmp r2, #0
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
6ac0: e0000091 mul r0, r1, r0
if ( information->auto_extend ) {
6ac4: 1a000060 bne 6c4c <_Objects_Extend_information+0x22c>
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
6ac8: e58d3000 str r3, [sp]
6acc: eb000838 bl 8bb4 <_Workspace_Allocate_or_fatal_error>
6ad0: e59d3000 ldr r3, [sp]
6ad4: e1a08000 mov r8, r0
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
6ad8: e3590000 cmp r9, #0
6adc: 0a000039 beq 6bc8 <_Objects_Extend_information+0x1a8>
*/
/*
* Up the block count and maximum
*/
block_count++;
6ae0: e283b001 add fp, r3, #1
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
6ae4: e08b008b add r0, fp, fp, lsl #1
((maximum + minimum_index) * sizeof(Objects_Control *));
6ae8: e08a0000 add r0, sl, r0
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
6aec: e0800007 add r0, r0, r7
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
6af0: e1a00100 lsl r0, r0, #2
6af4: e58d3000 str r3, [sp]
6af8: eb000823 bl 8b8c <_Workspace_Allocate>
if ( !object_blocks ) {
6afc: e2509000 subs r9, r0, #0
6b00: e59d3000 ldr r3, [sp]
6b04: 0a000073 beq 6cd8 <_Objects_Extend_information+0x2b8>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
6b08: e1d521b0 ldrh r2, [r5, #16]
6b0c: e1570002 cmp r7, r2
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
6b10: e089c10b add ip, r9, fp, lsl #2
6b14: e089b18b add fp, r9, fp, lsl #3
6b18: 3a000051 bcc 6c64 <_Objects_Extend_information+0x244>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
6b1c: e3570000 cmp r7, #0
6b20: 13a02000 movne r2, #0
6b24: 11a0100b movne r1, fp
local_table[ index ] = NULL;
6b28: 11a00002 movne r0, r2
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
6b2c: 0a000003 beq 6b40 <_Objects_Extend_information+0x120>
6b30: e2822001 add r2, r2, #1
6b34: e1570002 cmp r7, r2
local_table[ index ] = NULL;
6b38: e4810004 str r0, [r1], #4
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
6b3c: 8afffffb bhi 6b30 <_Objects_Extend_information+0x110>
6b40: e1a03103 lsl r3, r3, #2
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
6b44: e1d511b4 ldrh r1, [r5, #20]
6b48: e0861001 add r1, r6, r1
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
6b4c: e3a00000 mov r0, #0
inactive_per_block[block_count] = 0;
for ( index=index_base ;
6b50: e1560001 cmp r6, r1
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
6b54: e7890003 str r0, [r9, r3]
inactive_per_block[block_count] = 0;
6b58: e78c0003 str r0, [ip, r3]
for ( index=index_base ;
6b5c: 2a000005 bcs 6b78 <_Objects_Extend_information+0x158>
6b60: e08b2106 add r2, fp, r6, lsl #2
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
6b64: e1a03006 mov r3, r6
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
6b68: e2833001 add r3, r3, #1
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
6b6c: e1530001 cmp r3, r1
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
6b70: e4820004 str r0, [r2], #4
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
6b74: 3afffffb bcc 6b68 <_Objects_Extend_information+0x148>
6b78: e10f3000 mrs r3, CPSR
6b7c: e3832080 orr r2, r3, #128 ; 0x80
6b80: e129f002 msr CPSR_fc, r2
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
6b84: e5952000 ldr r2, [r5]
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
6b88: e1d510b4 ldrh r1, [r5, #4]
6b8c: e1a02c02 lsl r2, r2, #24
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
6b90: e1a0a80a lsl sl, sl, #16
6b94: e3822801 orr r2, r2, #65536 ; 0x10000
6b98: e1a0a82a lsr sl, sl, #16
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
6b9c: e1822d81 orr r2, r2, r1, lsl #27
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
6ba0: e182200a orr r2, r2, sl
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
6ba4: e5950034 ldr r0, [r5, #52] ; 0x34
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
6ba8: e585c030 str ip, [r5, #48] ; 0x30
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
6bac: e5859034 str r9, [r5, #52] ; 0x34
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
6bb0: e585b01c str fp, [r5, #28]
information->maximum = (Objects_Maximum) maximum;
6bb4: e1c5a1b0 strh sl, [r5, #16]
information->maximum_id = _Objects_Build_id(
6bb8: e585200c str r2, [r5, #12]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
6bbc: e129f003 msr CPSR_fc, r3
information->maximum
);
_ISR_Enable( level );
if ( old_tables )
6bc0: e3500000 cmp r0, #0
_Workspace_Free( old_tables );
6bc4: 1b0007f6 blne 8ba4 <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
6bc8: e5953034 ldr r3, [r5, #52] ; 0x34
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
6bcc: e28d7008 add r7, sp, #8
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
6bd0: e7838104 str r8, [r3, r4, lsl #2]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
6bd4: e1a01008 mov r1, r8
6bd8: e1a00007 mov r0, r7
6bdc: e1d521b4 ldrh r2, [r5, #20]
6be0: e5953018 ldr r3, [r5, #24]
6be4: eb001220 bl b46c <_Chain_Initialize>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
6be8: e1a04104 lsl r4, r4, #2
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
6bec: e2858020 add r8, r5, #32
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
6bf0: ea000009 b 6c1c <_Objects_Extend_information+0x1fc>
6bf4: e5953000 ldr r3, [r5]
the_object->id = _Objects_Build_id(
6bf8: e1d520b4 ldrh r2, [r5, #4]
6bfc: e1a03c03 lsl r3, r3, #24
6c00: e3833801 orr r3, r3, #65536 ; 0x10000
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
6c04: e1833d82 orr r3, r3, r2, lsl #27
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
6c08: e1833006 orr r3, r3, r6
6c0c: e5813008 str r3, [r1, #8]
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
6c10: e1a00008 mov r0, r8
6c14: ebfffce6 bl 5fb4 <_Chain_Append>
index++;
6c18: e2866001 add r6, r6, #1
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
6c1c: e1a00007 mov r0, r7
6c20: ebfffcf6 bl 6000 <_Chain_Get>
6c24: e2501000 subs r1, r0, #0
6c28: 1afffff1 bne 6bf4 <_Objects_Extend_information+0x1d4>
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
6c2c: e1d522bc ldrh r2, [r5, #44] ; 0x2c
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
6c30: e1d531b4 ldrh r3, [r5, #20]
6c34: e5951030 ldr r1, [r5, #48] ; 0x30
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
6c38: e0832002 add r2, r3, r2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
6c3c: e7813004 str r3, [r1, r4]
information->inactive =
6c40: e1c522bc strh r2, [r5, #44] ; 0x2c
(Objects_Maximum)(information->inactive + information->allocation_size);
}
6c44: e28dd014 add sp, sp, #20
6c48: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
if ( information->auto_extend ) {
new_object_block = _Workspace_Allocate( block_size );
6c4c: e58d3000 str r3, [sp]
6c50: eb0007cd bl 8b8c <_Workspace_Allocate>
if ( !new_object_block )
6c54: e2508000 subs r8, r0, #0
6c58: e59d3000 ldr r3, [sp]
6c5c: 1affff9d bne 6ad8 <_Objects_Extend_information+0xb8>
6c60: eafffff7 b 6c44 <_Objects_Extend_information+0x224>
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
6c64: e1a03103 lsl r3, r3, #2
6c68: e5951034 ldr r1, [r5, #52] ; 0x34
6c6c: e1a02003 mov r2, r3
6c70: e88d1008 stm sp, {r3, ip}
6c74: eb001d98 bl e2dc <memcpy>
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
6c78: e89d1008 ldm sp, {r3, ip}
6c7c: e1a0000c mov r0, ip
6c80: e1a02003 mov r2, r3
6c84: e5951030 ldr r1, [r5, #48] ; 0x30
6c88: eb001d93 bl e2dc <memcpy>
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
6c8c: e1d521b0 ldrh r2, [r5, #16]
6c90: e0872002 add r2, r7, r2
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
6c94: e1a0000b mov r0, fp
6c98: e595101c ldr r1, [r5, #28]
6c9c: e1a02102 lsl r2, r2, #2
6ca0: eb001d8d bl e2dc <memcpy>
6ca4: e89d1008 ldm sp, {r3, ip}
6ca8: eaffffa5 b 6b44 <_Objects_Extend_information+0x124>
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
6cac: e1d0a1b0 ldrh sl, [r0, #16]
6cb0: e1d011b4 ldrh r1, [r0, #20]
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
6cb4: e1a06007 mov r6, r7
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
6cb8: e3a09001 mov r9, #1
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
6cbc: e1a03004 mov r3, r4
6cc0: eaffff78 b 6aa8 <_Objects_Extend_information+0x88>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
6cc4: e1a01008 mov r1, r8 <== NOT EXECUTED
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
6cc8: e1a06007 mov r6, r7 <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
6ccc: e3a09001 mov r9, #1 <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
6cd0: e1a04003 mov r4, r3 <== NOT EXECUTED
6cd4: eaffff73 b 6aa8 <_Objects_Extend_information+0x88> <== NOT EXECUTED
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
6cd8: e1a00008 mov r0, r8
6cdc: eb0007b0 bl 8ba4 <_Workspace_Free>
return;
6ce0: eaffffd7 b 6c44 <_Objects_Extend_information+0x224>
00007050 <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
7050: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
7054: e1d040b8 ldrh r4, [r0, #8]
block_count = (information->maximum - index_base) /
7058: e1d051b4 ldrh r5, [r0, #20]
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
705c: e1a06000 mov r6, r0
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
7060: e1d001b0 ldrh r0, [r0, #16]
7064: e1a01005 mov r1, r5
7068: e0640000 rsb r0, r4, r0
706c: eb00280b bl 110a0 <__aeabi_uidiv>
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
7070: e3500000 cmp r0, #0
7074: 08bd80f0 popeq {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
7078: e5962030 ldr r2, [r6, #48] ; 0x30
707c: e5923000 ldr r3, [r2]
7080: e1550003 cmp r5, r3
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
7084: 13a03000 movne r3, #0
if ( information->inactive_per_block[ block ] ==
7088: 1a000005 bne 70a4 <_Objects_Shrink_information+0x54>
708c: ea000008 b 70b4 <_Objects_Shrink_information+0x64> <== NOT EXECUTED
7090: e5b21004 ldr r1, [r2, #4]!
7094: e1550001 cmp r5, r1
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
7098: e0844005 add r4, r4, r5
709c: e1a07103 lsl r7, r3, #2
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
70a0: 0a000004 beq 70b8 <_Objects_Shrink_information+0x68>
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
70a4: e2833001 add r3, r3, #1
70a8: e1500003 cmp r0, r3
70ac: 8afffff7 bhi 7090 <_Objects_Shrink_information+0x40>
70b0: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
70b4: e3a07000 mov r7, #0 <== NOT EXECUTED
information->allocation_size ) {
/*
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) information->Inactive.first;
70b8: e5960020 ldr r0, [r6, #32]
70bc: ea000002 b 70cc <_Objects_Shrink_information+0x7c>
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
70c0: e3550000 cmp r5, #0
70c4: 0a00000b beq 70f8 <_Objects_Shrink_information+0xa8>
index = _Objects_Get_index( the_object->id );
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
70c8: e1a00005 mov r0, r5
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) information->Inactive.first;
do {
index = _Objects_Get_index( the_object->id );
70cc: e1d030b8 ldrh r3, [r0, #8]
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
70d0: e1530004 cmp r3, r4
index = _Objects_Get_index( the_object->id );
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
70d4: e5905000 ldr r5, [r0]
if ((index >= index_base) &&
70d8: 3afffff8 bcc 70c0 <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
70dc: e1d621b4 ldrh r2, [r6, #20]
70e0: e0842002 add r2, r4, r2
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
70e4: e1530002 cmp r3, r2
70e8: 2afffff4 bcs 70c0 <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
70ec: ebfffbbb bl 5fe0 <_Chain_Extract>
}
}
while ( the_object );
70f0: e3550000 cmp r5, #0
70f4: 1afffff3 bne 70c8 <_Objects_Shrink_information+0x78>
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
70f8: e5963034 ldr r3, [r6, #52] ; 0x34
70fc: e7930007 ldr r0, [r3, r7]
7100: eb0006a7 bl 8ba4 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
7104: e1d602bc ldrh r0, [r6, #44] ; 0x2c
7108: e1d631b4 ldrh r3, [r6, #20]
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
710c: e5961034 ldr r1, [r6, #52] ; 0x34
information->inactive_per_block[ block ] = 0;
7110: e5962030 ldr r2, [r6, #48] ; 0x30
information->inactive -= information->allocation_size;
7114: e0633000 rsb r3, r3, r0
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
7118: e7815007 str r5, [r1, r7]
information->inactive_per_block[ block ] = 0;
711c: e7825007 str r5, [r2, r7]
information->inactive -= information->allocation_size;
7120: e1c632bc strh r3, [r6, #44] ; 0x2c
return;
7124: e8bd80f0 pop {r4, r5, r6, r7, pc}
0000d9a0 <_POSIX_signals_Clear_process_signals>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
d9a0: e10f2000 mrs r2, CPSR
d9a4: e3823080 orr r3, r2, #128 ; 0x80
d9a8: e129f003 msr CPSR_fc, r3
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
d9ac: e59f1050 ldr r1, [pc, #80] ; da04 <_POSIX_signals_Clear_process_signals+0x64>
d9b0: e0803080 add r3, r0, r0, lsl #1
d9b4: e7911103 ldr r1, [r1, r3, lsl #2]
d9b8: e3510002 cmp r1, #2
d9bc: e1a01103 lsl r1, r3, #2
d9c0: 0a000007 beq d9e4 <_POSIX_signals_Clear_process_signals+0x44>
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
d9c4: e59f303c ldr r3, [pc, #60] ; da08 <_POSIX_signals_Clear_process_signals+0x68>
d9c8: e5931000 ldr r1, [r3]
d9cc: e3a0c001 mov ip, #1
d9d0: e2400001 sub r0, r0, #1
d9d4: e1c1001c bic r0, r1, ip, lsl r0
d9d8: e5830000 str r0, [r3]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
d9dc: e129f002 msr CPSR_fc, r2
}
_ISR_Enable( level );
}
d9e0: e12fff1e bx lr
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
d9e4: e59fc020 ldr ip, [pc, #32] ; da0c <_POSIX_signals_Clear_process_signals+0x6c>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
d9e8: e2811004 add r1, r1, #4
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
d9ec: e79c3103 ldr r3, [ip, r3, lsl #2]
d9f0: e081c00c add ip, r1, ip
d9f4: e153000c cmp r3, ip
d9f8: 0afffff1 beq d9c4 <_POSIX_signals_Clear_process_signals+0x24>
d9fc: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
}
da00: e12fff1e bx lr <== NOT EXECUTED
00021e84 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
21e84: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
21e88: e5905010 ldr r5, [r0, #16] 21e8c: e3c534ef bic r3, r5, #-285212672 ; 0xef000000 21e90: e3c338ff bic r3, r3, #16711680 ; 0xff0000 21e94: e3c33c7f bic r3, r3, #32512 ; 0x7f00 21e98: e3a0c201 mov ip, #268435456 ; 0x10000000 21e9c: e3c330ff bic r3, r3, #255 ; 0xff 21ea0: e28cc902 add ip, ip, #32768 ; 0x8000 21ea4: e2417001 sub r7, r1, #1 21ea8: e3a06001 mov r6, #1 21eac: e153000c cmp r3, ip
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
21eb0: e1a04000 mov r4, r0
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
21eb4: e5903108 ldr r3, [r0, #264] ; 0x108 21eb8: e1a07716 lsl r7, r6, r7
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
21ebc: 0a00001b beq 21f30 <_POSIX_signals_Unblock_thread+0xac>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
21ec0: e59330d0 ldr r3, [r3, #208] ; 0xd0 21ec4: e1d77003 bics r7, r7, r3
21ec8: 0a000016 beq 21f28 <_POSIX_signals_Unblock_thread+0xa4>
* it is not blocked, THEN
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
21ecc: e2157201 ands r7, r5, #268435456 ; 0x10000000
21ed0: 0a000012 beq 21f20 <_POSIX_signals_Unblock_thread+0x9c>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
21ed4: e3c564ff bic r6, r5, #-16777216 ; 0xff000000 21ed8: e3c6673f bic r6, r6, #16515072 ; 0xfc0000 21edc: e3c66c41 bic r6, r6, #16640 ; 0x4100 21ee0: e3c6601f bic r6, r6, #31
the_thread->Wait.return_code = EINTR;
21ee4: e3a03004 mov r3, #4
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
21ee8: e3560000 cmp r6, #0
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
the_thread->Wait.return_code = EINTR;
21eec: e5803034 str r3, [r0, #52] ; 0x34
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
21ef0: 1a00002e bne 21fb0 <_POSIX_signals_Unblock_thread+0x12c>
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
21ef4: e2150008 ands r0, r5, #8
21ef8: 08bd80f0 popeq {r4, r5, r6, r7, pc}
(void) _Watchdog_Remove( &the_thread->Timer );
21efc: e2840048 add r0, r4, #72 ; 0x48 21f00: ebffb040 bl e008 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
21f04: e3a01201 mov r1, #268435456 ; 0x10000000 21f08: e2811bff add r1, r1, #261120 ; 0x3fc00 21f0c: e1a00004 mov r0, r4 21f10: e2811ffe add r1, r1, #1016 ; 0x3f8 21f14: ebffaaa8 bl c9bc <_Thread_Clear_state>
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
21f18: e1a00006 mov r0, r6
21f1c: e8bd80f0 pop {r4, r5, r6, r7, pc}
else if ( _States_Is_delaying(the_thread->current_state) ) {
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
21f20: e3550000 cmp r5, #0
21f24: 0a000016 beq 21f84 <_POSIX_signals_Unblock_thread+0x100>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
21f28: e1a00007 mov r0, r7
21f2c: e8bd80f0 pop {r4, r5, r6, r7, pc}
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
21f30: e5900030 ldr r0, [r0, #48] ; 0x30 21f34: e1170000 tst r7, r0
21f38: 0a00000d beq 21f74 <_POSIX_signals_Unblock_thread+0xf0>
the_thread->Wait.return_code = EINTR;
21f3c: e3a03004 mov r3, #4
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
21f40: e3520000 cmp r2, #0
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
the_thread->Wait.return_code = EINTR;
21f44: e5843034 str r3, [r4, #52] ; 0x34
the_info = (siginfo_t *) the_thread->Wait.return_argument;
21f48: e5943028 ldr r3, [r4, #40] ; 0x28
if ( !info ) {
the_info->si_signo = signo;
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
21f4c: 18920007 ldmne r2, {r0, r1, r2}
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
21f50: 05831000 streq r1, [r3]
the_info->si_code = SI_USER;
21f54: 03a01001 moveq r1, #1
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
21f58: 18830007 stmne r3, {r0, r1, r2}
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
the_info->si_code = SI_USER;
21f5c: 05831004 streq r1, [r3, #4]
the_info->si_value.sival_int = 0;
21f60: 05832008 streq r2, [r3, #8]
} else {
*the_info = *info;
}
_Thread_queue_Extract_with_proxy( the_thread );
21f64: e1a00004 mov r0, r4 21f68: ebffad5b bl d4dc <_Thread_queue_Extract_with_proxy>
return true;
21f6c: e3a00001 mov r0, #1
21f70: e8bd80f0 pop {r4, r5, r6, r7, pc}
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
21f74: e59300d0 ldr r0, [r3, #208] ; 0xd0 21f78: e1d70000 bics r0, r7, r0
21f7c: 1affffee bne 21f3c <_POSIX_signals_Unblock_thread+0xb8>
21f80: e8bd80f0 pop {r4, r5, r6, r7, pc}
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
21f84: e59f2030 ldr r2, [pc, #48] ; 21fbc <_POSIX_signals_Unblock_thread+0x138>
21f88: e5920000 ldr r0, [r2]
21f8c: e3500000 cmp r0, #0
21f90: 08bd80f0 popeq {r4, r5, r6, r7, pc}
21f94: e5923004 ldr r3, [r2, #4]
21f98: e1540003 cmp r4, r3
_Thread_Dispatch_necessary = true;
21f9c: 05c26010 strbeq r6, [r2, #16]
}
}
return false;
21fa0: 01a00005 moveq r0, r5
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
21fa4: 08bd80f0 popeq {r4, r5, r6, r7, pc}
_Thread_Dispatch_necessary = true;
}
}
return false;
21fa8: e1a00005 mov r0, r5 <== NOT EXECUTED
}
21fac: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
_Thread_queue_Extract_with_proxy( the_thread );
21fb0: ebffad49 bl d4dc <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
21fb4: e3a00000 mov r0, #0 <== NOT EXECUTED
21fb8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00006640 <_TOD_Validate>:
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
6640: e59f30b8 ldr r3, [pc, #184] ; 6700 <_TOD_Validate+0xc0>
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
6644: e92d4010 push {r4, lr}
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
6648: e2504000 subs r4, r0, #0
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
664c: e593100c ldr r1, [r3, #12]
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
6650: 01a00004 moveq r0, r4
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
6654: 08bd8010 popeq {r4, pc}
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
6658: e3a0093d mov r0, #999424 ; 0xf4000
665c: e2800d09 add r0, r0, #576 ; 0x240
6660: eb0048d4 bl 189b8 <__aeabi_uidiv>
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
6664: e5943018 ldr r3, [r4, #24]
6668: e1500003 cmp r0, r3
666c: 9a00001f bls 66f0 <_TOD_Validate+0xb0>
(the_tod->ticks >= ticks_per_second) ||
6670: e5943014 ldr r3, [r4, #20]
6674: e353003b cmp r3, #59 ; 0x3b
6678: 8a00001c bhi 66f0 <_TOD_Validate+0xb0>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
667c: e5943010 ldr r3, [r4, #16]
6680: e353003b cmp r3, #59 ; 0x3b
6684: 8a000019 bhi 66f0 <_TOD_Validate+0xb0>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
6688: e594300c ldr r3, [r4, #12]
668c: e3530017 cmp r3, #23
6690: 8a000016 bhi 66f0 <_TOD_Validate+0xb0>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
6694: e5940004 ldr r0, [r4, #4]
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
6698: e3500000 cmp r0, #0
669c: 08bd8010 popeq {r4, pc}
(the_tod->month == 0) ||
66a0: e350000c cmp r0, #12
66a4: 8a000011 bhi 66f0 <_TOD_Validate+0xb0>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
66a8: e5942000 ldr r2, [r4]
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
66ac: e3a03d1f mov r3, #1984 ; 0x7c0
66b0: e2833003 add r3, r3, #3
66b4: e1520003 cmp r2, r3
66b8: 9a00000c bls 66f0 <_TOD_Validate+0xb0>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
66bc: e5944008 ldr r4, [r4, #8]
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
66c0: e3540000 cmp r4, #0
66c4: 0a00000b beq 66f8 <_TOD_Validate+0xb8>
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
66c8: e3120003 tst r2, #3
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
66cc: 059f3030 ldreq r3, [pc, #48] ; 6704 <_TOD_Validate+0xc4>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
66d0: 159f302c ldrne r3, [pc, #44] ; 6704 <_TOD_Validate+0xc4>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
66d4: 0280000d addeq r0, r0, #13
66d8: 07930100 ldreq r0, [r3, r0, lsl #2]
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
66dc: 17930100 ldrne r0, [r3, r0, lsl #2]
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
66e0: e1500004 cmp r0, r4
66e4: 33a00000 movcc r0, #0
66e8: 23a00001 movcs r0, #1
66ec: e8bd8010 pop {r4, pc}
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
66f0: e3a00000 mov r0, #0
66f4: e8bd8010 pop {r4, pc}
66f8: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( the_tod->day > days_in_month )
return false;
return true;
}
66fc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00007cf8 <_Thread_queue_Enqueue_priority>:
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
7cf8: e5913014 ldr r3, [r1, #20]
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
7cfc: e92d0ff0 push {r4, r5, r6, r7, r8, r9, sl, fp}
7d00: e281403c add r4, r1, #60 ; 0x3c
Chain_Node *previous_node;
Chain_Node *search_node;
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
7d04: e281c038 add ip, r1, #56 ; 0x38
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
7d08: e5814038 str r4, [r1, #56] ; 0x38
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 ) )
7d0c: e3130020 tst r3, #32
the_chain->permanent_null = NULL;
7d10: e3a04000 mov r4, #0
7d14: e581403c str r4, [r1, #60] ; 0x3c
the_chain->last = _Chain_Head(the_chain);
7d18: e581c040 str ip, [r1, #64] ; 0x40
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
7d1c: e1a08323 lsr r8, r3, #6
_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;
7d20: e5905038 ldr r5, [r0, #56] ; 0x38
if ( _Thread_queue_Is_reverse_search( priority ) )
7d24: 1a00001f bne 7da8 <_Thread_queue_Enqueue_priority+0xb0>
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
7d28: e0888088 add r8, r8, r8, lsl #1
7d2c: e1a09108 lsl r9, r8, #2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
7d30: e2898004 add r8, r9, #4
7d34: e0808008 add r8, r0, r8
7d38: e0809009 add r9, r0, r9
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
7d3c: e10f7000 mrs r7, CPSR
7d40: e387c080 orr ip, r7, #128 ; 0x80
7d44: e129f00c msr CPSR_fc, ip
7d48: e1a0a007 mov sl, r7
7d4c: e599c000 ldr ip, [r9]
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
7d50: e15c0008 cmp ip, r8
7d54: 1a000009 bne 7d80 <_Thread_queue_Enqueue_priority+0x88>
7d58: ea000054 b 7eb0 <_Thread_queue_Enqueue_priority+0x1b8>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
7d5c: e10f6000 mrs r6, CPSR
7d60: e129f007 msr CPSR_fc, r7
7d64: e129f006 msr CPSR_fc, r6
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
7d68: e59c6010 ldr r6, [ip, #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) ) {
7d6c: e1150006 tst r5, r6
7d70: 0a000036 beq 7e50 <_Thread_queue_Enqueue_priority+0x158>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
7d74: e59cc000 ldr ip, [ip]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
7d78: e15c0008 cmp ip, r8
7d7c: 0a000002 beq 7d8c <_Thread_queue_Enqueue_priority+0x94>
search_priority = search_thread->current_priority;
7d80: e59c4014 ldr r4, [ip, #20]
if ( priority <= search_priority )
7d84: e1530004 cmp r3, r4
7d88: 8afffff3 bhi 7d5c <_Thread_queue_Enqueue_priority+0x64>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
7d8c: e5905030 ldr r5, [r0, #48] ; 0x30
7d90: e3550001 cmp r5, #1
7d94: 0a00002f beq 7e58 <_Thread_queue_Enqueue_priority+0x160>
* 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;
7d98: e582a000 str sl, [r2]
return the_thread_queue->sync_state; }
7d9c: e1a00005 mov r0, r5
7da0: e8bd0ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp}
7da4: e12fff1e bx lr
_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 ];
7da8: e0888088 add r8, r8, r8, lsl #1
7dac: e0808108 add r8, r0, r8, lsl #2
7db0: e59f9100 ldr r9, [pc, #256] ; 7eb8 <_Thread_queue_Enqueue_priority+0x1c0>
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
7db4: e1a0b008 mov fp, r8
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
7db8: e5d94000 ldrb r4, [r9]
7dbc: e2844001 add r4, r4, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
7dc0: e10f7000 mrs r7, CPSR
7dc4: e387c080 orr ip, r7, #128 ; 0x80
7dc8: e129f00c msr CPSR_fc, ip
7dcc: e1a0a007 mov sl, r7
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
7dd0: e59bc008 ldr ip, [fp, #8]
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
7dd4: e15c0008 cmp ip, r8
7dd8: 1a000009 bne 7e04 <_Thread_queue_Enqueue_priority+0x10c>
7ddc: ea00000b b 7e10 <_Thread_queue_Enqueue_priority+0x118>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
7de0: e10f6000 mrs r6, CPSR
7de4: e129f007 msr CPSR_fc, r7
7de8: e129f006 msr CPSR_fc, r6
7dec: e59c6010 ldr r6, [ip, #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) ) {
7df0: e1150006 tst r5, r6
7df4: 0a000013 beq 7e48 <_Thread_queue_Enqueue_priority+0x150>
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
7df8: e59cc004 ldr ip, [ip, #4]
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
7dfc: e15c0008 cmp ip, r8
7e00: 0a000002 beq 7e10 <_Thread_queue_Enqueue_priority+0x118>
search_priority = search_thread->current_priority;
7e04: e59c4014 ldr r4, [ip, #20]
if ( priority >= search_priority )
7e08: e1530004 cmp r3, r4
7e0c: 3afffff3 bcc 7de0 <_Thread_queue_Enqueue_priority+0xe8>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
7e10: e5905030 ldr r5, [r0, #48] ; 0x30
7e14: e3550001 cmp r5, #1
7e18: 1affffde bne 7d98 <_Thread_queue_Enqueue_priority+0xa0>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
7e1c: e1530004 cmp r3, r4
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
7e20: e3a03000 mov r3, #0
7e24: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
7e28: 0a000016 beq 7e88 <_Thread_queue_Enqueue_priority+0x190>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
7e2c: e59c3000 ldr r3, [ip]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
7e30: e8811008 stm r1, {r3, ip}
search_node->next = the_node; next_node->previous = the_node;
7e34: e5831004 str r1, [r3, #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;
7e38: e58c1000 str r1, [ip]
next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
7e3c: e5810044 str r0, [r1, #68] ; 0x44
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
7e40: e129f007 msr CPSR_fc, r7
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
7e44: eaffffd4 b 7d9c <_Thread_queue_Enqueue_priority+0xa4>
7e48: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
7e4c: eaffffd9 b 7db8 <_Thread_queue_Enqueue_priority+0xc0> <== NOT EXECUTED
7e50: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
7e54: eaffffb8 b 7d3c <_Thread_queue_Enqueue_priority+0x44> <== NOT EXECUTED
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
7e58: e1530004 cmp r3, r4
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
7e5c: e3a03000 mov r3, #0
7e60: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
7e64: 0a000007 beq 7e88 <_Thread_queue_Enqueue_priority+0x190>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
7e68: e59c3004 ldr r3, [ip, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
7e6c: e581c000 str ip, [r1]
the_node->previous = previous_node;
7e70: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
7e74: e5831000 str r1, [r3]
search_node->previous = the_node;
7e78: e58c1004 str r1, [ip, #4]
the_thread->Wait.queue = the_thread_queue;
7e7c: e5810044 str r0, [r1, #68] ; 0x44
7e80: e129f007 msr CPSR_fc, r7
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
7e84: eaffffc4 b 7d9c <_Thread_queue_Enqueue_priority+0xa4>
7e88: e28cc03c add ip, ip, #60 ; 0x3c
_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;
7e8c: e59c3004 ldr r3, [ip, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
7e90: e581c000 str ip, [r1]
the_node->previous = previous_node;
7e94: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
7e98: e5831000 str r1, [r3]
search_node->previous = the_node;
7e9c: e58c1004 str r1, [ip, #4]
the_thread->Wait.queue = the_thread_queue;
7ea0: e5810044 str r0, [r1, #68] ; 0x44
7ea4: e129f00a msr CPSR_fc, sl
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
7ea8: e3a05001 mov r5, #1
7eac: eaffffba b 7d9c <_Thread_queue_Enqueue_priority+0xa4>
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
7eb0: e3e04000 mvn r4, #0
7eb4: eaffffb4 b 7d8c <_Thread_queue_Enqueue_priority+0x94>
00015ec4 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
15ec4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
15ec8: e24dd024 sub sp, sp, #36 ; 0x24
15ecc: e28d700c add r7, sp, #12
15ed0: e28d2018 add r2, sp, #24
15ed4: e282a004 add sl, r2, #4
15ed8: e2872004 add r2, r7, #4
15edc: e58d2000 str r2, [sp]
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
15ee0: e28d2018 add r2, sp, #24 15ee4: e58d2020 str r2, [sp, #32]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
15ee8: e59d2000 ldr r2, [sp] 15eec: e58d200c str r2, [sp, #12] 15ef0: e2802008 add r2, r0, #8
the_chain->permanent_null = NULL;
15ef4: e3a03000 mov r3, #0 15ef8: e58d2004 str r2, [sp, #4] 15efc: e2802040 add r2, r0, #64 ; 0x40
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
15f00: e58da018 str sl, [sp, #24]
the_chain->permanent_null = NULL;
15f04: e58d301c str r3, [sp, #28] 15f08: e58d3010 str r3, [sp, #16]
the_chain->last = _Chain_Head(the_chain);
15f0c: e58d7014 str r7, [sp, #20] 15f10: e59f91a8 ldr r9, [pc, #424] ; 160c0 <_Timer_server_Body+0x1fc> 15f14: e59fb1a8 ldr fp, [pc, #424] ; 160c4 <_Timer_server_Body+0x200> 15f18: e58d2008 str r2, [sp, #8] 15f1c: e1a04000 mov r4, r0 15f20: e2806030 add r6, r0, #48 ; 0x30 15f24: e2808068 add r8, r0, #104 ; 0x68
{
/*
* 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;
15f28: e28d3018 add r3, sp, #24 15f2c: e5843078 str r3, [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;
15f30: e5993000 ldr r3, [r9]
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
15f34: e594103c ldr r1, [r4, #60] ; 0x3c
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
15f38: e1a02007 mov r2, r7 15f3c: e1a00006 mov r0, r6
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
15f40: e584303c str r3, [r4, #60] ; 0x3c
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
15f44: e0611003 rsb r1, r1, r3 15f48: eb0011d1 bl 1a694 <_Watchdog_Adjust_to_chain>
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
15f4c: e59b5000 ldr r5, [fp]
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
15f50: 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 ) {
15f54: e1550002 cmp r5, r2
15f58: 8a000022 bhi 15fe8 <_Timer_server_Body+0x124>
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
15f5c: 3a000018 bcc 15fc4 <_Timer_server_Body+0x100>
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
15f60: e5845074 str r5, [r4, #116] ; 0x74
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
15f64: e5940078 ldr r0, [r4, #120] ; 0x78 15f68: eb0002d3 bl 16abc <_Chain_Get>
if ( timer == NULL ) {
15f6c: e2501000 subs r1, r0, #0
15f70: 0a00000b beq 15fa4 <_Timer_server_Body+0xe0>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
15f74: e5913038 ldr r3, [r1, #56] ; 0x38 15f78: e3530001 cmp r3, #1
15f7c: 0a000015 beq 15fd8 <_Timer_server_Body+0x114>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
15f80: e3530003 cmp r3, #3
15f84: 1afffff6 bne 15f64 <_Timer_server_Body+0xa0>
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
15f88: e2811010 add r1, r1, #16 15f8c: e1a00008 mov r0, r8 15f90: eb0011e9 bl 1a73c <_Watchdog_Insert>
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
15f94: e5940078 ldr r0, [r4, #120] ; 0x78 15f98: eb0002c7 bl 16abc <_Chain_Get>
if ( timer == NULL ) {
15f9c: e2501000 subs r1, r0, #0
15fa0: 1afffff3 bne 15f74 <_Timer_server_Body+0xb0>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
15fa4: e10f2000 mrs r2, CPSR 15fa8: e3823080 orr r3, r2, #128 ; 0x80 15fac: e129f003 msr CPSR_fc, r3
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
15fb0: e59d3018 ldr r3, [sp, #24] 15fb4: e15a0003 cmp sl, r3
15fb8: 0a00000f beq 15ffc <_Timer_server_Body+0x138>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
15fbc: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 15fc0: eaffffda b 15f30 <_Timer_server_Body+0x6c> <== NOT EXECUTED
/*
* 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 );
15fc4: e1a00008 mov r0, r8 15fc8: e3a01001 mov r1, #1 15fcc: e0652002 rsb r2, r5, r2 15fd0: eb001180 bl 1a5d8 <_Watchdog_Adjust> 15fd4: eaffffe1 b 15f60 <_Timer_server_Body+0x9c>
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
15fd8: e1a00006 mov r0, r6 15fdc: e2811010 add r1, r1, #16 15fe0: eb0011d5 bl 1a73c <_Watchdog_Insert> 15fe4: eaffffde b 15f64 <_Timer_server_Body+0xa0>
/*
* 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 );
15fe8: e0621005 rsb r1, r2, r5 15fec: e1a00008 mov r0, r8 15ff0: e1a02007 mov r2, r7 15ff4: eb0011a6 bl 1a694 <_Watchdog_Adjust_to_chain> 15ff8: eaffffd8 b 15f60 <_Timer_server_Body+0x9c>
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
15ffc: e5841078 str r1, [r4, #120] ; 0x78 16000: e129f002 msr CPSR_fc, r2
_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 ) ) {
16004: e59d300c ldr r3, [sp, #12] 16008: e59d2000 ldr r2, [sp] 1600c: e1520003 cmp r2, r3
16010: 0a000015 beq 1606c <_Timer_server_Body+0x1a8>
16014: e1a05004 mov r5, r4 16018: e59d4000 ldr r4, [sp] 1601c: ea000009 b 16048 <_Timer_server_Body+0x184>
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
16020: e5932000 ldr r2, [r3]
the_chain->first = new_first; new_first->previous = _Chain_Head(the_chain);
16024: e5827004 str r7, [r2, #4]
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
the_chain->first = new_first;
16028: e58d200c str r2, [sp, #12]
* 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;
1602c: e3a02000 mov r2, #0 16030: e5832008 str r2, [r3, #8] 16034: e129f001 msr CPSR_fc, r1
/*
* 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 );
16038: e2830020 add r0, r3, #32
1603c: e8900003 ldm r0, {r0, r1}
16040: e1a0e00f mov lr, pc
16044: e593f01c ldr pc, [r3, #28]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
16048: e10f1000 mrs r1, CPSR 1604c: e3813080 orr r3, r1, #128 ; 0x80 16050: e129f003 msr CPSR_fc, r3
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
16054: e59d300c ldr r3, [sp, #12]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
16058: e1540003 cmp r4, r3
1605c: 1affffef bne 16020 <_Timer_server_Body+0x15c>
16060: e1a04005 mov r4, r5
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
16064: e129f001 msr CPSR_fc, r1 16068: eaffffae b 15f28 <_Timer_server_Body+0x64>
}
} else {
ts->active = false;
1606c: e3a03000 mov r3, #0 16070: e5c4307c strb r3, [r4, #124] ; 0x7c 16074: e59f204c ldr r2, [pc, #76] ; 160c8 <_Timer_server_Body+0x204> 16078: e5923000 ldr r3, [r2] 1607c: e2833001 add r3, r3, #1 16080: e5823000 str r3, [r2]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
16084: e3a01008 mov r1, #8 16088: e5940000 ldr r0, [r4] 1608c: eb000ee7 bl 19c30 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
16090: e1a00004 mov r0, r4 16094: ebffff5e bl 15e14 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
16098: e1a00004 mov r0, r4 1609c: ebffff72 bl 15e6c <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
160a0: eb000c44 bl 191b8 <_Thread_Enable_dispatch>
ts->active = true;
160a4: e3a03001 mov r3, #1 160a8: 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 );
160ac: e59d0004 ldr r0, [sp, #4] 160b0: eb001204 bl 1a8c8 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
160b4: e59d0008 ldr r0, [sp, #8] 160b8: eb001202 bl 1a8c8 <_Watchdog_Remove> 160bc: eaffff99 b 15f28 <_Timer_server_Body+0x64>
00008720 <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
8720: e92d40f0 push {r4, r5, r6, r7, lr}
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _User_extensions_List.first ;
8724: e59f5050 ldr r5, [pc, #80] ; 877c <_User_extensions_Thread_create+0x5c>
8728: e4954004 ldr r4, [r5], #4
872c: e1540005 cmp r4, r5
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
8730: e1a06000 mov r6, r0
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _User_extensions_List.first ;
8734: 0a00000e beq 8774 <_User_extensions_Thread_create+0x54>
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
status = (*the_extension->Callouts.thread_create)(
8738: e59f7040 ldr r7, [pc, #64] ; 8780 <_User_extensions_Thread_create+0x60>
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
873c: e5943014 ldr r3, [r4, #20]
8740: e3530000 cmp r3, #0
status = (*the_extension->Callouts.thread_create)(
8744: e1a01006 mov r1, r6
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
8748: 0a000004 beq 8760 <_User_extensions_Thread_create+0x40>
status = (*the_extension->Callouts.thread_create)(
874c: e5970004 ldr r0, [r7, #4]
8750: e1a0e00f mov lr, pc
8754: e12fff13 bx r3
_Thread_Executing,
the_thread
);
if ( !status )
8758: e3500000 cmp r0, #0
875c: 08bd80f0 popeq {r4, r5, r6, r7, pc}
User_extensions_Control *the_extension;
bool status;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
8760: e5944000 ldr r4, [r4]
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _User_extensions_List.first ;
8764: e1540005 cmp r4, r5
8768: 1afffff3 bne 873c <_User_extensions_Thread_create+0x1c>
if ( !status )
return false;
}
}
return true;
876c: e3a00001 mov r0, #1
8770: e8bd80f0 pop {r4, r5, r6, r7, pc}
8774: e3a00001 mov r0, #1 <== NOT EXECUTED
}
8778: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
0000a704 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
a704: e92d41f0 push {r4, r5, r6, r7, r8, lr}
a708: e1a04000 mov r4, r0
a70c: e1a05002 mov r5, r2
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a710: e10f3000 mrs r3, CPSR
a714: e3832080 orr r2, r3, #128 ; 0x80
a718: e129f002 msr CPSR_fc, r2
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
a71c: e1a07000 mov r7, r0
a720: e4972004 ldr r2, [r7], #4
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
a724: e1520007 cmp r2, r7
a728: 0a000018 beq a790 <_Watchdog_Adjust+0x8c>
switch ( direction ) {
a72c: e3510000 cmp r1, #0
a730: 1a000018 bne a798 <_Watchdog_Adjust+0x94>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
a734: e3550000 cmp r5, #0
a738: 0a000014 beq a790 <_Watchdog_Adjust+0x8c>
if ( units < _Watchdog_First( header )->delta_interval ) {
a73c: e5926010 ldr r6, [r2, #16]
a740: e1550006 cmp r5, r6
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
a744: 23a08001 movcs r8, #1
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
a748: 2a000005 bcs a764 <_Watchdog_Adjust+0x60>
a74c: ea000018 b a7b4 <_Watchdog_Adjust+0xb0> <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
a750: e0555006 subs r5, r5, r6
a754: 0a00000d beq a790 <_Watchdog_Adjust+0x8c>
if ( units < _Watchdog_First( header )->delta_interval ) {
a758: e5926010 ldr r6, [r2, #16]
a75c: e1560005 cmp r6, r5
a760: 8a000013 bhi a7b4 <_Watchdog_Adjust+0xb0>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
a764: e5828010 str r8, [r2, #16]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a768: e129f003 msr CPSR_fc, r3
_ISR_Enable( level );
_Watchdog_Tickle( header );
a76c: e1a00004 mov r0, r4
a770: eb0000a0 bl a9f8 <_Watchdog_Tickle>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a774: e10f3000 mrs r3, CPSR
a778: e3832080 orr r2, r3, #128 ; 0x80
a77c: e129f002 msr CPSR_fc, r2
a780: e5941000 ldr r1, [r4]
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
a784: e1570001 cmp r7, r1
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) header->first );
a788: e1a02001 mov r2, r1
a78c: 1affffef bne a750 <_Watchdog_Adjust+0x4c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a790: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
a794: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
a798: e3510001 cmp r1, #1
a79c: 1afffffb bne a790 <_Watchdog_Adjust+0x8c>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
a7a0: e5921010 ldr r1, [r2, #16]
a7a4: e0815005 add r5, r1, r5
a7a8: e5825010 str r5, [r2, #16]
a7ac: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
a7b0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
a7b4: e0655006 rsb r5, r5, r6
a7b8: e5825010 str r5, [r2, #16]
break;
a7bc: eafffff3 b a790 <_Watchdog_Adjust+0x8c>
00021b80 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
21b80: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
21b84: e24dd00c sub sp, sp, #12
21b88: e1a04000 mov r4, r0
21b8c: e1a05001 mov r5, r1
21b90: e1a08002 mov r8, r2
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
21b94: ebffff40 bl 2189c <getpid> 21b98: e1500004 cmp r0, r4
21b9c: 1a000095 bne 21df8 <killinfo+0x278>
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
21ba0: e3550000 cmp r5, #0
21ba4: 0a000098 beq 21e0c <killinfo+0x28c>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
21ba8: e2454001 sub r4, r5, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
21bac: e354001f cmp r4, #31
21bb0: 8a000095 bhi 21e0c <killinfo+0x28c>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
21bb4: e59f627c ldr r6, [pc, #636] ; 21e38 <killinfo+0x2b8> 21bb8: e1a07085 lsl r7, r5, #1 21bbc: e0873005 add r3, r7, r5 21bc0: e0863103 add r3, r6, r3, lsl #2 21bc4: e5933008 ldr r3, [r3, #8] 21bc8: e3530001 cmp r3, #1
return 0;
21bcc: 03a00000 moveq r0, #0
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
21bd0: 0a000038 beq 21cb8 <killinfo+0x138>
/*
* P1003.1c/Draft 10, p. 33 says that certain signals should always
* be directed to the executing thread such as those caused by hardware
* faults.
*/
if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
21bd4: e3550008 cmp r5, #8 21bd8: 13550004 cmpne r5, #4
21bdc: 0a000037 beq 21cc0 <killinfo+0x140>
21be0: e355000b cmp r5, #11
21be4: 0a000035 beq 21cc0 <killinfo+0x140>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
21be8: e3a03001 mov r3, #1
/* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER;
21bec: e58d3004 str r3, [sp, #4]
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
21bf0: e58d5000 str r5, [sp]
siginfo->si_code = SI_USER;
if ( !value ) {
21bf4: e3580000 cmp r8, #0 21bf8: e1a04413 lsl r4, r3, r4
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
21bfc: 15983000 ldrne r3, [r8] 21c00: 158d3008 strne r3, [sp, #8] 21c04: e59f3230 ldr r3, [pc, #560] ; 21e3c <killinfo+0x2bc> 21c08: e5932000 ldr r2, [r3] 21c0c: e2822001 add r2, r2, #1
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
21c10: 058d8008 streq r8, [sp, #8] 21c14: e5832000 str r2, [r3]
/*
* Is the currently executing thread interested? If so then it will
* get it an execute it as soon as the dispatcher executes.
*/
the_thread = _Thread_Executing;
21c18: e59f3220 ldr r3, [pc, #544] ; 21e40 <killinfo+0x2c0> 21c1c: e5930004 ldr r0, [r3, #4]
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
21c20: e5903108 ldr r3, [r0, #264] ; 0x108 21c24: e59330d0 ldr r3, [r3, #208] ; 0xd0 21c28: e1d43003 bics r3, r4, r3
21c2c: 1a000014 bne 21c84 <killinfo+0x104>
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = the_chain->first ;
21c30: e59f120c ldr r1, [pc, #524] ; 21e44 <killinfo+0x2c4> 21c34: e4913004 ldr r3, [r1], #4 21c38: e1530001 cmp r3, r1
21c3c: 0a000030 beq 21d04 <killinfo+0x184>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
21c40: e5932030 ldr r2, [r3, #48] ; 0x30 21c44: e1140002 tst r4, r2
for ( the_node = the_chain->first ;
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
21c48: e1a00003 mov r0, r3
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
21c4c: e5932108 ldr r2, [r3, #264] ; 0x108
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
21c50: 0a000008 beq 21c78 <killinfo+0xf8>
21c54: ea00000a b 21c84 <killinfo+0x104>
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = the_chain->first ;
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
21c58: e5933000 ldr r3, [r3]
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = the_chain->first ;
21c5c: e1530001 cmp r3, r1
21c60: 0a000027 beq 21d04 <killinfo+0x184>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
21c64: e5932030 ldr r2, [r3, #48] ; 0x30 <== NOT EXECUTED 21c68: e1140002 tst r4, r2 <== NOT EXECUTED
for ( the_node = the_chain->first ;
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
21c6c: e1a00003 mov r0, r3 <== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
21c70: e5932108 ldr r2, [r3, #264] ; 0x108 <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
21c74: 1a000002 bne 21c84 <killinfo+0x104> <== NOT EXECUTED
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
21c78: e59220d0 ldr r2, [r2, #208] ; 0xd0 21c7c: e1d42002 bics r2, r4, r2
21c80: 0afffff4 beq 21c58 <killinfo+0xd8>
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
21c84: e1a01005 mov r1, r5 21c88: e1a0200d mov r2, sp 21c8c: eb00007c bl 21e84 <_POSIX_signals_Unblock_thread> 21c90: e3500000 cmp r0, #0
21c94: 1a000005 bne 21cb0 <killinfo+0x130>
/*
* We may have woken up a thread but we definitely need to post the
* signal to the process wide information set.
*/
_POSIX_signals_Set_process_signals( mask );
21c98: e1a00004 mov r0, r4
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
21c9c: e0875005 add r5, r7, r5
/*
* We may have woken up a thread but we definitely need to post the
* signal to the process wide information set.
*/
_POSIX_signals_Set_process_signals( mask );
21ca0: eb00006d bl 21e5c <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
21ca4: e7963105 ldr r3, [r6, r5, lsl #2] 21ca8: e3530002 cmp r3, #2
21cac: 0a000007 beq 21cd0 <killinfo+0x150>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
21cb0: ebffac38 bl cd98 <_Thread_Enable_dispatch>
return 0;
21cb4: e3a00000 mov r0, #0
}
21cb8: e28dd00c add sp, sp, #12
21cbc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* P1003.1c/Draft 10, p. 33 says that certain signals should always
* be directed to the executing thread such as those caused by hardware
* faults.
*/
if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
return pthread_kill( pthread_self(), sig );
21cc0: eb0000f7 bl 220a4 <pthread_self> 21cc4: e1a01005 mov r1, r5 21cc8: eb0000bc bl 21fc0 <pthread_kill> 21ccc: eafffff9 b 21cb8 <killinfo+0x138>
_POSIX_signals_Set_process_signals( mask );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
21cd0: e59f0170 ldr r0, [pc, #368] ; 21e48 <killinfo+0x2c8> 21cd4: ebffa63b bl b5c8 <_Chain_Get>
if ( !psiginfo ) {
21cd8: e250c000 subs ip, r0, #0
21cdc: 0a00004f beq 21e20 <killinfo+0x2a0>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
21ce0: e1a0300d mov r3, sp
21ce4: e8930007 ldm r3, {r0, r1, r2}
21ce8: e28c3008 add r3, ip, #8
21cec: e8830007 stm r3, {r0, r1, r2}
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
21cf0: e59f0154 ldr r0, [pc, #340] ; 21e4c <killinfo+0x2cc> 21cf4: e1a0100c mov r1, ip 21cf8: e0800105 add r0, r0, r5, lsl #2 21cfc: ebffa61e bl b57c <_Chain_Append> 21d00: eaffffea b 21cb0 <killinfo+0x130>
* NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
21d04: e59f3144 ldr r3, [pc, #324] ; 21e50 <killinfo+0x2d0> 21d08: e5d3e000 ldrb lr, [r3] 21d0c: e59fa140 ldr sl, [pc, #320] ; 21e54 <killinfo+0x2d4> 21d10: e28ee001 add lr, lr, #1
* * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL;
21d14: e3a08000 mov r8, #0
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
21d18: e5ba3004 ldr r3, [sl, #4]! 21d1c: e3530000 cmp r3, #0
21d20: 0a000022 beq 21db0 <killinfo+0x230>
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
21d24: e5933004 ldr r3, [r3, #4]
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
21d28: e1d3c1b0 ldrh ip, [r3, #16]
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
21d2c: e35c0000 cmp ip, #0
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
21d30: e593101c ldr r1, [r3, #28]
for ( index = 1 ; index <= maximum ; index++ ) {
21d34: 0a00001d beq 21db0 <killinfo+0x230>
21d38: e3a02001 mov r2, #1
the_thread = (Thread_Control *) object_table[ index ];
21d3c: e5b13004 ldr r3, [r1, #4]!
if ( !the_thread )
21d40: e3530000 cmp r3, #0
21d44: 0a000016 beq 21da4 <killinfo+0x224>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
21d48: e5930014 ldr r0, [r3, #20] 21d4c: e150000e cmp r0, lr
21d50: 8a000013 bhi 21da4 <killinfo+0x224>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
21d54: e5939108 ldr r9, [r3, #264] ; 0x108 21d58: e59990d0 ldr r9, [r9, #208] ; 0xd0 21d5c: e1d49009 bics r9, r4, r9
21d60: 0a00000f beq 21da4 <killinfo+0x224>
*
* NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1
* so we never have to worry about deferencing a NULL
* interested thread.
*/
if ( the_thread->current_priority < interested_priority ) {
21d64: e150000e cmp r0, lr
21d68: 3a00001c bcc 21de0 <killinfo+0x260>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
21d6c: e3580000 cmp r8, #0
21d70: 0a00000b beq 21da4 <killinfo+0x224>
21d74: e5989010 ldr r9, [r8, #16] 21d78: e3590000 cmp r9, #0
21d7c: 0a000008 beq 21da4 <killinfo+0x224>
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
21d80: e593b010 ldr fp, [r3, #16] 21d84: e35b0000 cmp fp, #0
21d88: 0a000014 beq 21de0 <killinfo+0x260>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
21d8c: e3190201 tst r9, #268435456 ; 0x10000000
21d90: 1a000003 bne 21da4 <killinfo+0x224>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
21d94: e20bb201 and fp, fp, #268435456 ; 0x10000000
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
21d98: e35b0000 cmp fp, #0 21d9c: 11a0e000 movne lr, r0 21da0: 11a08003 movne r8, r3
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
21da4: e2822001 add r2, r2, #1 21da8: e15c0002 cmp ip, r2
21dac: 2affffe2 bcs 21d3c <killinfo+0x1bc>
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
21db0: e59f30a0 ldr r3, [pc, #160] ; 21e58 <killinfo+0x2d8> 21db4: e15a0003 cmp sl, r3
21db8: 1affffd6 bne 21d18 <killinfo+0x198>
}
}
}
}
if ( interested ) {
21dbc: e3580000 cmp r8, #0
21dc0: 0affffb4 beq 21c98 <killinfo+0x118>
21dc4: e1a00008 mov r0, r8
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
21dc8: e1a01005 mov r1, r5 21dcc: e1a0200d mov r2, sp 21dd0: eb00002b bl 21e84 <_POSIX_signals_Unblock_thread> 21dd4: e3500000 cmp r0, #0
21dd8: 0affffae beq 21c98 <killinfo+0x118>
21ddc: eaffffb3 b 21cb0 <killinfo+0x130> <== NOT EXECUTED
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
21de0: e2822001 add r2, r2, #1 21de4: e15c0002 cmp ip, r2
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
21de8: e1a0e000 mov lr, r0 21dec: e1a08003 mov r8, r3
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
21df0: 2affffd1 bcs 21d3c <killinfo+0x1bc>
21df4: eaffffed b 21db0 <killinfo+0x230>
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
rtems_set_errno_and_return_minus_one( ESRCH );
21df8: ebffc4d3 bl 1314c <__errno> 21dfc: e3a03003 mov r3, #3 21e00: e5803000 str r3, [r0] 21e04: e3e00000 mvn r0, #0 21e08: eaffffaa b 21cb8 <killinfo+0x138>
*/
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
21e0c: ebffc4ce bl 1314c <__errno> 21e10: e3a03016 mov r3, #22 21e14: e5803000 str r3, [r0] 21e18: e3e00000 mvn r0, #0 21e1c: eaffffa5 b 21cb8 <killinfo+0x138>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
_Thread_Enable_dispatch();
21e20: ebffabdc bl cd98 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
21e24: ebffc4c8 bl 1314c <__errno> 21e28: e3a0300b mov r3, #11 21e2c: e5803000 str r3, [r0] 21e30: e3e00000 mvn r0, #0 21e34: eaffff9f b 21cb8 <killinfo+0x138>
0000a86c <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
a86c: e3500000 cmp r0, #0
a870: 0a00000e beq a8b0 <pthread_attr_setschedpolicy+0x44>
a874: e5903000 ldr r3, [r0]
a878: e3530000 cmp r3, #0
a87c: 0a00000b beq a8b0 <pthread_attr_setschedpolicy+0x44>
return EINVAL;
switch ( policy ) {
a880: e3510004 cmp r1, #4
a884: 9a000001 bls a890 <pthread_attr_setschedpolicy+0x24>
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
a888: e3a00086 mov r0, #134 ; 0x86
} }
a88c: e12fff1e bx lr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
a890: e3a03001 mov r3, #1
a894: e1a03113 lsl r3, r3, r1
a898: e3130017 tst r3, #23
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
a89c: 15801014 strne r1, [r0, #20]
return 0;
a8a0: 13a00000 movne r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
a8a4: 112fff1e bxne lr
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
a8a8: e3a00086 mov r0, #134 ; 0x86 <== NOT EXECUTED
} }
a8ac: e12fff1e bx lr <== NOT EXECUTED
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
a8b0: e3a00016 mov r0, #22
a8b4: e12fff1e bx lr
00007724 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
7724: e3500000 cmp r0, #0
7728: 0a000008 beq 7750 <pthread_mutexattr_setpshared+0x2c>
772c: e5903000 ldr r3, [r0]
7730: e3530000 cmp r3, #0
7734: 0a000005 beq 7750 <pthread_mutexattr_setpshared+0x2c>
return EINVAL;
switch ( pshared ) {
7738: e3510001 cmp r1, #1
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
773c: 95801004 strls r1, [r0, #4]
return 0;
7740: 93a00000 movls r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
7744: 912fff1e bxls lr
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
7748: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
774c: e12fff1e bx lr <== NOT EXECUTED
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
7750: e3a00016 mov r0, #22
7754: e12fff1e bx lr
00006998 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
6998: e92d4030 push {r4, r5, lr}
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
699c: e2505000 subs r5, r0, #0
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
69a0: e24dd00c sub sp, sp, #12
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
69a4: 0a00001d beq 6a20 <pthread_rwlock_timedrdlock+0x88>
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
69a8: e1a00001 mov r0, r1
69ac: e28d1004 add r1, sp, #4
69b0: eb0019bf bl d0b4 <_POSIX_Absolute_timeout_to_ticks>
69b4: e5951000 ldr r1, [r5]
69b8: e1a04000 mov r4, r0
69bc: e28d2008 add r2, sp, #8
69c0: e59f0098 ldr r0, [pc, #152] ; 6a60 <pthread_rwlock_timedrdlock+0xc8>
69c4: eb000aac bl 947c <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
69c8: e59d3008 ldr r3, [sp, #8]
69cc: e3530000 cmp r3, #0
69d0: 1a000012 bne 6a20 <pthread_rwlock_timedrdlock+0x88>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
69d4: e5951000 ldr r1, [r5]
int _EXFUN(pthread_rwlock_init, (pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr)); int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_timedrdlock,
69d8: e3540003 cmp r4, #3
69dc: 13a05000 movne r5, #0
69e0: 03a05001 moveq r5, #1
69e4: e58d3000 str r3, [sp]
69e8: e2800010 add r0, r0, #16
69ec: e1a02005 mov r2, r5
69f0: e59d3004 ldr r3, [sp, #4]
69f4: eb000738 bl 86dc <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
69f8: eb000ccb bl 9d2c <_Thread_Enable_dispatch>
if ( !do_wait ) {
69fc: e3550000 cmp r5, #0
6a00: 1a000011 bne 6a4c <pthread_rwlock_timedrdlock+0xb4>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
6a04: e59f3058 ldr r3, [pc, #88] ; 6a64 <pthread_rwlock_timedrdlock+0xcc>
6a08: e5933004 ldr r3, [r3, #4]
6a0c: e5930034 ldr r0, [r3, #52] ; 0x34
6a10: e3500002 cmp r0, #2
6a14: 0a000004 beq 6a2c <pthread_rwlock_timedrdlock+0x94>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
6a18: eb000046 bl 6b38 <_POSIX_RWLock_Translate_core_RWLock_return_code>
6a1c: ea000000 b 6a24 <pthread_rwlock_timedrdlock+0x8c>
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
6a20: e3a00016 mov r0, #22
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
6a24: e28dd00c add sp, sp, #12
6a28: e8bd8030 pop {r4, r5, pc}
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
6a2c: e3540000 cmp r4, #0
6a30: 0afffffa beq 6a20 <pthread_rwlock_timedrdlock+0x88>
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
6a34: e2444001 sub r4, r4, #1
6a38: e3540001 cmp r4, #1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
6a3c: 93a00074 movls r0, #116 ; 0x74
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
6a40: 9afffff7 bls 6a24 <pthread_rwlock_timedrdlock+0x8c>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
6a44: eb00003b bl 6b38 <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED
6a48: eafffff5 b 6a24 <pthread_rwlock_timedrdlock+0x8c> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
6a4c: e59f3010 ldr r3, [pc, #16] ; 6a64 <pthread_rwlock_timedrdlock+0xcc>
6a50: e5933004 ldr r3, [r3, #4]
6a54: e5930034 ldr r0, [r3, #52] ; 0x34
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
6a58: eb000036 bl 6b38 <_POSIX_RWLock_Translate_core_RWLock_return_code>
6a5c: eafffff0 b 6a24 <pthread_rwlock_timedrdlock+0x8c>
00006a68 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
6a68: e92d4030 push {r4, r5, lr}
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
6a6c: e2505000 subs r5, r0, #0
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
6a70: e24dd00c sub sp, sp, #12
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
6a74: 0a00001d beq 6af0 <pthread_rwlock_timedwrlock+0x88>
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
6a78: e1a00001 mov r0, r1
6a7c: e28d1004 add r1, sp, #4
6a80: eb00198b bl d0b4 <_POSIX_Absolute_timeout_to_ticks>
6a84: e5951000 ldr r1, [r5]
6a88: e1a04000 mov r4, r0
6a8c: e28d2008 add r2, sp, #8
6a90: e59f0098 ldr r0, [pc, #152] ; 6b30 <pthread_rwlock_timedwrlock+0xc8>
6a94: eb000a78 bl 947c <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
6a98: e59d3008 ldr r3, [sp, #8]
6a9c: e3530000 cmp r3, #0
6aa0: 1a000012 bne 6af0 <pthread_rwlock_timedwrlock+0x88>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
6aa4: e5951000 ldr r1, [r5]
(pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime));
int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedwrlock,
6aa8: e3540003 cmp r4, #3
6aac: 13a05000 movne r5, #0
6ab0: 03a05001 moveq r5, #1
6ab4: e58d3000 str r3, [sp]
6ab8: e2800010 add r0, r0, #16
6abc: e1a02005 mov r2, r5
6ac0: e59d3004 ldr r3, [sp, #4]
6ac4: eb00073b bl 87b8 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
6ac8: eb000c97 bl 9d2c <_Thread_Enable_dispatch>
if ( !do_wait &&
6acc: e3550000 cmp r5, #0
6ad0: 1a000011 bne 6b1c <pthread_rwlock_timedwrlock+0xb4>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
6ad4: e59f3058 ldr r3, [pc, #88] ; 6b34 <pthread_rwlock_timedwrlock+0xcc>
6ad8: e5933004 ldr r3, [r3, #4]
6adc: e5930034 ldr r0, [r3, #52] ; 0x34
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
6ae0: e3500002 cmp r0, #2
6ae4: 0a000004 beq 6afc <pthread_rwlock_timedwrlock+0x94>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
6ae8: eb000012 bl 6b38 <_POSIX_RWLock_Translate_core_RWLock_return_code>
6aec: ea000000 b 6af4 <pthread_rwlock_timedwrlock+0x8c>
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
6af0: e3a00016 mov r0, #22
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
6af4: e28dd00c add sp, sp, #12
6af8: e8bd8030 pop {r4, r5, pc}
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
6afc: e3540000 cmp r4, #0
6b00: 0afffffa beq 6af0 <pthread_rwlock_timedwrlock+0x88>
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
6b04: e2444001 sub r4, r4, #1
6b08: e3540001 cmp r4, #1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
6b0c: 93a00074 movls r0, #116 ; 0x74
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
6b10: 9afffff7 bls 6af4 <pthread_rwlock_timedwrlock+0x8c>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
6b14: eb000007 bl 6b38 <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED
6b18: eafffff5 b 6af4 <pthread_rwlock_timedwrlock+0x8c> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
6b1c: e59f3010 ldr r3, [pc, #16] ; 6b34 <pthread_rwlock_timedwrlock+0xcc>
6b20: e5933004 ldr r3, [r3, #4]
6b24: e5930034 ldr r0, [r3, #52] ; 0x34
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
6b28: eb000002 bl 6b38 <_POSIX_RWLock_Translate_core_RWLock_return_code>
6b2c: eafffff0 b 6af4 <pthread_rwlock_timedwrlock+0x8c>
000072d0 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
72d0: e3500000 cmp r0, #0
72d4: 0a000008 beq 72fc <pthread_rwlockattr_setpshared+0x2c>
return EINVAL;
if ( !attr->is_initialized )
72d8: e5903000 ldr r3, [r0]
72dc: e3530000 cmp r3, #0
72e0: 0a000005 beq 72fc <pthread_rwlockattr_setpshared+0x2c>
return EINVAL;
switch ( pshared ) {
72e4: e3510001 cmp r1, #1
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
72e8: 95801004 strls r1, [r0, #4]
return 0;
72ec: 93a00000 movls r0, #0
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
72f0: 912fff1e bxls lr
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
72f4: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
72f8: e12fff1e bx lr <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
72fc: e3a00016 mov r0, #22
7300: e12fff1e bx lr
00006fac <rtems_io_register_driver>:
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
6fac: e59f3150 ldr r3, [pc, #336] ; 7104 <rtems_io_register_driver+0x158>
6fb0: e593c000 ldr ip, [r3]
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
6fb4: e59f314c ldr r3, [pc, #332] ; 7108 <rtems_io_register_driver+0x15c>
if ( rtems_interrupt_is_in_progress() )
6fb8: e35c0000 cmp ip, #0
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
6fbc: e92d4030 push {r4, r5, lr}
6fc0: e1a04000 mov r4, r0
rtems_device_major_number major_limit = _IO_Number_of_drivers;
6fc4: e5930000 ldr r0, [r3]
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
6fc8: 13a00012 movne r0, #18
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
6fcc: 18bd8030 popne {r4, r5, pc}
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
6fd0: e3520000 cmp r2, #0
6fd4: 0a00003f beq 70d8 <rtems_io_register_driver+0x12c>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
6fd8: e3510000 cmp r1, #0
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
6fdc: e5820000 str r0, [r2]
if ( driver_table == NULL )
6fe0: 0a00003c beq 70d8 <rtems_io_register_driver+0x12c>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
6fe4: e591c000 ldr ip, [r1]
6fe8: e35c0000 cmp ip, #0
6fec: 0a000036 beq 70cc <rtems_io_register_driver+0x120>
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
6ff0: e1500004 cmp r0, r4
6ff4: 9a000027 bls 7098 <rtems_io_register_driver+0xec>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
6ff8: e59f010c ldr r0, [pc, #268] ; 710c <rtems_io_register_driver+0x160>
6ffc: e590c000 ldr ip, [r0]
7000: e28cc001 add ip, ip, #1
7004: e580c000 str ip, [r0]
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
7008: e3540000 cmp r4, #0
700c: 1a000023 bne 70a0 <rtems_io_register_driver+0xf4>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
7010: e593c000 ldr ip, [r3]
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
7014: e35c0000 cmp ip, #0
7018: 0a000030 beq 70e0 <rtems_io_register_driver+0x134>
701c: e59fe0ec ldr lr, [pc, #236] ; 7110 <rtems_io_register_driver+0x164>
7020: e59e3000 ldr r3, [lr]
7024: ea000003 b 7038 <rtems_io_register_driver+0x8c>
7028: e2844001 add r4, r4, #1
702c: e15c0004 cmp ip, r4
7030: e2833018 add r3, r3, #24
7034: 9a000005 bls 7050 <rtems_io_register_driver+0xa4>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
7038: e5930000 ldr r0, [r3]
703c: e3500000 cmp r0, #0
7040: 1afffff8 bne 7028 <rtems_io_register_driver+0x7c>
7044: e5930004 ldr r0, [r3, #4]
7048: e3500000 cmp r0, #0
704c: 1afffff5 bne 7028 <rtems_io_register_driver+0x7c>
}
/* Assigns invalid value in case of failure */
*major = m;
if ( m != n )
7050: e15c0004 cmp ip, r4
7054: 1084c084 addne ip, r4, r4, lsl #1
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
7058: e5824000 str r4, [r2]
if ( m != n )
705c: 11a0c18c lslne ip, ip, #3
7060: 0a00001f beq 70e4 <rtems_io_register_driver+0x138>
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
7064: e59e5000 ldr r5, [lr]
7068: e1a0e001 mov lr, r1
706c: e8be000f ldm lr!, {r0, r1, r2, r3}
7070: e085c00c add ip, r5, ip
7074: e8ac000f stmia ip!, {r0, r1, r2, r3}
7078: e89e0003 ldm lr, {r0, r1}
707c: e88c0003 stm ip, {r0, r1}
_Thread_Enable_dispatch();
7080: eb0006a3 bl 8b14 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
7084: e3a01000 mov r1, #0
7088: e1a00004 mov r0, r4
708c: e1a02001 mov r2, r1
}
7090: e8bd4030 pop {r4, r5, lr}
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
7094: ea00210c b f4cc <rtems_io_initialize>
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
7098: e3a0000a mov r0, #10
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
709c: e8bd8030 pop {r4, r5, pc}
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
70a0: e59fe068 ldr lr, [pc, #104] ; 7110 <rtems_io_register_driver+0x164>
70a4: e59e3000 ldr r3, [lr]
70a8: e084c084 add ip, r4, r4, lsl #1
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
70ac: e793018c ldr r0, [r3, ip, lsl #3]
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
70b0: e1a0c18c lsl ip, ip, #3
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
70b4: e3500000 cmp r0, #0
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
70b8: e083300c add r3, r3, ip
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
70bc: 0a00000b beq 70f0 <rtems_io_register_driver+0x144>
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
70c0: eb000693 bl 8b14 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
70c4: e3a0000c mov r0, #12
70c8: e8bd8030 pop {r4, r5, pc}
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
70cc: e591c004 ldr ip, [r1, #4]
70d0: e35c0000 cmp ip, #0
70d4: 1affffc5 bne 6ff0 <rtems_io_register_driver+0x44>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
70d8: e3a00009 mov r0, #9
70dc: e8bd8030 pop {r4, r5, pc}
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
70e0: e5824000 str r4, [r2] <== NOT EXECUTED
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
70e4: eb00068a bl 8b14 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
70e8: e3a00005 mov r0, #5
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
return sc;
70ec: e8bd8030 pop {r4, r5, pc}
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
70f0: e5933004 ldr r3, [r3, #4]
70f4: e3530000 cmp r3, #0
70f8: 1afffff0 bne 70c0 <rtems_io_register_driver+0x114>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
70fc: e5824000 str r4, [r2]
7100: eaffffd7 b 7064 <rtems_io_register_driver+0xb8>
000058fc <rtems_object_get_api_class_name>:
)
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
58fc: e3500001 cmp r0, #1
const char *rtems_object_get_api_class_name(
int the_api,
int the_class
)
{
5900: e52de004 push {lr} ; (str lr, [sp, #-4]!)
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
5904: 0a00000d beq 5940 <rtems_object_get_api_class_name+0x44>
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
5908: e3500002 cmp r0, #2
590c: 0a000004 beq 5924 <rtems_object_get_api_class_name+0x28>
api_assoc = rtems_object_api_classic_assoc;
#ifdef RTEMS_POSIX_API
else if ( the_api == OBJECTS_POSIX_API )
5910: e3500003 cmp r0, #3
api_assoc = rtems_object_api_posix_assoc;
5914: 059f003c ldreq r0, [pc, #60] ; 5958 <rtems_object_get_api_class_name+0x5c>
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
api_assoc = rtems_object_api_classic_assoc;
#ifdef RTEMS_POSIX_API
else if ( the_api == OBJECTS_POSIX_API )
5918: 0a000002 beq 5928 <rtems_object_get_api_class_name+0x2c>
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
591c: e59f0038 ldr r0, [pc, #56] ; 595c <rtems_object_get_api_class_name+0x60>
5920: e49df004 pop {pc} ; (ldr pc, [sp], #4)
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
api_assoc = rtems_object_api_classic_assoc;
5924: e59f0034 ldr r0, [pc, #52] ; 5960 <rtems_object_get_api_class_name+0x64>
else if ( the_api == OBJECTS_POSIX_API )
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
5928: eb00133b bl a61c <rtems_assoc_ptr_by_local>
if ( class_assoc )
592c: e3500000 cmp r0, #0
return class_assoc->name;
5930: 15900000 ldrne r0, [r0]
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
if ( class_assoc )
5934: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
return class_assoc->name;
return "BAD CLASS";
5938: e59f0024 ldr r0, [pc, #36] ; 5964 <rtems_object_get_api_class_name+0x68>
}
593c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
5940: e59f0020 ldr r0, [pc, #32] ; 5968 <rtems_object_get_api_class_name+0x6c>
else if ( the_api == OBJECTS_POSIX_API )
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
5944: eb001334 bl a61c <rtems_assoc_ptr_by_local>
if ( class_assoc )
5948: e3500000 cmp r0, #0
return class_assoc->name;
594c: 15900000 ldrne r0, [r0]
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
if ( class_assoc )
5950: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
5954: eafffff7 b 5938 <rtems_object_get_api_class_name+0x3c> <== NOT EXECUTED
0000d4fc <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
d4fc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
d500: e2525000 subs r5, r2, #0
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
d504: e1a04000 mov r4, r0
d508: e1a06001 mov r6, r1
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
d50c: 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 )
d510: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
d514: e59f9148 ldr r9, [pc, #328] ; d664 <rtems_task_mode+0x168>
d518: e5997004 ldr r7, [r9, #4]
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
d51c: e5d7a074 ldrb sl, [r7, #116] ; 0x74
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
d520: e5978104 ldr r8, [r7, #260] ; 0x104
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
d524: 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;
d528: e35a0000 cmp sl, #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;
d52c: e5d8b008 ldrb fp, [r8, #8]
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
d530: 03a0ac01 moveq sl, #256 ; 0x100
d534: 13a0a000 movne sl, #0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
d538: e3530000 cmp r3, #0
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
d53c: 138aac02 orrne sl, sl, #512 ; 0x200
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
d540: e35b0000 cmp fp, #0
d544: 03a0bb01 moveq fp, #1024 ; 0x400
d548: 13a0b000 movne fp, #0
old_mode |= _ISR_Get_level();
d54c: ebffee8a bl 8f7c <_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;
d550: e18bb000 orr fp, fp, r0
old_mode |= _ISR_Get_level();
d554: e18ba00a orr sl, fp, sl
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
d558: e3160c01 tst r6, #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;
d55c: e585a000 str sl, [r5]
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
d560: 0a000003 beq d574 <rtems_task_mode+0x78>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
d564: e3140c01 tst r4, #256 ; 0x100
d568: 13a03000 movne r3, #0
d56c: 03a03001 moveq r3, #1
d570: e5c73074 strb r3, [r7, #116] ; 0x74
if ( mask & RTEMS_TIMESLICE_MASK ) {
d574: e3160c02 tst r6, #512 ; 0x200
d578: 1a000028 bne d620 <rtems_task_mode+0x124>
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
d57c: e3160080 tst r6, #128 ; 0x80
d580: 1a00002f bne d644 <rtems_task_mode+0x148>
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
d584: e2166b01 ands r6, r6, #1024 ; 0x400
d588: 0a000012 beq d5d8 <rtems_task_mode+0xdc>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
d58c: 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 ) {
d590: e5d82008 ldrb r2, [r8, #8]
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
d594: 13a03000 movne r3, #0
d598: 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 ) {
d59c: e1520003 cmp r2, r3
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
d5a0: 03a06000 moveq r6, #0
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
d5a4: 0a00000b beq d5d8 <rtems_task_mode+0xdc>
asr->is_enabled = is_asr_enabled;
d5a8: e5c83008 strb r3, [r8, #8]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
d5ac: e10f3000 mrs r3, CPSR
d5b0: e3832080 orr r2, r3, #128 ; 0x80
d5b4: e129f002 msr CPSR_fc, r2
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
d5b8: e5981018 ldr r1, [r8, #24]
information->signals_pending = information->signals_posted;
d5bc: e5982014 ldr r2, [r8, #20]
information->signals_posted = _signals;
d5c0: e5881014 str r1, [r8, #20]
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
d5c4: e5882018 str r2, [r8, #24]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
d5c8: e129f003 msr CPSR_fc, r3
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
d5cc: e5986014 ldr r6, [r8, #20]
d5d0: e3560000 cmp r6, #0
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
d5d4: 13a06001 movne r6, #1
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
d5d8: e59f3088 ldr r3, [pc, #136] ; d668 <rtems_task_mode+0x16c>
d5dc: e5933000 ldr r3, [r3]
d5e0: e3530003 cmp r3, #3
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
d5e4: 13a00000 movne r0, #0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
d5e8: 18bd8ff0 popne {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
Thread_Control *executing;
executing = _Thread_Executing;
if ( are_signals_pending ||
d5ec: e3560000 cmp r6, #0
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
d5f0: e5993004 ldr r3, [r9, #4]
if ( are_signals_pending ||
d5f4: 1a000015 bne d650 <rtems_task_mode+0x154>
d5f8: e59f2064 ldr r2, [pc, #100] ; d664 <rtems_task_mode+0x168>
d5fc: e5922008 ldr r2, [r2, #8]
d600: e1530002 cmp r3, r2
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
d604: 01a00006 moveq r0, r6
d608: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
d60c: e5d33074 ldrb r3, [r3, #116] ; 0x74
d610: e3530000 cmp r3, #0
d614: 1a00000d bne d650 <rtems_task_mode+0x154>
d618: e1a00006 mov r0, r6 <== NOT EXECUTED
}
d61c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
*/
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
d620: e2143c02 ands r3, r4, #512 ; 0x200
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
d624: 159f3040 ldrne r3, [pc, #64] ; d66c <rtems_task_mode+0x170>
d628: 15933000 ldrne r3, [r3]
if ( mask & RTEMS_PREEMPT_MASK )
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;
d62c: 13a02001 movne r2, #1
d630: 1587207c strne r2, [r7, #124] ; 0x7c
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
d634: 15873078 strne r3, [r7, #120] ; 0x78
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
d638: 0587307c streq r3, [r7, #124] ; 0x7c
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
d63c: e3160080 tst r6, #128 ; 0x80
d640: 0affffcf beq d584 <rtems_task_mode+0x88>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
d644: e2040080 and r0, r4, #128 ; 0x80
d648: ebffee46 bl 8f68 <_CPU_ISR_Set_level>
d64c: eaffffcc b d584 <rtems_task_mode+0x88>
_Thread_Dispatch_necessary = true;
d650: e3a03001 mov r3, #1
d654: e5c93010 strb r3, [r9, #16]
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
d658: ebffe7f4 bl 7630 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
d65c: e3a00000 mov r0, #0
d660: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
000086f4 <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
86f4: e92d4010 push {r4, lr}
86f8: e24dd004 sub sp, sp, #4
86fc: e1a04000 mov r4, r0
* * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
8700: e1a00001 mov r0, r1
8704: e1a0100d mov r1, sp
8708: eb00162f bl dfcc <_POSIX_Absolute_timeout_to_ticks>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
870c: e3500003 cmp r0, #3
8710: 0a000005 beq 872c <sem_timedwait+0x38>
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
8714: e1a00004 mov r0, r4 <== NOT EXECUTED
8718: e3a01000 mov r1, #0 <== NOT EXECUTED
871c: e59d2000 ldr r2, [sp] <== NOT EXECUTED
8720: eb001945 bl ec3c <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
8724: e28dd004 add sp, sp, #4
8728: e8bd8010 pop {r4, pc}
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
872c: e1a00004 mov r0, r4
8730: e3a01001 mov r1, #1
8734: e59d2000 ldr r2, [sp]
8738: eb00193f bl ec3c <_POSIX_Semaphore_Wait_support>
873c: eafffff8 b 8724 <sem_timedwait+0x30>
00005f3c <sigaction>:
struct sigaction *oact
)
{
ISR_Level level;
if ( oact )
5f3c: e2523000 subs r3, r2, #0
*oact = _POSIX_signals_Vectors[ sig ];
5f40: 159f20c4 ldrne r2, [pc, #196] ; 600c <sigaction+0xd0>
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
5f44: e92d4070 push {r4, r5, r6, lr}
5f48: e1a05001 mov r5, r1
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
5f4c: 10801080 addne r1, r0, r0, lsl #1
5f50: 10822101 addne r2, r2, r1, lsl #2
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
5f54: e1a04000 mov r4, r0
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
5f58: 18920007 ldmne r2, {r0, r1, r2}
5f5c: 18830007 stmne r3, {r0, r1, r2}
if ( !sig )
5f60: e3540000 cmp r4, #0
5f64: 0a000023 beq 5ff8 <sigaction+0xbc>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
5f68: e2443001 sub r3, r4, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
5f6c: e353001f cmp r3, #31
5f70: 8a000020 bhi 5ff8 <sigaction+0xbc>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
5f74: e3540009 cmp r4, #9
5f78: 0a00001e beq 5ff8 <sigaction+0xbc>
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
5f7c: e3550000 cmp r5, #0
5f80: 0a00001a beq 5ff0 <sigaction+0xb4>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
5f84: e10f6000 mrs r6, CPSR
5f88: e3863080 orr r3, r6, #128 ; 0x80
5f8c: e129f003 msr CPSR_fc, r3
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
5f90: e5953008 ldr r3, [r5, #8]
5f94: e3530000 cmp r3, #0
5f98: 0a000009 beq 5fc4 <sigaction+0x88>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
5f9c: e1a00004 mov r0, r4
5fa0: eb0016ff bl bba4 <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
5fa4: e59f3060 ldr r3, [pc, #96] ; 600c <sigaction+0xd0>
5fa8: e8950007 ldm r5, {r0, r1, r2}
5fac: e0844084 add r4, r4, r4, lsl #1
5fb0: e0834104 add r4, r3, r4, lsl #2
5fb4: e8840007 stm r4, {r0, r1, r2}
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
5fb8: e129f006 msr CPSR_fc, r6
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
5fbc: e3a00000 mov r0, #0
5fc0: e8bd8070 pop {r4, r5, r6, pc}
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
5fc4: e0844084 add r4, r4, r4, lsl #1
5fc8: e59f3040 ldr r3, [pc, #64] ; 6010 <sigaction+0xd4>
5fcc: e1a04104 lsl r4, r4, #2
5fd0: e0833004 add r3, r3, r4
5fd4: e8930007 ldm r3, {r0, r1, r2}
5fd8: e59f302c ldr r3, [pc, #44] ; 600c <sigaction+0xd0>
5fdc: e0834004 add r4, r3, r4
5fe0: e8840007 stm r4, {r0, r1, r2}
5fe4: e129f006 msr CPSR_fc, r6
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
5fe8: e3a00000 mov r0, #0
5fec: e8bd8070 pop {r4, r5, r6, pc}
5ff0: e1a00005 mov r0, r5 <== NOT EXECUTED
}
5ff4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
rtems_set_errno_and_return_minus_one( EINVAL );
5ff8: eb00234d bl ed34 <__errno>
5ffc: e3a03016 mov r3, #22
6000: e5803000 str r3, [r0]
6004: e3e00000 mvn r0, #0
6008: e8bd8070 pop {r4, r5, r6, pc}
000085bc <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
85bc: e92d4010 push {r4, lr}
85c0: e1a04001 mov r4, r1
int status;
status = sigtimedwait( set, NULL, NULL );
85c4: e3a01000 mov r1, #0
85c8: e1a02001 mov r2, r1
85cc: ebffff7f bl 83d0 <sigtimedwait>
if ( status != -1 ) {
85d0: e3700001 cmn r0, #1
85d4: 0a000005 beq 85f0 <sigwait+0x34>
if ( sig )
85d8: e3540000 cmp r4, #0
*sig = status;
85dc: 15840000 strne r0, [r4]
return 0;
85e0: 13a00000 movne r0, #0
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
85e4: 18bd8010 popne {r4, pc}
*sig = status;
return 0;
85e8: e1a00004 mov r0, r4 <== NOT EXECUTED
}
return errno;
}
85ec: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( sig )
*sig = status;
return 0;
}
return errno;
85f0: eb0022ac bl 110a8 <__errno>
85f4: e5900000 ldr r0, [r0]
85f8: e8bd8010 pop {r4, pc}