a0016a28 <_CORE_message_queue_Broadcast>:
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
a0016a28: 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
)
{
a0016a2c: 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 ) {
a0016a30: 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
)
{
a0016a34: e1a07000 mov r7, r0 a0016a38: e1a05002 mov r5, r2 a0016a3c: e1a08001 mov r8, r1 a0016a40: 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 ) {
a0016a44: 3a000013 bcc a0016a98 <_CORE_message_queue_Broadcast+0x70>
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
a0016a48: e5906048 ldr r6, [r0, #72] ; 0x48 a0016a4c: e3560000 cmp r6, #0
a0016a50: 0a000009 beq a0016a7c <_CORE_message_queue_Broadcast+0x54>
*count = 0;
a0016a54: e3a00000 mov r0, #0 a0016a58: e58a0000 str r0, [sl]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
a0016a5c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
a0016a60: e594002c ldr r0, [r4, #44] ; 0x2c a0016a64: e1a01008 mov r1, r8 a0016a68: e1a02005 mov r2, r5 a0016a6c: eb002487 bl a001fc90 <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
a0016a70: e5943028 ldr r3, [r4, #40] ; 0x28
*/
number_broadcasted = 0;
while ((the_thread =
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
a0016a74: e2866001 add r6, r6, #1
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
a0016a78: 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 =
a0016a7c: e1a00007 mov r0, r7 a0016a80: eb000b13 bl a00196d4 <_Thread_queue_Dequeue> a0016a84: e2504000 subs r4, r0, #0
a0016a88: 1afffff4 bne a0016a60 <_CORE_message_queue_Broadcast+0x38>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
a0016a8c: e58a6000 str r6, [sl]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
a0016a90: e1a00004 mov r0, r4
a0016a94: 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;
a0016a98: e3a00001 mov r0, #1 <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
a0016a9c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
a000b710 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
a000b710: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
a000b714: 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;
a000b718: e5902010 ldr r2, [r0, #16]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
a000b71c: e24dd01c sub sp, sp, #28 a000b720: 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 ) {
a000b724: e2911004 adds r1, r1, #4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
a000b728: 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 ) {
a000b72c: e58d1000 str r1, [sp]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
a000b730: 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;
a000b734: 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 ) {
a000b738: 2a000078 bcs a000b920 <_Heap_Allocate_aligned_with_boundary+0x210>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
a000b73c: e3530000 cmp r3, #0
a000b740: 1a000074 bne a000b918 <_Heap_Allocate_aligned_with_boundary+0x208>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
a000b744: 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 ) {
a000b748: e1570009 cmp r7, r9
a000b74c: 0a000073 beq a000b920 <_Heap_Allocate_aligned_with_boundary+0x210>
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
a000b750: e59d300c ldr r3, [sp, #12]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
a000b754: e2651004 rsb r1, r5, #4
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
a000b758: e3a06001 mov r6, #1
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
a000b75c: e2833007 add r3, r3, #7 a000b760: e58d3010 str r3, [sp, #16]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
a000b764: e58d1014 str r1, [sp, #20]
/*
* 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 ) {
a000b768: e599a004 ldr sl, [r9, #4] a000b76c: e59d2000 ldr r2, [sp] a000b770: e152000a cmp r2, sl
a000b774: 2a00004e bcs a000b8b4 <_Heap_Allocate_aligned_with_boundary+0x1a4>
if ( alignment == 0 ) {
a000b778: 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;
a000b77c: 02894008 addeq r4, r9, #8
a000b780: 0a000051 beq a000b8cc <_Heap_Allocate_aligned_with_boundary+0x1bc>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
a000b784: 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;
a000b788: 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;
a000b78c: 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;
a000b790: 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;
a000b794: 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;
a000b798: e081400a add r4, r1, sl
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
a000b79c: 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;
a000b7a0: e0633002 rsb r3, r3, r2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
a000b7a4: 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
a000b7a8: e083a00a add sl, r3, sl a000b7ac: 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;
a000b7b0: e2893008 add r3, r9, #8 a000b7b4: e58d3008 str r3, [sp, #8]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
a000b7b8: eb0016bc bl a00112b0 <__umodsi3> a000b7bc: 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 ) {
a000b7c0: e15a0004 cmp sl, r4
a000b7c4: 2a000003 bcs a000b7d8 <_Heap_Allocate_aligned_with_boundary+0xc8>
a000b7c8: e1a0000a mov r0, sl a000b7cc: e1a01008 mov r1, r8 a000b7d0: eb0016b6 bl a00112b0 <__umodsi3> a000b7d4: e060400a rsb r4, r0, sl
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
a000b7d8: e35b0000 cmp fp, #0
a000b7dc: 0a000026 beq a000b87c <_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;
a000b7e0: e084a005 add sl, r4, r5 a000b7e4: e1a0000a mov r0, sl a000b7e8: e1a0100b mov r1, fp a000b7ec: eb0016af bl a00112b0 <__umodsi3> a000b7f0: 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 ) {
a000b7f4: e15a0000 cmp sl, r0 a000b7f8: 93a0a000 movls sl, #0 a000b7fc: 83a0a001 movhi sl, #1 a000b800: e1540000 cmp r4, r0 a000b804: 23a0a000 movcs sl, #0 a000b808: e35a0000 cmp sl, #0
a000b80c: 0a00001a beq a000b87c <_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;
a000b810: e59d1008 ldr r1, [sp, #8] a000b814: 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 ) {
a000b818: e1530000 cmp r3, r0 a000b81c: 958d9018 strls r9, [sp, #24] a000b820: 91a09003 movls r9, r3
a000b824: 9a000002 bls a000b834 <_Heap_Allocate_aligned_with_boundary+0x124>
a000b828: ea000021 b a000b8b4 <_Heap_Allocate_aligned_with_boundary+0x1a4> a000b82c: e1590000 cmp r9, r0
a000b830: 8a00003c bhi a000b928 <_Heap_Allocate_aligned_with_boundary+0x218>
return 0;
}
alloc_begin = boundary_line - alloc_size;
a000b834: e0654000 rsb r4, r5, r0 a000b838: e1a01008 mov r1, r8 a000b83c: e1a00004 mov r0, r4 a000b840: eb00169a bl a00112b0 <__umodsi3> a000b844: e0604004 rsb r4, r0, r4
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
a000b848: e084a005 add sl, r4, r5 a000b84c: e1a0000a mov r0, sl a000b850: e1a0100b mov r1, fp a000b854: eb001695 bl a00112b0 <__umodsi3> a000b858: 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 ) {
a000b85c: e15a0000 cmp sl, r0 a000b860: 93a0a000 movls sl, #0 a000b864: 83a0a001 movhi sl, #1 a000b868: e1540000 cmp r4, r0 a000b86c: 23a0a000 movcs sl, #0 a000b870: e35a0000 cmp sl, #0
a000b874: 1affffec bne a000b82c <_Heap_Allocate_aligned_with_boundary+0x11c>
a000b878: 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 ) {
a000b87c: e59d2008 ldr r2, [sp, #8] a000b880: e1520004 cmp r2, r4
a000b884: 8a00000a bhi a000b8b4 <_Heap_Allocate_aligned_with_boundary+0x1a4>
a000b888: e59d100c ldr r1, [sp, #12] a000b88c: e1a00004 mov r0, r4 a000b890: eb001686 bl a00112b0 <__umodsi3> a000b894: e3e0a007 mvn sl, #7 a000b898: e069a00a rsb sl, r9, sl
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 ) {
a000b89c: e59d1004 ldr r1, [sp, #4]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
a000b8a0: e08aa004 add sl, sl, r4 a000b8a4: e060300a rsb r3, r0, sl a000b8a8: e15a0000 cmp sl, r0 a000b8ac: 11510003 cmpne r1, r3
a000b8b0: 9a000005 bls a000b8cc <_Heap_Allocate_aligned_with_boundary+0x1bc>
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
a000b8b4: e5999008 ldr r9, [r9, #8] a000b8b8: 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 ) {
a000b8bc: e1570009 cmp r7, r9
a000b8c0: 0a00001d beq a000b93c <_Heap_Allocate_aligned_with_boundary+0x22c>
a000b8c4: e1a06003 mov r6, r3 a000b8c8: eaffffa6 b a000b768 <_Heap_Allocate_aligned_with_boundary+0x58>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
a000b8cc: e3540000 cmp r4, #0
a000b8d0: 0afffff7 beq a000b8b4 <_Heap_Allocate_aligned_with_boundary+0x1a4>
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
a000b8d4: e5972048 ldr r2, [r7, #72] ; 0x48
stats->searches += search_count;
a000b8d8: e597304c ldr r3, [r7, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
a000b8dc: e1a00007 mov r0, r7
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
a000b8e0: e2822001 add r2, r2, #1
stats->searches += search_count;
a000b8e4: 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;
a000b8e8: e5872048 str r2, [r7, #72] ; 0x48
stats->searches += search_count;
a000b8ec: e587304c str r3, [r7, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
a000b8f0: e1a01009 mov r1, r9 a000b8f4: e1a02004 mov r2, r4 a000b8f8: e1a03005 mov r3, r5 a000b8fc: ebffeb80 bl a0006704 <_Heap_Block_allocate> a000b900: e1a00004 mov r0, r4
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
a000b904: e5973044 ldr r3, [r7, #68] ; 0x44 a000b908: e1530006 cmp r3, r6
stats->max_search = search_count;
a000b90c: 35876044 strcc r6, [r7, #68] ; 0x44
}
return (void *) alloc_begin;
}
a000b910: e28dd01c add sp, sp, #28
a000b914: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
a000b918: e1550003 cmp r5, r3
a000b91c: 9a000008 bls a000b944 <_Heap_Allocate_aligned_with_boundary+0x234>
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
a000b920: e3a00000 mov r0, #0 a000b924: eafffff9 b a000b910 <_Heap_Allocate_aligned_with_boundary+0x200>
a000b928: e59d9018 ldr r9, [sp, #24] <== NOT EXECUTED
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
a000b92c: e2863001 add r3, r6, #1 <== NOT EXECUTED a000b930: 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 ) {
a000b934: e1570009 cmp r7, r9 <== NOT EXECUTED a000b938: 1affffe1 bne a000b8c4 <_Heap_Allocate_aligned_with_boundary+0x1b4><== NOT EXECUTED
a000b93c: e3a00000 mov r0, #0 a000b940: eaffffef b a000b904 <_Heap_Allocate_aligned_with_boundary+0x1f4>
if ( boundary < alloc_size ) {
return NULL;
}
if ( alignment == 0 ) {
alignment = page_size;
a000b944: e3580000 cmp r8, #0 a000b948: 01a08002 moveq r8, r2 a000b94c: eaffff7c b a000b744 <_Heap_Allocate_aligned_with_boundary+0x34>
a000b950 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
a000b950: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
a000b954: e1a04000 mov r4, r0
a000b958: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
a000b95c: e1a00001 mov r0, r1 a000b960: e5941010 ldr r1, [r4, #16] a000b964: eb001651 bl a00112b0 <__umodsi3>
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
a000b968: e5943020 ldr r3, [r4, #32]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
a000b96c: e2455008 sub r5, r5, #8
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
a000b970: 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;
a000b974: e1550003 cmp r5, r3
a000b978: 3a000030 bcc a000ba40 <_Heap_Free+0xf0>
a000b97c: e5941024 ldr r1, [r4, #36] ; 0x24 a000b980: e1550001 cmp r5, r1
a000b984: 8a00002d bhi a000ba40 <_Heap_Free+0xf0>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
a000b988: 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;
a000b98c: 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);
a000b990: 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;
a000b994: e1530002 cmp r3, r2
a000b998: 8a000028 bhi a000ba40 <_Heap_Free+0xf0>
a000b99c: e1510002 cmp r1, r2
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
a000b9a0: 33a00000 movcc r0, #0
a000b9a4: 3a000027 bcc a000ba48 <_Heap_Free+0xf8>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
a000b9a8: 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 ) ) {
a000b9ac: e2170001 ands r0, r7, #1
a000b9b0: 0a000024 beq a000ba48 <_Heap_Free+0xf8>
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 ));
a000b9b4: 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;
a000b9b8: e3c77001 bic r7, r7, #1 a000b9bc: 03a08000 moveq r8, #0
a000b9c0: 0a000004 beq a000b9d8 <_Heap_Free+0x88>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
a000b9c4: 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;
a000b9c8: e5900004 ldr r0, [r0, #4]
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
a000b9cc: e3100001 tst r0, #1 a000b9d0: 13a08000 movne r8, #0 a000b9d4: 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 ) ) {
a000b9d8: e21c0001 ands r0, ip, #1
a000b9dc: 1a00001a bne a000ba4c <_Heap_Free+0xfc>
uintptr_t const prev_size = block->prev_size;
a000b9e0: 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);
a000b9e4: 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;
a000b9e8: e153000a cmp r3, sl
a000b9ec: 8a000015 bhi a000ba48 <_Heap_Free+0xf8>
a000b9f0: e151000a cmp r1, sl
a000b9f4: 3a000013 bcc a000ba48 <_Heap_Free+0xf8>
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;
a000b9f8: 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) ) {
a000b9fc: e2100001 ands r0, r0, #1
a000ba00: 0a000010 beq a000ba48 <_Heap_Free+0xf8>
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
a000ba04: e3580000 cmp r8, #0
a000ba08: 0a000038 beq a000baf0 <_Heap_Free+0x1a0>
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
a000ba0c: e5940038 ldr r0, [r4, #56] ; 0x38
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
a000ba10: 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;
a000ba14: e0867007 add r7, r6, r7
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
a000ba18: e592200c ldr r2, [r2, #12]
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
a000ba1c: e087c00c add ip, r7, ip
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
a000ba20: e2400001 sub r0, r0, #1
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
a000ba24: 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;
a000ba28: e5823008 str r3, [r2, #8]
next->prev = prev;
a000ba2c: 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;
a000ba30: e5840038 str r0, [r4, #56] ; 0x38
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
a000ba34: 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;
a000ba38: e78ac00c str ip, [sl, ip] a000ba3c: ea00000e b a000ba7c <_Heap_Free+0x12c>
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
a000ba40: e3a00000 mov r0, #0
a000ba44: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
a000ba48: 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 */
a000ba4c: e3580000 cmp r8, #0
a000ba50: 0a000014 beq a000baa8 <_Heap_Free+0x158>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
a000ba54: e5923008 ldr r3, [r2, #8] a000ba58: e592200c ldr r2, [r2, #12]
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;
a000ba5c: e0877006 add r7, r7, r6
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
a000ba60: e3871001 orr r1, r7, #1
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
a000ba64: e5853008 str r3, [r5, #8]
new_block->prev = prev;
a000ba68: e585200c str r2, [r5, #12]
next->prev = new_block;
prev->next = new_block;
a000ba6c: e5825008 str r5, [r2, #8]
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
a000ba70: e583500c str r5, [r3, #12] a000ba74: e5851004 str r1, [r5, #4]
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
a000ba78: e7857007 str r7, [r5, r7]
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
a000ba7c: e5942040 ldr r2, [r4, #64] ; 0x40
++stats->frees;
a000ba80: e5943050 ldr r3, [r4, #80] ; 0x50
stats->free_size += block_size;
a000ba84: e5941030 ldr r1, [r4, #48] ; 0x30
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
a000ba88: e2422001 sub r2, r2, #1
++stats->frees;
a000ba8c: e2833001 add r3, r3, #1
stats->free_size += block_size;
a000ba90: e0816006 add r6, r1, r6
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
a000ba94: e5842040 str r2, [r4, #64] ; 0x40
++stats->frees;
a000ba98: e5843050 str r3, [r4, #80] ; 0x50
stats->free_size += block_size;
a000ba9c: e5846030 str r6, [r4, #48] ; 0x30
return( true );
a000baa0: e3a00001 mov r0, #1
a000baa4: 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;
a000baa8: e3863001 orr r3, r6, #1 a000baac: e5853004 str r3, [r5, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
a000bab0: e5943038 ldr r3, [r4, #56] ; 0x38
if ( stats->max_free_blocks < stats->free_blocks ) {
a000bab4: e594c03c ldr ip, [r4, #60] ; 0x3c
} 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;
a000bab8: 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;
a000babc: e5941008 ldr r1, [r4, #8]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
a000bac0: 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;
a000bac4: e3c00001 bic r0, r0, #1
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
if ( stats->max_free_blocks < stats->free_blocks ) {
a000bac8: e153000c cmp r3, ip
new_block->next = next;
a000bacc: e5851008 str r1, [r5, #8]
new_block->prev = block_before;
a000bad0: 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;
a000bad4: e5820004 str r0, [r2, #4]
block_before->next = new_block; next->prev = new_block;
a000bad8: e581500c str r5, [r1, #12]
next_block->prev_size = block_size;
a000badc: 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;
a000bae0: e5845008 str r5, [r4, #8]
/* Statistics */
++stats->free_blocks;
a000bae4: e5843038 str r3, [r4, #56] ; 0x38
if ( stats->max_free_blocks < stats->free_blocks ) {
stats->max_free_blocks = stats->free_blocks;
a000bae8: 8584303c strhi r3, [r4, #60] ; 0x3c a000baec: eaffffe2 b a000ba7c <_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;
a000baf0: e086c00c add ip, r6, ip
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
a000baf4: e38c3001 orr r3, ip, #1 a000baf8: e58a3004 str r3, [sl, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
a000bafc: e5923004 ldr r3, [r2, #4]
next_block->prev_size = size;
a000bb00: e785c006 str ip, [r5, r6]
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
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;
a000bb04: e3c33001 bic r3, r3, #1 a000bb08: e5823004 str r3, [r2, #4] a000bb0c: eaffffda b a000ba7c <_Heap_Free+0x12c>
a0012f68 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
a0012f68: e92d40f0 push {r4, r5, r6, r7, lr}
a0012f6c: e1a04000 mov r4, r0
a0012f70: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
a0012f74: e1a00001 mov r0, r1 a0012f78: e5941010 ldr r1, [r4, #16] a0012f7c: e1a07002 mov r7, r2 a0012f80: ebfff8ca bl a00112b0 <__umodsi3>
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
a0012f84: e5943020 ldr r3, [r4, #32]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
a0012f88: e2456008 sub r6, r5, #8
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
a0012f8c: 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;
a0012f90: e1500003 cmp r0, r3
a0012f94: 3a000012 bcc a0012fe4 <_Heap_Size_of_alloc_area+0x7c>
a0012f98: e5942024 ldr r2, [r4, #36] ; 0x24 a0012f9c: e1500002 cmp r0, r2
a0012fa0: 8a00000f bhi a0012fe4 <_Heap_Size_of_alloc_area+0x7c>
- 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;
a0012fa4: e5906004 ldr r6, [r0, #4] a0012fa8: 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);
a0012fac: 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;
a0012fb0: e1530006 cmp r3, r6
a0012fb4: 8a00000a bhi a0012fe4 <_Heap_Size_of_alloc_area+0x7c>
a0012fb8: e1520006 cmp r2, r6
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
a0012fbc: 33a00000 movcc r0, #0
a0012fc0: 3a000009 bcc a0012fec <_Heap_Size_of_alloc_area+0x84>
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;
a0012fc4: 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 )
a0012fc8: e2100001 ands r0, r0, #1
a0012fcc: 0a000006 beq a0012fec <_Heap_Size_of_alloc_area+0x84>
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
a0012fd0: e2655004 rsb r5, r5, #4 a0012fd4: e0856006 add r6, r5, r6 a0012fd8: e5876000 str r6, [r7]
return true;
a0012fdc: e3a00001 mov r0, #1
a0012fe0: e8bd80f0 pop {r4, r5, r6, r7, pc}
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
a0012fe4: e3a00000 mov r0, #0
a0012fe8: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
a0012fec: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
a0007468 <_Heap_Walk>:
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() ) ) {
a0007468: e59f3578 ldr r3, [pc, #1400] ; a00079e8 <_Heap_Walk+0x580>
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
a000746c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
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;
a0007470: e31200ff tst r2, #255 ; 0xff
if ( !_System_state_Is_up( _System_state_Get() ) ) {
a0007474: 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;
a0007478: e59f256c ldr r2, [pc, #1388] ; a00079ec <_Heap_Walk+0x584> a000747c: e59f956c ldr r9, [pc, #1388] ; a00079f0 <_Heap_Walk+0x588>
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
a0007480: e1a0a001 mov sl, r1
uintptr_t const page_size = heap->page_size;
a0007484: e5901010 ldr r1, [r0, #16]
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;
a0007488: 11a09002 movne r9, r2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
a000748c: 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;
a0007490: e5902014 ldr r2, [r0, #20]
Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block;
a0007494: e5903024 ldr r3, [r0, #36] ; 0x24
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
a0007498: e24dd038 sub sp, sp, #56 ; 0x38 a000749c: e1a04000 mov r4, r0
uintptr_t const page_size = heap->page_size;
a00074a0: e58d1024 str r1, [sp, #36] ; 0x24
uintptr_t const min_block_size = heap->min_block_size;
a00074a4: e58d2028 str r2, [sp, #40] ; 0x28
Heap_Block *const first_block = heap->first_block;
a00074a8: e5908020 ldr r8, [r0, #32]
Heap_Block *const last_block = heap->last_block;
a00074ac: 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() ) ) {
a00074b0: 0a000002 beq a00074c0 <_Heap_Walk+0x58>
}
block = next_block;
} while ( block != first_block );
return true;
a00074b4: e3a00001 mov r0, #1
}
a00074b8: e28dd038 add sp, sp, #56 ; 0x38
a00074bc: 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)(
a00074c0: e594101c ldr r1, [r4, #28] a00074c4: e5900018 ldr r0, [r0, #24] a00074c8: e5942008 ldr r2, [r4, #8] a00074cc: e594300c ldr r3, [r4, #12] a00074d0: e59dc028 ldr ip, [sp, #40] ; 0x28 a00074d4: e58d1008 str r1, [sp, #8] a00074d8: e59d102c ldr r1, [sp, #44] ; 0x2c a00074dc: e58d0004 str r0, [sp, #4] a00074e0: e58d2014 str r2, [sp, #20] a00074e4: e58d1010 str r1, [sp, #16] a00074e8: e58d3018 str r3, [sp, #24] a00074ec: e59f2500 ldr r2, [pc, #1280] ; a00079f4 <_Heap_Walk+0x58c> a00074f0: e58dc000 str ip, [sp] a00074f4: e58d800c str r8, [sp, #12] a00074f8: e1a0000a mov r0, sl a00074fc: e3a01000 mov r1, #0 a0007500: e59d3024 ldr r3, [sp, #36] ; 0x24 a0007504: e12fff39 blx r9
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
a0007508: e59d2024 ldr r2, [sp, #36] ; 0x24 a000750c: e3520000 cmp r2, #0
a0007510: 0a000024 beq a00075a8 <_Heap_Walk+0x140>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
a0007514: e59d3024 ldr r3, [sp, #36] ; 0x24 a0007518: e2135007 ands r5, r3, #7
a000751c: 1a000027 bne a00075c0 <_Heap_Walk+0x158>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
a0007520: e59d0028 ldr r0, [sp, #40] ; 0x28 a0007524: e59d1024 ldr r1, [sp, #36] ; 0x24 a0007528: ebffe54f bl a0000a6c <__umodsi3>
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
a000752c: e250b000 subs fp, r0, #0
a0007530: 1a000028 bne a00075d8 <_Heap_Walk+0x170>
a0007534: e2880008 add r0, r8, #8 a0007538: e59d1024 ldr r1, [sp, #36] ; 0x24 a000753c: ebffe54a bl a0000a6c <__umodsi3>
);
return false;
}
if (
a0007540: e2506000 subs r6, r0, #0
a0007544: 1a00002a bne a00075f4 <_Heap_Walk+0x18c>
block = next_block;
} while ( block != first_block );
return true;
}
a0007548: e598b004 ldr fp, [r8, #4]
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
a000754c: e21b5001 ands r5, fp, #1
a0007550: 0a0000bf beq a0007854 <_Heap_Walk+0x3ec>
- 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;
a0007554: e59dc02c ldr ip, [sp, #44] ; 0x2c a0007558: e59c3004 ldr r3, [ip, #4] a000755c: 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);
a0007560: 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;
a0007564: e5935004 ldr r5, [r3, #4]
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
a0007568: e2155001 ands r5, r5, #1
a000756c: 0a000007 beq a0007590 <_Heap_Walk+0x128>
);
return false;
}
if (
a0007570: e1580003 cmp r8, r3
a0007574: 0a000025 beq a0007610 <_Heap_Walk+0x1a8>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
a0007578: e1a0000a mov r0, sl <== NOT EXECUTED a000757c: e3a01001 mov r1, #1 <== NOT EXECUTED a0007580: e59f2470 ldr r2, [pc, #1136] ; a00079f8 <_Heap_Walk+0x590> <== NOT EXECUTED a0007584: e12fff39 blx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
a0007588: e1a00006 mov r0, r6 <== NOT EXECUTED a000758c: eaffffc9 b a00074b8 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
a0007590: e1a0000a mov r0, sl a0007594: e3a01001 mov r1, #1 a0007598: e59f245c ldr r2, [pc, #1116] ; a00079fc <_Heap_Walk+0x594> a000759c: e12fff39 blx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
a00075a0: e1a00005 mov r0, r5 a00075a4: eaffffc3 b a00074b8 <_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" );
a00075a8: e1a0000a mov r0, sl a00075ac: e3a01001 mov r1, #1 a00075b0: e59f2448 ldr r2, [pc, #1096] ; a0007a00 <_Heap_Walk+0x598> a00075b4: e12fff39 blx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
a00075b8: e59d0024 ldr r0, [sp, #36] ; 0x24 a00075bc: eaffffbd b a00074b8 <_Heap_Walk+0x50>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
a00075c0: e1a0000a mov r0, sl a00075c4: e3a01001 mov r1, #1 a00075c8: e59f2434 ldr r2, [pc, #1076] ; a0007a04 <_Heap_Walk+0x59c> a00075cc: e12fff39 blx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
a00075d0: e3a00000 mov r0, #0 a00075d4: eaffffb7 b a00074b8 <_Heap_Walk+0x50>
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
a00075d8: e1a0000a mov r0, sl a00075dc: e3a01001 mov r1, #1 a00075e0: e59f2420 ldr r2, [pc, #1056] ; a0007a08 <_Heap_Walk+0x5a0> a00075e4: e59d3028 ldr r3, [sp, #40] ; 0x28 a00075e8: e12fff39 blx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
a00075ec: e1a00005 mov r0, r5 a00075f0: eaffffb0 b a00074b8 <_Heap_Walk+0x50>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
a00075f4: e1a0000a mov r0, sl a00075f8: e3a01001 mov r1, #1 a00075fc: e59f2408 ldr r2, [pc, #1032] ; a0007a0c <_Heap_Walk+0x5a4> a0007600: e1a03008 mov r3, r8 a0007604: e12fff39 blx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
a0007608: e1a0000b mov r0, fp a000760c: eaffffa9 b a00074b8 <_Heap_Walk+0x50>
block = next_block;
} while ( block != first_block );
return true;
}
a0007610: e5945008 ldr r5, [r4, #8]
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
a0007614: 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 ) {
a0007618: e1540005 cmp r4, r5 a000761c: 05943020 ldreq r3, [r4, #32]
a0007620: 0a00000c beq a0007658 <_Heap_Walk+0x1f0>
block = next_block;
} while ( block != first_block );
return true;
}
a0007624: 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;
a0007628: e1530005 cmp r3, r5
a000762c: 9a00008e bls a000786c <_Heap_Walk+0x404>
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)(
a0007630: e1a0000a mov r0, sl a0007634: e3a01001 mov r1, #1 a0007638: e59f23d0 ldr r2, [pc, #976] ; a0007a10 <_Heap_Walk+0x5a8> a000763c: e1a03005 mov r3, r5 a0007640: e12fff39 blx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
a0007644: e3a00000 mov r0, #0 a0007648: eaffff9a b a00074b8 <_Heap_Walk+0x50> a000764c: e1a03008 mov r3, r8 a0007650: e59db034 ldr fp, [sp, #52] ; 0x34 a0007654: e59d8030 ldr r8, [sp, #48] ; 0x30
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
a0007658: 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;
a000765c: 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);
a0007660: 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;
a0007664: e1530005 cmp r3, r5
a0007668: 9a000007 bls a000768c <_Heap_Walk+0x224>
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)(
a000766c: e1a0000a mov r0, sl a0007670: e58d5000 str r5, [sp] a0007674: e3a01001 mov r1, #1 a0007678: e59f2394 ldr r2, [pc, #916] ; a0007a14 <_Heap_Walk+0x5ac> a000767c: e1a03006 mov r3, r6 a0007680: e12fff39 blx r9
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
a0007684: e3a00000 mov r0, #0 a0007688: eaffff8a b a00074b8 <_Heap_Walk+0x50> a000768c: e5943024 ldr r3, [r4, #36] ; 0x24 a0007690: e1530005 cmp r3, r5
a0007694: 3afffff4 bcc a000766c <_Heap_Walk+0x204>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
a0007698: e59d1024 ldr r1, [sp, #36] ; 0x24 a000769c: e1a00007 mov r0, r7 a00076a0: ebffe4f1 bl a0000a6c <__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;
a00076a4: e59d102c ldr r1, [sp, #44] ; 0x2c a00076a8: e0563001 subs r3, r6, r1 a00076ac: 13a03001 movne r3, #1
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
a00076b0: e3500000 cmp r0, #0
a00076b4: 0a000001 beq a00076c0 <_Heap_Walk+0x258>
a00076b8: e3530000 cmp r3, #0
a00076bc: 1a0000a2 bne a000794c <_Heap_Walk+0x4e4>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
a00076c0: e59d2028 ldr r2, [sp, #40] ; 0x28 a00076c4: e1520007 cmp r2, r7
a00076c8: 9a000001 bls a00076d4 <_Heap_Walk+0x26c>
a00076cc: e3530000 cmp r3, #0
a00076d0: 1a0000a5 bne a000796c <_Heap_Walk+0x504>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
a00076d4: e1560005 cmp r6, r5
a00076d8: 3a000001 bcc a00076e4 <_Heap_Walk+0x27c>
a00076dc: e3530000 cmp r3, #0
a00076e0: 1a0000aa bne a0007990 <_Heap_Walk+0x528>
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;
a00076e4: e5953004 ldr r3, [r5, #4] a00076e8: e20bb001 and fp, fp, #1
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
a00076ec: e3130001 tst r3, #1
a00076f0: 0a000016 beq a0007750 <_Heap_Walk+0x2e8>
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
a00076f4: e35b0000 cmp fp, #0
a00076f8: 0a00000b beq a000772c <_Heap_Walk+0x2c4>
(*printer)(
a00076fc: e58d7000 str r7, [sp] a0007700: e1a0000a mov r0, sl a0007704: e3a01000 mov r1, #0 a0007708: e59f2308 ldr r2, [pc, #776] ; a0007a18 <_Heap_Walk+0x5b0> a000770c: e1a03006 mov r3, r6 a0007710: e12fff39 blx r9
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
a0007714: e1580005 cmp r8, r5
a0007718: 0affff65 beq a00074b4 <_Heap_Walk+0x4c>
a000771c: e595b004 ldr fp, [r5, #4] a0007720: e5943020 ldr r3, [r4, #32] a0007724: e1a06005 mov r6, r5 a0007728: eaffffcb b a000765c <_Heap_Walk+0x1f4>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
a000772c: e58d7000 str r7, [sp] a0007730: e5963000 ldr r3, [r6] a0007734: e1a0000a mov r0, sl a0007738: e1a0100b mov r1, fp a000773c: e58d3004 str r3, [sp, #4] a0007740: e59f22d4 ldr r2, [pc, #724] ; a0007a1c <_Heap_Walk+0x5b4> a0007744: e1a03006 mov r3, r6 a0007748: e12fff39 blx r9 a000774c: eafffff0 b a0007714 <_Heap_Walk+0x2ac>
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 ?
a0007750: 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)(
a0007754: e5943008 ldr r3, [r4, #8]
block = next_block;
} while ( block != first_block );
return true;
}
a0007758: 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)(
a000775c: e1530002 cmp r3, r2 a0007760: 059f02b8 ldreq r0, [pc, #696] ; a0007a20 <_Heap_Walk+0x5b8>
a0007764: 0a000003 beq a0007778 <_Heap_Walk+0x310>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
a0007768: e59f32b4 ldr r3, [pc, #692] ; a0007a24 <_Heap_Walk+0x5bc> a000776c: e1540002 cmp r4, r2 a0007770: e59f02b0 ldr r0, [pc, #688] ; a0007a28 <_Heap_Walk+0x5c0> a0007774: 01a00003 moveq r0, r3
block->next,
block->next == last_free_block ?
a0007778: 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)(
a000777c: e1510003 cmp r1, r3 a0007780: 059f12a4 ldreq r1, [pc, #676] ; a0007a2c <_Heap_Walk+0x5c4>
a0007784: 0a000003 beq a0007798 <_Heap_Walk+0x330>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
a0007788: e59fc2a0 ldr ip, [pc, #672] ; a0007a30 <_Heap_Walk+0x5c8> a000778c: e1540003 cmp r4, r3 a0007790: e59f1290 ldr r1, [pc, #656] ; a0007a28 <_Heap_Walk+0x5c0> a0007794: 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)(
a0007798: e58d2004 str r2, [sp, #4] a000779c: e58d0008 str r0, [sp, #8] a00077a0: e58d300c str r3, [sp, #12] a00077a4: e58d1010 str r1, [sp, #16] a00077a8: e1a03006 mov r3, r6 a00077ac: e58d7000 str r7, [sp] a00077b0: e1a0000a mov r0, sl a00077b4: e3a01000 mov r1, #0 a00077b8: e59f2274 ldr r2, [pc, #628] ; a0007a34 <_Heap_Walk+0x5cc> a00077bc: e12fff39 blx r9
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
a00077c0: e5953000 ldr r3, [r5] a00077c4: e1570003 cmp r7, r3
a00077c8: 1a000010 bne a0007810 <_Heap_Walk+0x3a8>
);
return false;
}
if ( !prev_used ) {
a00077cc: e35b0000 cmp fp, #0
a00077d0: 0a000018 beq a0007838 <_Heap_Walk+0x3d0>
block = next_block;
} while ( block != first_block );
return true;
}
a00077d4: 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 ) {
a00077d8: e1540003 cmp r4, r3
a00077dc: 0a000004 beq a00077f4 <_Heap_Walk+0x38c>
if ( free_block == block ) {
a00077e0: e1560003 cmp r6, r3
a00077e4: 0affffca beq a0007714 <_Heap_Walk+0x2ac>
return true;
}
free_block = free_block->next;
a00077e8: 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 ) {
a00077ec: e1540003 cmp r4, r3
a00077f0: 1afffffa bne a00077e0 <_Heap_Walk+0x378>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
a00077f4: e1a0000a mov r0, sl a00077f8: e3a01001 mov r1, #1 a00077fc: e59f2234 ldr r2, [pc, #564] ; a0007a38 <_Heap_Walk+0x5d0> a0007800: e1a03006 mov r3, r6 a0007804: e12fff39 blx r9
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
a0007808: e3a00000 mov r0, #0 a000780c: eaffff29 b a00074b8 <_Heap_Walk+0x50>
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
a0007810: e58d3004 str r3, [sp, #4] a0007814: e1a0000a mov r0, sl a0007818: e58d7000 str r7, [sp] a000781c: e58d5008 str r5, [sp, #8] a0007820: e3a01001 mov r1, #1 a0007824: e59f2210 ldr r2, [pc, #528] ; a0007a3c <_Heap_Walk+0x5d4> a0007828: e1a03006 mov r3, r6 a000782c: e12fff39 blx r9
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
a0007830: e3a00000 mov r0, #0 a0007834: eaffff1f b a00074b8 <_Heap_Walk+0x50>
return false;
}
if ( !prev_used ) {
(*printer)(
a0007838: e1a0000a mov r0, sl a000783c: e3a01001 mov r1, #1 a0007840: e59f21f8 ldr r2, [pc, #504] ; a0007a40 <_Heap_Walk+0x5d8> a0007844: e1a03006 mov r3, r6 a0007848: e12fff39 blx r9
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
a000784c: e1a0000b mov r0, fp a0007850: eaffff18 b a00074b8 <_Heap_Walk+0x50>
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
a0007854: e1a0000a mov r0, sl a0007858: e3a01001 mov r1, #1 a000785c: e59f21e0 ldr r2, [pc, #480] ; a0007a44 <_Heap_Walk+0x5dc> a0007860: e12fff39 blx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
a0007864: e1a00005 mov r0, r5 a0007868: eaffff12 b a00074b8 <_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;
a000786c: e594c024 ldr ip, [r4, #36] ; 0x24 a0007870: e15c0005 cmp ip, r5
a0007874: 3affff6d bcc a0007630 <_Heap_Walk+0x1c8>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
a0007878: e2850008 add r0, r5, #8 a000787c: e1a01007 mov r1, r7 a0007880: e58d3020 str r3, [sp, #32] a0007884: e58dc01c str ip, [sp, #28] a0007888: ebffe477 bl a0000a6c <__umodsi3>
);
return false;
}
if (
a000788c: e3500000 cmp r0, #0 a0007890: e59d3020 ldr r3, [sp, #32] a0007894: e59dc01c ldr ip, [sp, #28]
a0007898: 1a000044 bne a00079b0 <_Heap_Walk+0x548>
- 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;
a000789c: e5952004 ldr r2, [r5, #4] a00078a0: e3c22001 bic r2, r2, #1
block = next_block;
} while ( block != first_block );
return true;
}
a00078a4: 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;
a00078a8: e5922004 ldr r2, [r2, #4]
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
a00078ac: e3120001 tst r2, #1
a00078b0: 1a000045 bne a00079cc <_Heap_Walk+0x564>
a00078b4: e58d8030 str r8, [sp, #48] ; 0x30 a00078b8: e58db034 str fp, [sp, #52] ; 0x34 a00078bc: e1a01004 mov r1, r4 a00078c0: e1a06005 mov r6, r5 a00078c4: e1a08003 mov r8, r3 a00078c8: e1a0b00c mov fp, ip a00078cc: ea000013 b a0007920 <_Heap_Walk+0x4b8>
return false;
}
prev_block = free_block;
free_block = free_block->next;
a00078d0: 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 ) {
a00078d4: e1540005 cmp r4, r5
a00078d8: 0affff5b beq a000764c <_Heap_Walk+0x1e4>
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;
a00078dc: e1580005 cmp r8, r5
a00078e0: 8affff52 bhi a0007630 <_Heap_Walk+0x1c8>
a00078e4: e155000b cmp r5, fp
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
a00078e8: e2850008 add r0, r5, #8 a00078ec: 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;
a00078f0: 8affff4e bhi a0007630 <_Heap_Walk+0x1c8>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
a00078f4: ebffe45c bl a0000a6c <__umodsi3>
);
return false;
}
if (
a00078f8: e3500000 cmp r0, #0
a00078fc: 1a00002b bne a00079b0 <_Heap_Walk+0x548>
- 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;
a0007900: e5953004 ldr r3, [r5, #4]
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
a0007904: e1a01006 mov r1, r6 a0007908: e1a06005 mov r6, r5 a000790c: e3c33001 bic r3, r3, #1
block = next_block;
} while ( block != first_block );
return true;
}
a0007910: 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;
a0007914: e5933004 ldr r3, [r3, #4]
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
a0007918: e3130001 tst r3, #1
a000791c: 1a00002a bne a00079cc <_Heap_Walk+0x564>
);
return false;
}
if ( free_block->prev != prev_block ) {
a0007920: e595200c ldr r2, [r5, #12] a0007924: e1520001 cmp r2, r1
a0007928: 0affffe8 beq a00078d0 <_Heap_Walk+0x468>
(*printer)(
a000792c: e58d2000 str r2, [sp] a0007930: e1a0000a mov r0, sl a0007934: e3a01001 mov r1, #1 a0007938: e59f2108 ldr r2, [pc, #264] ; a0007a48 <_Heap_Walk+0x5e0> a000793c: e1a03005 mov r3, r5 a0007940: e12fff39 blx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
a0007944: e3a00000 mov r0, #0 a0007948: eafffeda b a00074b8 <_Heap_Walk+0x50>
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
a000794c: e1a0000a mov r0, sl a0007950: e58d7000 str r7, [sp] a0007954: e3a01001 mov r1, #1 a0007958: e59f20ec ldr r2, [pc, #236] ; a0007a4c <_Heap_Walk+0x5e4> a000795c: e1a03006 mov r3, r6 a0007960: e12fff39 blx r9
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
a0007964: e3a00000 mov r0, #0 a0007968: eafffed2 b a00074b8 <_Heap_Walk+0x50>
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
a000796c: e58d2004 str r2, [sp, #4] a0007970: e1a0000a mov r0, sl a0007974: e58d7000 str r7, [sp] a0007978: e3a01001 mov r1, #1 a000797c: e59f20cc ldr r2, [pc, #204] ; a0007a50 <_Heap_Walk+0x5e8> a0007980: e1a03006 mov r3, r6 a0007984: e12fff39 blx r9
block,
block_size,
min_block_size
);
return false;
a0007988: e3a00000 mov r0, #0 a000798c: eafffec9 b a00074b8 <_Heap_Walk+0x50>
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
a0007990: e1a0000a mov r0, sl a0007994: e58d5000 str r5, [sp] a0007998: e3a01001 mov r1, #1 a000799c: e59f20b0 ldr r2, [pc, #176] ; a0007a54 <_Heap_Walk+0x5ec> a00079a0: e1a03006 mov r3, r6 a00079a4: e12fff39 blx r9
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
a00079a8: e3a00000 mov r0, #0 a00079ac: eafffec1 b a00074b8 <_Heap_Walk+0x50>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
a00079b0: e1a0000a mov r0, sl a00079b4: e3a01001 mov r1, #1 a00079b8: e59f2098 ldr r2, [pc, #152] ; a0007a58 <_Heap_Walk+0x5f0> a00079bc: e1a03005 mov r3, r5 a00079c0: e12fff39 blx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
a00079c4: e3a00000 mov r0, #0 a00079c8: eafffeba b a00074b8 <_Heap_Walk+0x50>
return false;
}
if ( _Heap_Is_used( free_block ) ) {
(*printer)(
a00079cc: e1a0000a mov r0, sl a00079d0: e3a01001 mov r1, #1 a00079d4: e59f2080 ldr r2, [pc, #128] ; a0007a5c <_Heap_Walk+0x5f4> a00079d8: e1a03005 mov r3, r5 a00079dc: e12fff39 blx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
a00079e0: e3a00000 mov r0, #0 a00079e4: eafffeb3 b a00074b8 <_Heap_Walk+0x50>
a0006950 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
a0006950: 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 )
a0006954: e5904034 ldr r4, [r0, #52] ; 0x34
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
a0006958: e24dd014 sub sp, sp, #20 a000695c: e1a05000 mov r5, r0
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
a0006960: e3540000 cmp r4, #0
/* * 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 );
a0006964: e1d070b8 ldrh r7, [r0, #8]
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
a0006968: 0a00009c beq a0006be0 <_Objects_Extend_information+0x290>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
a000696c: e1d081b4 ldrh r8, [r0, #20] a0006970: e1d0a1b0 ldrh sl, [r0, #16] a0006974: e1a01008 mov r1, r8 a0006978: e1a0000a mov r0, sl a000697c: eb002a05 bl a0011198 <__aeabi_uidiv> a0006980: e1a03800 lsl r3, r0, #16
for ( ; block < block_count; block++ ) {
a0006984: e1b03823 lsrs r3, r3, #16
a0006988: 0a00009a beq a0006bf8 <_Objects_Extend_information+0x2a8>
if ( information->object_blocks[ block ] == NULL ) {
a000698c: e5949000 ldr r9, [r4] a0006990: e3590000 cmp r9, #0 a0006994: 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 );
a0006998: 01a06007 moveq r6, r7
index_base = minimum_index; block = 0;
a000699c: 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 ) {
a00069a0: 0a00000c beq a00069d8 <_Objects_Extend_information+0x88>
a00069a4: e1a02004 mov r2, r4 a00069a8: 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 );
a00069ac: e1a06007 mov r6, r7
index_base = minimum_index; block = 0;
a00069b0: e3a04000 mov r4, #0 a00069b4: ea000002 b a00069c4 <_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 ) {
a00069b8: e5b29004 ldr r9, [r2, #4]! a00069bc: e3590000 cmp r9, #0
a00069c0: 0a000004 beq a00069d8 <_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++ ) {
a00069c4: e2844001 add r4, r4, #1 a00069c8: e1530004 cmp r3, r4
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
break;
} else
index_base += information->allocation_size;
a00069cc: 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++ ) {
a00069d0: 8afffff8 bhi a00069b8 <_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;
a00069d4: e3a09001 mov r9, #1
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
a00069d8: 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 ) {
a00069dc: e35a0801 cmp sl, #65536 ; 0x10000
a00069e0: 2a000064 bcs a0006b78 <_Objects_Extend_information+0x228>
/*
* 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 ) {
a00069e4: 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;
a00069e8: e5950018 ldr r0, [r5, #24]
if ( information->auto_extend ) {
a00069ec: 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;
a00069f0: e0000091 mul r0, r1, r0
if ( information->auto_extend ) {
a00069f4: 1a000061 bne a0006b80 <_Objects_Extend_information+0x230>
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
a00069f8: e58d3000 str r3, [sp] a00069fc: eb000883 bl a0008c10 <_Workspace_Allocate_or_fatal_error> a0006a00: e59d3000 ldr r3, [sp] a0006a04: e1a08000 mov r8, r0
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
a0006a08: e3590000 cmp r9, #0
a0006a0c: 0a00003a beq a0006afc <_Objects_Extend_information+0x1ac>
*/
/*
* Up the block count and maximum
*/
block_count++;
a0006a10: e283b001 add fp, r3, #1
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
a0006a14: e08b008b add r0, fp, fp, lsl #1
((maximum + minimum_index) * sizeof(Objects_Control *));
a0006a18: e08a0000 add r0, sl, r0
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
a0006a1c: e0800007 add r0, r0, r7
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
a0006a20: e1a00100 lsl r0, r0, #2 a0006a24: e58d3000 str r3, [sp] a0006a28: eb00086e bl a0008be8 <_Workspace_Allocate>
if ( !object_blocks ) {
a0006a2c: e2509000 subs r9, r0, #0 a0006a30: e59d3000 ldr r3, [sp]
a0006a34: 0a000074 beq a0006c0c <_Objects_Extend_information+0x2bc>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
a0006a38: e1d521b0 ldrh r2, [r5, #16]
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
a0006a3c: e089c10b add ip, r9, fp, lsl #2 a0006a40: e089b18b add fp, r9, fp, lsl #3 a0006a44: e1570002 cmp r7, r2
a0006a48: 3a000052 bcc a0006b98 <_Objects_Extend_information+0x248>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
a0006a4c: e3570000 cmp r7, #0 a0006a50: 13a02000 movne r2, #0 a0006a54: 11a0100b movne r1, fp
local_table[ index ] = NULL;
a0006a58: 11a00002 movne r0, r2
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
a0006a5c: 0a000003 beq a0006a70 <_Objects_Extend_information+0x120>
a0006a60: e2822001 add r2, r2, #1 a0006a64: e1570002 cmp r7, r2
local_table[ index ] = NULL;
a0006a68: e4810004 str r0, [r1], #4
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
a0006a6c: 8afffffb bhi a0006a60 <_Objects_Extend_information+0x110>
a0006a70: 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 );
a0006a74: e1d511b4 ldrh r1, [r5, #20]
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
a0006a78: e3a00000 mov r0, #0 a0006a7c: e7890003 str r0, [r9, r3]
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
a0006a80: e0861001 add r1, r6, r1
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
a0006a84: e1560001 cmp r6, r1
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
a0006a88: e78c0003 str r0, [ip, r3]
for ( index=index_base ;
a0006a8c: 2a000005 bcs a0006aa8 <_Objects_Extend_information+0x158>
a0006a90: e08b2106 add r2, fp, r6, lsl #2
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
a0006a94: 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++ ) {
a0006a98: 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 ;
a0006a9c: e1530001 cmp r3, r1
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
a0006aa0: 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 ;
a0006aa4: 3afffffb bcc a0006a98 <_Objects_Extend_information+0x148>
a0006aa8: e10f3000 mrs r3, CPSR a0006aac: e3832080 orr r2, r3, #128 ; 0x80 a0006ab0: e129f002 msr CPSR_fc, r2
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
a0006ab4: 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(
a0006ab8: e1d510b4 ldrh r1, [r5, #4]
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;
a0006abc: e1a0a80a lsl sl, sl, #16 a0006ac0: e1a02c02 lsl r2, r2, #24 a0006ac4: e3822801 orr r2, r2, #65536 ; 0x10000 a0006ac8: e1a0a82a lsr sl, sl, #16
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
a0006acc: 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) |
a0006ad0: e182200a orr r2, r2, sl
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
a0006ad4: e5950034 ldr r0, [r5, #52] ; 0x34
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
a0006ad8: e585c030 str ip, [r5, #48] ; 0x30
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
a0006adc: e5859034 str r9, [r5, #52] ; 0x34
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
a0006ae0: e585b01c str fp, [r5, #28]
information->maximum = (Objects_Maximum) maximum;
a0006ae4: e1c5a1b0 strh sl, [r5, #16]
information->maximum_id = _Objects_Build_id(
a0006ae8: e585200c str r2, [r5, #12]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a0006aec: e129f003 msr CPSR_fc, r3
information->maximum
);
_ISR_Enable( level );
if ( old_tables )
a0006af0: e3500000 cmp r0, #0
a0006af4: 0a000000 beq a0006afc <_Objects_Extend_information+0x1ac>
_Workspace_Free( old_tables );
a0006af8: eb000840 bl a0008c00 <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
a0006afc: e5953034 ldr r3, [r5, #52] ; 0x34
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
a0006b00: e28d7008 add r7, sp, #8 a0006b04: e1a01008 mov r1, r8
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
a0006b08: e7838104 str r8, [r3, r4, lsl #2]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
a0006b0c: e1a00007 mov r0, r7 a0006b10: e1d521b4 ldrh r2, [r5, #20] a0006b14: e5953018 ldr r3, [r5, #24] a0006b18: eb00126b bl a000b4cc <_Chain_Initialize>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
a0006b1c: e1a04104 lsl r4, r4, #2
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
a0006b20: 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 ) {
a0006b24: ea000009 b a0006b50 <_Objects_Extend_information+0x200> a0006b28: e5953000 ldr r3, [r5]
the_object->id = _Objects_Build_id(
a0006b2c: e1d520b4 ldrh r2, [r5, #4]
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
a0006b30: e1a00008 mov r0, r8 a0006b34: e1a03c03 lsl r3, r3, #24 a0006b38: e3833801 orr r3, r3, #65536 ; 0x10000
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
a0006b3c: 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) |
a0006b40: e1833006 orr r3, r3, r6
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
the_object->id = _Objects_Build_id(
a0006b44: e5813008 str r3, [r1, #8]
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
a0006b48: ebfffce1 bl a0005ed4 <_Chain_Append>
index++;
a0006b4c: 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 ) {
a0006b50: e1a00007 mov r0, r7 a0006b54: ebfffcf1 bl a0005f20 <_Chain_Get> a0006b58: e2501000 subs r1, r0, #0
a0006b5c: 1afffff1 bne a0006b28 <_Objects_Extend_information+0x1d8>
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
a0006b60: e1d522bc ldrh r2, [r5, #44] ; 0x2c
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
a0006b64: e1d531b4 ldrh r3, [r5, #20] a0006b68: e5951030 ldr r1, [r5, #48] ; 0x30
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
a0006b6c: e0832002 add r2, r3, r2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
a0006b70: e7813004 str r3, [r1, r4]
information->inactive =
a0006b74: e1c522bc strh r2, [r5, #44] ; 0x2c
(Objects_Maximum)(information->inactive + information->allocation_size);
}
a0006b78: e28dd014 add sp, sp, #20
a0006b7c: 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 );
a0006b80: e58d3000 str r3, [sp] a0006b84: eb000817 bl a0008be8 <_Workspace_Allocate>
if ( !new_object_block )
a0006b88: e2508000 subs r8, r0, #0 a0006b8c: e59d3000 ldr r3, [sp]
a0006b90: 1affff9c bne a0006a08 <_Objects_Extend_information+0xb8>
a0006b94: eafffff7 b a0006b78 <_Objects_Extend_information+0x228>
/*
* 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,
a0006b98: e1a03103 lsl r3, r3, #2
a0006b9c: e5951034 ldr r1, [r5, #52] ; 0x34
a0006ba0: e1a02003 mov r2, r3
a0006ba4: e88d1008 stm sp, {r3, ip}
a0006ba8: eb001e09 bl a000e3d4 <memcpy>
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
a0006bac: e89d1008 ldm sp, {r3, ip}
a0006bb0: e5951030 ldr r1, [r5, #48] ; 0x30
a0006bb4: e1a0000c mov r0, ip
a0006bb8: e1a02003 mov r2, r3
a0006bbc: eb001e04 bl a000e3d4 <memcpy>
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
a0006bc0: e1d521b0 ldrh r2, [r5, #16]
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
a0006bc4: e1a0000b mov r0, fp a0006bc8: e595101c ldr r1, [r5, #28]
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
a0006bcc: 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,
a0006bd0: e1a02102 lsl r2, r2, #2
a0006bd4: eb001dfe bl a000e3d4 <memcpy>
a0006bd8: e89d1008 ldm sp, {r3, ip}
a0006bdc: eaffffa4 b a0006a74 <_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 )
a0006be0: e1d0a1b0 ldrh sl, [r0, #16] a0006be4: 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 );
a0006be8: 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;
a0006bec: e3a09001 mov r9, #1
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
a0006bf0: e1a03004 mov r3, r4 a0006bf4: eaffff77 b a00069d8 <_Objects_Extend_information+0x88>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
a0006bf8: 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 );
a0006bfc: 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;
a0006c00: e3a09001 mov r9, #1 <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
a0006c04: e1a04003 mov r4, r3 <== NOT EXECUTED a0006c08: eaffff72 b a00069d8 <_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 );
a0006c0c: e1a00008 mov r0, r8 a0006c10: eb0007fa bl a0008c00 <_Workspace_Free>
return;
a0006c14: eaffffd7 b a0006b78 <_Objects_Extend_information+0x228>
a0006f94 <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
a0006f94: 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 );
a0006f98: e1d040b8 ldrh r4, [r0, #8]
block_count = (information->maximum - index_base) /
a0006f9c: e1d051b4 ldrh r5, [r0, #20]
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
a0006fa0: 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) /
a0006fa4: e1d001b0 ldrh r0, [r0, #16] a0006fa8: e1a01005 mov r1, r5 a0006fac: e0640000 rsb r0, r4, r0 a0006fb0: eb002878 bl a0011198 <__aeabi_uidiv>
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
a0006fb4: e3500000 cmp r0, #0
a0006fb8: 0a00000d beq a0006ff4 <_Objects_Shrink_information+0x60>
if ( information->inactive_per_block[ block ] ==
a0006fbc: e5962030 ldr r2, [r6, #48] ; 0x30 a0006fc0: e5923000 ldr r3, [r2] a0006fc4: 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++ ) {
a0006fc8: 13a03000 movne r3, #0
if ( information->inactive_per_block[ block ] ==
a0006fcc: 1a000005 bne a0006fe8 <_Objects_Shrink_information+0x54>
a0006fd0: ea000008 b a0006ff8 <_Objects_Shrink_information+0x64> <== NOT EXECUTED
a0006fd4: e5b21004 ldr r1, [r2, #4]!
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
a0006fd8: e0844005 add r4, r4, r5 a0006fdc: 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 ] ==
a0006fe0: e1550001 cmp r5, r1
a0006fe4: 0a000004 beq a0006ffc <_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++ ) {
a0006fe8: e2833001 add r3, r3, #1 a0006fec: e1500003 cmp r0, r3
a0006ff0: 8afffff7 bhi a0006fd4 <_Objects_Shrink_information+0x40>
a0006ff4: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
a0006ff8: e3a07000 mov r7, #0 <== NOT EXECUTED
information->allocation_size ) {
/*
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
a0006ffc: e5960020 ldr r0, [r6, #32] a0007000: ea000002 b a0007010 <_Objects_Shrink_information+0x7c>
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
a0007004: e3550000 cmp r5, #0
a0007008: 0a00000b beq a000703c <_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;
a000700c: e1a00005 mov r0, r5
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
do {
index = _Objects_Get_index( the_object->id );
a0007010: 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;
a0007014: e5905000 ldr r5, [r0]
if ((index >= index_base) &&
a0007018: e1530004 cmp r3, r4
a000701c: 3afffff8 bcc a0007004 <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
a0007020: e1d621b4 ldrh r2, [r6, #20] a0007024: 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) &&
a0007028: e1530002 cmp r3, r2
a000702c: 2afffff4 bcs a0007004 <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
a0007030: ebfffbb2 bl a0005f00 <_Chain_Extract>
}
}
while ( the_object );
a0007034: e3550000 cmp r5, #0
a0007038: 1afffff3 bne a000700c <_Objects_Shrink_information+0x78>
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
a000703c: e5963034 ldr r3, [r6, #52] ; 0x34 a0007040: e7930007 ldr r0, [r3, r7] a0007044: eb0006ed bl a0008c00 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
a0007048: e1d602bc ldrh r0, [r6, #44] ; 0x2c a000704c: 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;
a0007050: e5961034 ldr r1, [r6, #52] ; 0x34
information->inactive_per_block[ block ] = 0;
a0007054: e5962030 ldr r2, [r6, #48] ; 0x30
information->inactive -= information->allocation_size;
a0007058: 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;
a000705c: e7815007 str r5, [r1, r7]
information->inactive_per_block[ block ] = 0;
a0007060: e7825007 str r5, [r2, r7]
information->inactive -= information->allocation_size;
a0007064: e1c632bc strh r3, [r6, #44] ; 0x2c
return;
a0007068: e8bd80f0 pop {r4, r5, r6, r7, pc}
a000da98 <_POSIX_signals_Clear_process_signals>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a000da98: e10f2000 mrs r2, CPSR a000da9c: e3823080 orr r3, r2, #128 ; 0x80 a000daa0: 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 ) {
a000daa4: e3a0300c mov r3, #12 a000daa8: e0030390 mul r3, r0, r3 a000daac: e59f1048 ldr r1, [pc, #72] ; a000dafc <_POSIX_signals_Clear_process_signals+0x64> a000dab0: e7911003 ldr r1, [r1, r3] a000dab4: e3510002 cmp r1, #2
a000dab8: 0a000007 beq a000dadc <_POSIX_signals_Clear_process_signals+0x44>
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
a000dabc: e59f303c ldr r3, [pc, #60] ; a000db00 <_POSIX_signals_Clear_process_signals+0x68> a000dac0: e3a0c001 mov ip, #1 a000dac4: e2400001 sub r0, r0, #1 a000dac8: e5931000 ldr r1, [r3] a000dacc: e1c1001c bic r0, r1, ip, lsl r0 a000dad0: e5830000 str r0, [r3]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a000dad4: e129f002 msr CPSR_fc, r2
}
_ISR_Enable( level );
}
a000dad8: e12fff1e bx lr a000dadc: e59f1020 ldr r1, [pc, #32] ; a000db04 <_POSIX_signals_Clear_process_signals+0x6c>
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
a000dae0: e283c004 add ip, r3, #4
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
a000dae4: e7913003 ldr r3, [r1, r3] a000dae8: e08c1001 add r1, ip, r1 a000daec: e1530001 cmp r3, r1
a000daf0: 0afffff1 beq a000dabc <_POSIX_signals_Clear_process_signals+0x24>
a000daf4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
}
a000daf8: e12fff1e bx lr <== NOT EXECUTED
a0006548 <_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();
a0006548: e59f30bc ldr r3, [pc, #188] ; a000660c <_TOD_Validate+0xc4>
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
a000654c: 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) ||
a0006550: 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();
a0006554: e593100c ldr r1, [r3, #12]
if ((!the_tod) ||
a0006558: 0a000029 beq a0006604 <_TOD_Validate+0xbc>
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
a000655c: e3a0093d mov r0, #999424 ; 0xf4000 a0006560: e2800d09 add r0, r0, #576 ; 0x240 a0006564: eb0048f1 bl a0018930 <__aeabi_uidiv>
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
a0006568: e5943018 ldr r3, [r4, #24] a000656c: e1500003 cmp r0, r3
a0006570: 9a00001f bls a00065f4 <_TOD_Validate+0xac>
(the_tod->ticks >= ticks_per_second) ||
a0006574: e5943014 ldr r3, [r4, #20] a0006578: e353003b cmp r3, #59 ; 0x3b
a000657c: 8a00001c bhi a00065f4 <_TOD_Validate+0xac>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
a0006580: e5943010 ldr r3, [r4, #16] a0006584: e353003b cmp r3, #59 ; 0x3b
a0006588: 8a000019 bhi a00065f4 <_TOD_Validate+0xac>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
a000658c: e594300c ldr r3, [r4, #12] a0006590: e3530017 cmp r3, #23
a0006594: 8a000016 bhi a00065f4 <_TOD_Validate+0xac>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
a0006598: 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) ||
a000659c: e3500000 cmp r0, #0
a00065a0: 0a000016 beq a0006600 <_TOD_Validate+0xb8>
(the_tod->month == 0) ||
a00065a4: e350000c cmp r0, #12
a00065a8: 8a000011 bhi a00065f4 <_TOD_Validate+0xac>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
a00065ac: 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) ||
a00065b0: e3a03d1f mov r3, #1984 ; 0x7c0 a00065b4: e2833003 add r3, r3, #3 a00065b8: e1520003 cmp r2, r3
a00065bc: 9a00000c bls a00065f4 <_TOD_Validate+0xac>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
a00065c0: 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) ||
a00065c4: e3540000 cmp r4, #0
a00065c8: 0a00000b beq a00065fc <_TOD_Validate+0xb4>
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
a00065cc: e3120003 tst r2, #3
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
a00065d0: 059f3038 ldreq r3, [pc, #56] ; a0006610 <_TOD_Validate+0xc8>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
a00065d4: 159f3034 ldrne r3, [pc, #52] ; a0006610 <_TOD_Validate+0xc8>
(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 ];
a00065d8: 0280000d addeq r0, r0, #13 a00065dc: 07930100 ldreq r0, [r3, r0, lsl #2]
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
a00065e0: 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(
a00065e4: e1500004 cmp r0, r4
a00065e8: 33a00000 movcc r0, #0
a00065ec: 23a00001 movcs r0, #1
a00065f0: 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;
a00065f4: e3a00000 mov r0, #0
a00065f8: e8bd8010 pop {r4, pc}
a00065fc: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( the_tod->day > days_in_month )
return false;
return true;
}
a0006600: e8bd8010 pop {r4, pc} <== NOT EXECUTED
(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;
a0006604: e1a00004 mov r0, r4 <== NOT EXECUTED
a0006608: e8bd8010 pop {r4, pc} <== NOT EXECUTED
a0007f04 <_Thread_queue_Enqueue_priority>:
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
a0007f04: 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
)
{
a0007f08: e92d07f0 push {r4, r5, r6, r7, r8, r9, sl}
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
a0007f0c: e281403c add r4, r1, #60 ; 0x3c
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
a0007f10: e281c038 add ip, r1, #56 ; 0x38
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
a0007f14: 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 ) )
a0007f18: e3130020 tst r3, #32
head->previous = NULL;
a0007f1c: e3a04000 mov r4, #0
tail->previous = head;
a0007f20: e581c040 str ip, [r1, #64] ; 0x40
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
a0007f24: e581403c str r4, [r1, #60] ; 0x3c
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
a0007f28: e1a0c323 lsr ip, 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;
a0007f2c: e5905038 ldr r5, [r0, #56] ; 0x38
if ( _Thread_queue_Is_reverse_search( priority ) )
a0007f30: 0a00001f beq a0007fb4 <_Thread_queue_Enqueue_priority+0xb0>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
a0007f34: e3a0a00c mov sl, #12 a0007f38: e59f917c ldr r9, [pc, #380] ; a00080bc <_Thread_queue_Enqueue_priority+0x1b8> a0007f3c: e02a0a9c mla sl, ip, sl, r0
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
a0007f40: e5d94000 ldrb r4, [r9] a0007f44: e2844001 add r4, r4, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a0007f48: e10f7000 mrs r7, CPSR a0007f4c: e387c080 orr ip, r7, #128 ; 0x80 a0007f50: e129f00c msr CPSR_fc, ip a0007f54: e1a08007 mov r8, r7
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
a0007f58: e59ac008 ldr ip, [sl, #8]
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
a0007f5c: e15c000a cmp ip, sl
a0007f60: 1a000009 bne a0007f8c <_Thread_queue_Enqueue_priority+0x88>
a0007f64: ea00000b b a0007f98 <_Thread_queue_Enqueue_priority+0x94>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
a0007f68: e10f6000 mrs r6, CPSR a0007f6c: e129f007 msr CPSR_fc, r7 a0007f70: 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);
a0007f74: 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) ) {
a0007f78: e1150006 tst r5, r6
a0007f7c: 0a000034 beq a0008054 <_Thread_queue_Enqueue_priority+0x150>
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
a0007f80: e59cc004 ldr ip, [ip, #4]
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
a0007f84: e15c000a cmp ip, sl
a0007f88: 0a000002 beq a0007f98 <_Thread_queue_Enqueue_priority+0x94>
search_priority = search_thread->current_priority;
a0007f8c: e59c4014 ldr r4, [ip, #20]
if ( priority >= search_priority )
a0007f90: e1530004 cmp r3, r4
a0007f94: 3afffff3 bcc a0007f68 <_Thread_queue_Enqueue_priority+0x64>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
a0007f98: e5905030 ldr r5, [r0, #48] ; 0x30 a0007f9c: e3550001 cmp r5, #1
a0007fa0: 0a00002f beq a0008064 <_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;
a0007fa4: e5828000 str r8, [r2]
return the_thread_queue->sync_state; }
a0007fa8: e1a00005 mov r0, r5
a0007fac: e8bd07f0 pop {r4, r5, r6, r7, r8, r9, sl}
a0007fb0: e12fff1e bx lr
a0007fb4: e3a0900c mov r9, #12
a0007fb8: e00c0c99 mul ip, r9, ip
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
a0007fbc: e28ca004 add sl, ip, #4 a0007fc0: e080900c add r9, r0, ip a0007fc4: e080a00a add sl, r0, sl
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a0007fc8: e10f7000 mrs r7, CPSR a0007fcc: e387c080 orr ip, r7, #128 ; 0x80 a0007fd0: e129f00c msr CPSR_fc, ip a0007fd4: e1a08007 mov r8, r7 a0007fd8: e599c000 ldr ip, [r9]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
a0007fdc: e15c000a cmp ip, sl
a0007fe0: 1a000009 bne a000800c <_Thread_queue_Enqueue_priority+0x108>
a0007fe4: ea000032 b a00080b4 <_Thread_queue_Enqueue_priority+0x1b0>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
a0007fe8: e10f6000 mrs r6, CPSR a0007fec: e129f007 msr CPSR_fc, r7 a0007ff0: e129f006 msr CPSR_fc, r6 a0007ff4: 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) ) {
a0007ff8: e1150006 tst r5, r6
a0007ffc: 0a000016 beq a000805c <_Thread_queue_Enqueue_priority+0x158>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
a0008000: e59cc000 ldr ip, [ip]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
a0008004: e15c000a cmp ip, sl
a0008008: 0a000002 beq a0008018 <_Thread_queue_Enqueue_priority+0x114>
search_priority = search_thread->current_priority;
a000800c: e59c4014 ldr r4, [ip, #20]
if ( priority <= search_priority )
a0008010: e1530004 cmp r3, r4
a0008014: 8afffff3 bhi a0007fe8 <_Thread_queue_Enqueue_priority+0xe4>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
a0008018: e5905030 ldr r5, [r0, #48] ; 0x30 a000801c: e3550001 cmp r5, #1
a0008020: 1affffdf bne a0007fa4 <_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 )
a0008024: 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;
a0008028: e3a03000 mov r3, #0 a000802c: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
a0008030: 0a000016 beq a0008090 <_Thread_queue_Enqueue_priority+0x18c>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
a0008034: e59c3004 ldr r3, [ip, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
a0008038: e581c000 str ip, [r1]
the_node->previous = previous_node;
a000803c: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
a0008040: e5831000 str r1, [r3]
search_node->previous = the_node;
a0008044: e58c1004 str r1, [ip, #4]
the_thread->Wait.queue = the_thread_queue;
a0008048: e5810044 str r0, [r1, #68] ; 0x44
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a000804c: e129f007 msr CPSR_fc, r7
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
a0008050: eaffffd4 b a0007fa8 <_Thread_queue_Enqueue_priority+0xa4>
a0008054: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED a0008058: eaffffb8 b a0007f40 <_Thread_queue_Enqueue_priority+0x3c> <== NOT EXECUTED
a000805c: e129f007 msr CPSR_fc, r7 a0008060: eaffffd8 b a0007fc8 <_Thread_queue_Enqueue_priority+0xc4>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
a0008064: 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;
a0008068: e3a03000 mov r3, #0 a000806c: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
a0008070: 0a000006 beq a0008090 <_Thread_queue_Enqueue_priority+0x18c>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
a0008074: e59c3000 ldr r3, [ip]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
a0008078: e8811008 stm r1, {r3, ip}
search_node->next = the_node; next_node->previous = the_node;
a000807c: 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;
a0008080: e58c1000 str r1, [ip]
next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
a0008084: e5810044 str r0, [r1, #68] ; 0x44 a0008088: e129f007 msr CPSR_fc, r7
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
a000808c: eaffffc5 b a0007fa8 <_Thread_queue_Enqueue_priority+0xa4>
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
a0008090: e59c3040 ldr r3, [ip, #64] ; 0x40
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
a0008094: e28c203c add r2, ip, #60 ; 0x3c
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
a0008098: e881000c stm r1, {r2, r3}
the_node->previous = previous_node; previous_node->next = the_node;
a000809c: e5831000 str r1, [r3]
search_node->previous = the_node;
a00080a0: e58c1040 str r1, [ip, #64] ; 0x40
the_thread->Wait.queue = the_thread_queue;
a00080a4: e5810044 str r0, [r1, #68] ; 0x44 a00080a8: e129f008 msr CPSR_fc, r8
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
a00080ac: e3a05001 mov r5, #1 a00080b0: eaffffbc b a0007fa8 <_Thread_queue_Enqueue_priority+0xa4>
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
a00080b4: e3e04000 mvn r4, #0 a00080b8: eaffffd6 b a0008018 <_Thread_queue_Enqueue_priority+0x114>
a0008754 <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
a0008754: e92d40f0 push {r4, r5, r6, r7, lr}
return false;
}
}
return true;
}
a0008758: e59f504c ldr r5, [pc, #76] ; a00087ac <_User_extensions_Thread_create+0x58>
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
a000875c: e1a06000 mov r6, r0
return false;
}
}
return true;
}
a0008760: e4954004 ldr r4, [r5], #4
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
a0008764: e1540005 cmp r4, r5
a0008768: 0a00000d beq a00087a4 <_User_extensions_Thread_create+0x50>
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)(
a000876c: e59f703c ldr r7, [pc, #60] ; a00087b0 <_User_extensions_Thread_create+0x5c>
!_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 ) {
a0008770: e5943014 ldr r3, [r4, #20]
status = (*the_extension->Callouts.thread_create)(
a0008774: 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 ) {
a0008778: e3530000 cmp r3, #0
a000877c: 0a000003 beq a0008790 <_User_extensions_Thread_create+0x3c>
status = (*the_extension->Callouts.thread_create)(
a0008780: e5970004 ldr r0, [r7, #4] a0008784: e12fff33 blx r3
_Thread_Executing,
the_thread
);
if ( !status )
a0008788: e3500000 cmp r0, #0
a000878c: 0a000005 beq a00087a8 <_User_extensions_Thread_create+0x54>
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
a0008790: e5944000 ldr r4, [r4]
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
a0008794: e1540005 cmp r4, r5
a0008798: 1afffff4 bne a0008770 <_User_extensions_Thread_create+0x1c>
if ( !status )
return false;
}
}
return true;
a000879c: e3a00001 mov r0, #1
a00087a0: e8bd80f0 pop {r4, r5, r6, r7, pc}
a00087a4: e3a00001 mov r0, #1 <== NOT EXECUTED
}
a00087a8: e8bd80f0 pop {r4, r5, r6, r7, pc}
a000a5c0 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
a000a5c0: e92d41f0 push {r4, r5, r6, r7, r8, lr}
a000a5c4: e1a04000 mov r4, r0
a000a5c8: e1a05002 mov r5, r2
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a000a5cc: e10f3000 mrs r3, CPSR a000a5d0: e3832080 orr r2, r3, #128 ; 0x80 a000a5d4: e129f002 msr CPSR_fc, r2
}
}
_ISR_Enable( level );
}
a000a5d8: e1a07000 mov r7, r0 a000a5dc: 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 ) ) {
a000a5e0: e1520007 cmp r2, r7
a000a5e4: 0a000018 beq a000a64c <_Watchdog_Adjust+0x8c>
switch ( direction ) {
a000a5e8: e3510000 cmp r1, #0
a000a5ec: 1a000018 bne a000a654 <_Watchdog_Adjust+0x94>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
a000a5f0: e3550000 cmp r5, #0
a000a5f4: 0a000014 beq a000a64c <_Watchdog_Adjust+0x8c>
if ( units < _Watchdog_First( header )->delta_interval ) {
a000a5f8: e5926010 ldr r6, [r2, #16] a000a5fc: e1550006 cmp r5, r6
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
a000a600: 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 ) {
a000a604: 2a000005 bcs a000a620 <_Watchdog_Adjust+0x60>
a000a608: ea000018 b a000a670 <_Watchdog_Adjust+0xb0> <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
a000a60c: e0555006 subs r5, r5, r6
a000a610: 0a00000d beq a000a64c <_Watchdog_Adjust+0x8c>
if ( units < _Watchdog_First( header )->delta_interval ) {
a000a614: e5926010 ldr r6, [r2, #16] a000a618: e1560005 cmp r6, r5
a000a61c: 8a000013 bhi a000a670 <_Watchdog_Adjust+0xb0>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
a000a620: e5828010 str r8, [r2, #16]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a000a624: e129f003 msr CPSR_fc, r3
_ISR_Enable( level );
_Watchdog_Tickle( header );
a000a628: e1a00004 mov r0, r4 a000a62c: eb0000aa bl a000a8dc <_Watchdog_Tickle>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a000a630: e10f3000 mrs r3, CPSR a000a634: e3832080 orr r2, r3, #128 ; 0x80 a000a638: e129f002 msr CPSR_fc, r2
}
}
_ISR_Enable( level );
}
a000a63c: e5941000 ldr r1, [r4]
_Watchdog_Tickle( header );
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
a000a640: e1570001 cmp r7, r1
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
a000a644: e1a02001 mov r2, r1
a000a648: 1affffef bne a000a60c <_Watchdog_Adjust+0x4c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a000a64c: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
a000a650: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
a000a654: e3510001 cmp r1, #1
a000a658: 1afffffb bne a000a64c <_Watchdog_Adjust+0x8c>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
a000a65c: e5921010 ldr r1, [r2, #16] a000a660: e0815005 add r5, r1, r5 a000a664: e5825010 str r5, [r2, #16] a000a668: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
a000a66c: 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;
a000a670: e0655006 rsb r5, r5, r6 a000a674: e5825010 str r5, [r2, #16]
break;
a000a678: eafffff3 b a000a64c <_Watchdog_Adjust+0x8c>
a0005ff0 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
a0005ff0: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
a0005ff4: e59f41b4 ldr r4, [pc, #436] ; a00061b0 <aio_cancel+0x1c0>
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
a0005ff8: e1a05001 mov r5, r1 a0005ffc: e1a07000 mov r7, r0
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
a0006000: e1a00004 mov r0, r4 a0006004: eb00044a bl a0007134 <pthread_mutex_lock>
if (aiocbp == NULL)
a0006008: e3550000 cmp r5, #0
a000600c: 0a00002d beq a00060c8 <aio_cancel+0xd8>
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
}
else
{
if (aiocbp->aio_fildes != fildes) {
a0006010: e5956000 ldr r6, [r5] a0006014: e1560007 cmp r6, r7
a0006018: 1a000023 bne a00060ac <aio_cancel+0xbc>
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
a000601c: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED a0006020: e1a01006 mov r1, r6 <== NOT EXECUTED a0006024: e3a02000 mov r2, #0 <== NOT EXECUTED a0006028: eb0000c2 bl a0006338 <rtems_aio_search_fd> <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
a000602c: e2507000 subs r7, r0, #0 <== NOT EXECUTED a0006030: 0a00000c beq a0006068 <aio_cancel+0x78> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
pthread_mutex_lock (&r_chain->mutex);
a0006034: e287401c add r4, r7, #28 <== NOT EXECUTED a0006038: e1a00004 mov r0, r4 <== NOT EXECUTED a000603c: eb00043c bl a0007134 <pthread_mutex_lock> <== NOT EXECUTED
result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp);
a0006040: e1a01005 mov r1, r5 <== NOT EXECUTED a0006044: e1a00007 mov r0, r7 <== NOT EXECUTED a0006048: eb0001be bl a0006748 <rtems_aio_remove_req> <== NOT EXECUTED a000604c: e1a05000 mov r5, r0 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
a0006050: e1a00004 mov r0, r4 <== NOT EXECUTED a0006054: eb000457 bl a00071b8 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
a0006058: e59f0150 ldr r0, [pc, #336] ; a00061b0 <aio_cancel+0x1c0> <== NOT EXECUTED a000605c: eb000455 bl a00071b8 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
}
return AIO_ALLDONE;
}
a0006060: e1a00005 mov r0, r5
a0006064: e8bd80f0 pop {r4, r5, r6, r7, pc}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
fildes,
0);
if (r_chain == NULL)
if (!rtems_chain_is_empty (&aio_request_queue.idle_req))
a0006068: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED a000606c: e2843058 add r3, r4, #88 ; 0x58 <== NOT EXECUTED a0006070: e1520003 cmp r2, r3 <== NOT EXECUTED a0006074: 0affffee beq a0006034 <aio_cancel+0x44> <== NOT EXECUTED
{
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
a0006078: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED a000607c: e1a01006 mov r1, r6 <== NOT EXECUTED a0006080: e1a02007 mov r2, r7 <== NOT EXECUTED a0006084: eb0000ab bl a0006338 <rtems_aio_search_fd> <== NOT EXECUTED
fildes, 0); if (r_chain == NULL)
a0006088: e3500000 cmp r0, #0 <== NOT EXECUTED a000608c: 0a000006 beq a00060ac <aio_cancel+0xbc> <== NOT EXECUTED
{
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp);
a0006090: e1a01005 mov r1, r5 <== NOT EXECUTED a0006094: eb0001ab bl a0006748 <rtems_aio_remove_req> <== NOT EXECUTED a0006098: e1a05000 mov r5, r0 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
a000609c: e1a00004 mov r0, r4 <== NOT EXECUTED a00060a0: eb000444 bl a00071b8 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
}
return AIO_ALLDONE;
}
a00060a4: e1a00005 mov r0, r5 <== NOT EXECUTED
a00060a8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
fildes,
0);
if (r_chain == NULL)
{
pthread_mutex_unlock (&aio_request_queue.mutex);
a00060ac: e1a00004 mov r0, r4 a00060b0: eb000440 bl a00071b8 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
a00060b4: eb0029b5 bl a0010790 <__errno> a00060b8: e3a03016 mov r3, #22 a00060bc: e5803000 str r3, [r0] a00060c0: e3e05000 mvn r5, #0 a00060c4: eaffffe5 b a0006060 <aio_cancel+0x70>
pthread_mutex_lock (&aio_request_queue.mutex);
if (aiocbp == NULL)
{
if (fcntl (fildes, F_GETFL) < 0) {
a00060c8: e1a00007 mov r0, r7 a00060cc: e3a01003 mov r1, #3 a00060d0: eb001b7b bl a000cec4 <fcntl> a00060d4: e3500000 cmp r0, #0
a00060d8: ba00002d blt a0006194 <aio_cancel+0x1a4>
pthread_mutex_unlock(&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EBADF);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
a00060dc: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED a00060e0: e1a01007 mov r1, r7 <== NOT EXECUTED a00060e4: e1a02005 mov r2, r5 <== NOT EXECUTED a00060e8: eb000092 bl a0006338 <rtems_aio_search_fd> <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
a00060ec: e2506000 subs r6, r0, #0 <== NOT EXECUTED a00060f0: 0a00000b beq a0006124 <aio_cancel+0x134> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_ALLDONE;
}
pthread_mutex_lock (&r_chain->mutex);
a00060f4: e286701c add r7, r6, #28 <== NOT EXECUTED a00060f8: e1a00007 mov r0, r7 <== NOT EXECUTED a00060fc: eb00040c bl a0007134 <pthread_mutex_lock> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
a0006100: e1a00006 mov r0, r6 <== NOT EXECUTED a0006104: eb000a75 bl a0008ae0 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
a0006108: e1a00006 mov r0, r6 <== NOT EXECUTED a000610c: eb000176 bl a00066ec <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
a0006110: e1a00007 mov r0, r7 <== NOT EXECUTED a0006114: eb000427 bl a00071b8 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
a0006118: e1a00004 mov r0, r4 <== NOT EXECUTED a000611c: eb000425 bl a00071b8 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
a0006120: eaffffce b a0006060 <aio_cancel+0x70> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
fildes,
0);
if (r_chain == NULL)
{
if (!rtems_chain_is_empty (&aio_request_queue.idle_req))
a0006124: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED a0006128: e2843058 add r3, r4, #88 ; 0x58 <== NOT EXECUTED a000612c: e1520003 cmp r2, r3 <== NOT EXECUTED a0006130: 0a000013 beq a0006184 <aio_cancel+0x194> <== NOT EXECUTED
{
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
a0006134: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED a0006138: e1a01007 mov r1, r7 <== NOT EXECUTED a000613c: e1a02006 mov r2, r6 <== NOT EXECUTED a0006140: eb00007c bl a0006338 <rtems_aio_search_fd> <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL) {
a0006144: e2505000 subs r5, r0, #0 <== NOT EXECUTED a0006148: 0a00000d beq a0006184 <aio_cancel+0x194> <== NOT EXECUTED
return AIO_ALLDONE;
}
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
pthread_mutex_destroy (&r_chain->mutex);
a000614c: e285701c add r7, r5, #28 <== NOT EXECUTED a0006150: eb000a62 bl a0008ae0 <_Chain_Extract> <== NOT EXECUTED
pthread_mutex_unlock(&aio_request_queue.mutex);
return AIO_ALLDONE;
}
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
a0006154: e1a00005 mov r0, r5 <== NOT EXECUTED a0006158: eb000163 bl a00066ec <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_destroy (&r_chain->mutex);
a000615c: e1a00007 mov r0, r7 <== NOT EXECUTED a0006160: eb00034d bl a0006e9c <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->mutex);
a0006164: e1a00007 mov r0, r7 <== NOT EXECUTED a0006168: eb000273 bl a0006b3c <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
a000616c: e1a00005 mov r0, r5 <== NOT EXECUTED a0006170: ebfff27f bl a0002b74 <free> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
a0006174: e1a00004 mov r0, r4 <== NOT EXECUTED a0006178: eb00040e bl a00071b8 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
a000617c: e1a05006 mov r5, r6 <== NOT EXECUTED a0006180: eaffffb6 b a0006060 <aio_cancel+0x70> <== NOT EXECUTED
}
pthread_mutex_unlock (&aio_request_queue.mutex);
a0006184: e1a00004 mov r0, r4 <== NOT EXECUTED a0006188: eb00040a bl a00071b8 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
a000618c: e3a05002 mov r5, #2 <== NOT EXECUTED a0006190: eaffffb2 b a0006060 <aio_cancel+0x70> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
if (aiocbp == NULL)
{
if (fcntl (fildes, F_GETFL) < 0) {
pthread_mutex_unlock(&aio_request_queue.mutex);
a0006194: e1a00004 mov r0, r4 a0006198: eb000406 bl a00071b8 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
a000619c: eb00297b bl a0010790 <__errno> a00061a0: e3a03009 mov r3, #9 a00061a4: e5803000 str r3, [r0] a00061a8: e3e05000 mvn r5, #0 a00061ac: eaffffab b a0006060 <aio_cancel+0x70>
a00061bc <aio_fsync>:
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
a00061bc: e3500a02 cmp r0, #8192 ; 0x2000
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
a00061c0: e92d4030 push {r4, r5, lr}
a00061c4: e1a04001 mov r4, r1
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
a00061c8: 13a05016 movne r5, #22
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
a00061cc: 1a000011 bne a0006218 <aio_fsync+0x5c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
a00061d0: e5910000 ldr r0, [r1] a00061d4: e3a01003 mov r1, #3 a00061d8: eb001b39 bl a000cec4 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
a00061dc: e2000003 and r0, r0, #3 a00061e0: e2400001 sub r0, r0, #1 a00061e4: e3500001 cmp r0, #1
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
a00061e8: 83a05009 movhi r5, #9
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
a00061ec: 8a000009 bhi a0006218 <aio_fsync+0x5c>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
a00061f0: e3a00018 mov r0, #24 a00061f4: ebfff40c bl a000322c <malloc>
if (req == NULL)
a00061f8: e2503000 subs r3, r0, #0 <== NOT EXECUTED a00061fc: 0a000004 beq a0006214 <aio_fsync+0x58> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
a0006200: e5834014 str r4, [r3, #20] <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_SYNC;
a0006204: e3a03003 mov r3, #3 <== NOT EXECUTED a0006208: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return rtems_aio_enqueue (req);
}
a000620c: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
a0006210: ea000166 b a00067b0 <rtems_aio_enqueue> <== NOT EXECUTED
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
a0006214: e3a0500b mov r5, #11 <== NOT EXECUTED
a0006218: e3e03000 mvn r3, #0 a000621c: e5845030 str r5, [r4, #48] ; 0x30 a0006220: e5843034 str r3, [r4, #52] ; 0x34 a0006224: eb002959 bl a0010790 <__errno> a0006228: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
a000622c: e3e00000 mvn r0, #0
a0006230: e8bd8030 pop {r4, r5, pc}
a0006994 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
a0006994: e92d4030 push {r4, r5, lr}
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
a0006998: e3a01003 mov r1, #3
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
a000699c: e1a04000 mov r4, r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
a00069a0: e5900000 ldr r0, [r0] a00069a4: eb001946 bl a000cec4 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
a00069a8: e2000003 and r0, r0, #3 a00069ac: e3500002 cmp r0, #2 a00069b0: 13500000 cmpne r0, #0
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
a00069b4: 13a05009 movne r5, #9
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
a00069b8: 1a00000f bne a00069fc <aio_read+0x68>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
a00069bc: e5943014 ldr r3, [r4, #20] a00069c0: e3530000 cmp r3, #0
a00069c4: 1a000013 bne a0006a18 <aio_read+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
a00069c8: e5943008 ldr r3, [r4, #8] a00069cc: e3530000 cmp r3, #0
a00069d0: ba000010 blt a0006a18 <aio_read+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
a00069d4: e3a00018 mov r0, #24 a00069d8: ebfff213 bl a000322c <malloc>
if (req == NULL)
a00069dc: e2503000 subs r3, r0, #0
a00069e0: 0a000004 beq a00069f8 <aio_read+0x64>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
a00069e4: e5834014 str r4, [r3, #20]
req->aiocbp->aio_lio_opcode = LIO_READ;
a00069e8: e3a03001 mov r3, #1 a00069ec: e584302c str r3, [r4, #44] ; 0x2c
return rtems_aio_enqueue (req);
}
a00069f0: e8bd4030 pop {r4, r5, lr}
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
a00069f4: eaffff6d b a00067b0 <rtems_aio_enqueue>
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
a00069f8: e3a0500b mov r5, #11 <== NOT EXECUTED
a00069fc: e3e03000 mvn r3, #0 a0006a00: e5845030 str r5, [r4, #48] ; 0x30 a0006a04: e5843034 str r3, [r4, #52] ; 0x34 a0006a08: eb002760 bl a0010790 <__errno> a0006a0c: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
a0006a10: e3e00000 mvn r0, #0
a0006a14: e8bd8030 pop {r4, r5, pc}
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
a0006a18: e3a05016 mov r5, #22 a0006a1c: eafffff6 b a00069fc <aio_read+0x68>
a0006a28 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
a0006a28: e92d4030 push {r4, r5, lr}
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
a0006a2c: e3a01003 mov r1, #3
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
a0006a30: e1a04000 mov r4, r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
a0006a34: e5900000 ldr r0, [r0] a0006a38: eb001921 bl a000cec4 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
a0006a3c: e2000003 and r0, r0, #3 a0006a40: e2400001 sub r0, r0, #1 a0006a44: e3500001 cmp r0, #1
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
a0006a48: 83a05009 movhi r5, #9
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
a0006a4c: 8a00000f bhi a0006a90 <aio_write+0x68>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
a0006a50: e5943014 ldr r3, [r4, #20] a0006a54: e3530000 cmp r3, #0
a0006a58: 1a000013 bne a0006aac <aio_write+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
a0006a5c: e5943008 ldr r3, [r4, #8] a0006a60: e3530000 cmp r3, #0
a0006a64: ba000010 blt a0006aac <aio_write+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
a0006a68: e3a00018 mov r0, #24 a0006a6c: ebfff1ee bl a000322c <malloc>
if (req == NULL)
a0006a70: e2503000 subs r3, r0, #0
a0006a74: 0a000004 beq a0006a8c <aio_write+0x64>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
a0006a78: e5834014 str r4, [r3, #20]
req->aiocbp->aio_lio_opcode = LIO_WRITE;
a0006a7c: e3a03002 mov r3, #2 a0006a80: e584302c str r3, [r4, #44] ; 0x2c
return rtems_aio_enqueue (req);
}
a0006a84: e8bd4030 pop {r4, r5, lr}
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
a0006a88: eaffff48 b a00067b0 <rtems_aio_enqueue>
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
a0006a8c: e3a0500b mov r5, #11 <== NOT EXECUTED
a0006a90: e3e03000 mvn r3, #0 a0006a94: e5845030 str r5, [r4, #48] ; 0x30 a0006a98: e5843034 str r3, [r4, #52] ; 0x34 a0006a9c: eb00273b bl a0010790 <__errno> a0006aa0: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
a0006aa4: e3e00000 mvn r0, #0
a0006aa8: e8bd8030 pop {r4, r5, pc}
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
a0006aac: e3a05016 mov r5, #22 a0006ab0: eafffff6 b a0006a90 <aio_write+0x68>
a0021afc <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
a0021afc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
a0021b00: e24dd00c sub sp, sp, #12
a0021b04: e1a04000 mov r4, r0
a0021b08: e1a05001 mov r5, r1
a0021b0c: e1a07002 mov r7, r2
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
a0021b10: ebffff37 bl a00217f4 <getpid> a0021b14: e1500004 cmp r0, r4
a0021b18: 1a000096 bne a0021d78 <killinfo+0x27c>
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
a0021b1c: e3550000 cmp r5, #0
a0021b20: 0a000099 beq a0021d8c <killinfo+0x290>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
a0021b24: e2454001 sub r4, r5, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
a0021b28: e354001f cmp r4, #31
a0021b2c: 8a000096 bhi a0021d8c <killinfo+0x290>
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 )
a0021b30: e59f6280 ldr r6, [pc, #640] ; a0021db8 <killinfo+0x2bc> a0021b34: e3a0300c mov r3, #12 a0021b38: e0236395 mla r3, r5, r3, r6 a0021b3c: e5933008 ldr r3, [r3, #8] a0021b40: e3530001 cmp r3, #1
return 0;
a0021b44: 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 )
a0021b48: 0a000039 beq a0021c34 <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 ) )
a0021b4c: e3550008 cmp r5, #8 a0021b50: 13550004 cmpne r5, #4
a0021b54: 0a000038 beq a0021c3c <killinfo+0x140>
a0021b58: e355000b cmp r5, #11
a0021b5c: 0a000036 beq a0021c3c <killinfo+0x140>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
a0021b60: e3a03001 mov r3, #1
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
a0021b64: e3570000 cmp r7, #0
/* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER;
a0021b68: e58d3004 str r3, [sp, #4]
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
a0021b6c: e58d5000 str r5, [sp] a0021b70: e1a04413 lsl r4, r3, r4
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
a0021b74: 15973000 ldrne r3, [r7]
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
a0021b78: 058d7008 streq r7, [sp, #8]
} else {
siginfo->si_value = *value;
a0021b7c: 158d3008 strne r3, [sp, #8] a0021b80: e59f3234 ldr r3, [pc, #564] ; a0021dbc <killinfo+0x2c0> a0021b84: e5932000 ldr r2, [r3] a0021b88: e2822001 add r2, r2, #1 a0021b8c: 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;
a0021b90: e59f3228 ldr r3, [pc, #552] ; a0021dc0 <killinfo+0x2c4> a0021b94: e5930004 ldr r0, [r3, #4]
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
a0021b98: e59030fc ldr r3, [r0, #252] ; 0xfc a0021b9c: e59330d0 ldr r3, [r3, #208] ; 0xd0 a0021ba0: e1d43003 bics r3, r4, r3
a0021ba4: 1a000014 bne a0021bfc <killinfo+0x100>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
a0021ba8: e59fc214 ldr ip, [pc, #532] ; a0021dc4 <killinfo+0x2c8> a0021bac: e49c3004 ldr r3, [ip], #4
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
a0021bb0: e153000c cmp r3, ip
a0021bb4: 0a000033 beq a0021c88 <killinfo+0x18c>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
a0021bb8: e5932030 ldr r2, [r3, #48] ; 0x30
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
a0021bbc: e1a00003 mov r0, r3
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
a0021bc0: e59310fc ldr r1, [r3, #252] ; 0xfc
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
a0021bc4: e1140002 tst r4, r2
a0021bc8: 0a000008 beq a0021bf0 <killinfo+0xf4>
a0021bcc: ea00000a b a0021bfc <killinfo+0x100>
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
a0021bd0: 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 = _Chain_First( the_chain );
a0021bd4: e153000c cmp r3, ip
a0021bd8: 0a00002a beq a0021c88 <killinfo+0x18c>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
a0021bdc: e5932030 ldr r2, [r3, #48] ; 0x30 <== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
a0021be0: e59310fc ldr r1, [r3, #252] ; 0xfc <== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
a0021be4: e1a00003 mov r0, r3 <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
a0021be8: e1140002 tst r4, r2 <== NOT EXECUTED a0021bec: 1a000002 bne a0021bfc <killinfo+0x100> <== NOT EXECUTED
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
a0021bf0: e59120d0 ldr r2, [r1, #208] ; 0xd0 a0021bf4: e1d42002 bics r2, r4, r2
a0021bf8: 0afffff4 beq a0021bd0 <killinfo+0xd4>
/*
* 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 ) ) {
a0021bfc: e1a01005 mov r1, r5 a0021c00: e1a0200d mov r2, sp a0021c04: eb00007d bl a0021e00 <_POSIX_signals_Unblock_thread> a0021c08: e3500000 cmp r0, #0
a0021c0c: 1a000006 bne a0021c2c <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 );
a0021c10: e1a00004 mov r0, r4 a0021c14: eb00006f bl a0021dd8 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
a0021c18: e3a0300c mov r3, #12 a0021c1c: e0050593 mul r5, r3, r5 a0021c20: e7963005 ldr r3, [r6, r5] a0021c24: e3530002 cmp r3, #2
a0021c28: 0a000007 beq a0021c4c <killinfo+0x150>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
a0021c2c: ebfface1 bl a000cfb8 <_Thread_Enable_dispatch>
return 0;
a0021c30: e3a00000 mov r0, #0
}
a0021c34: e28dd00c add sp, sp, #12
a0021c38: 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 );
a0021c3c: eb0000fb bl a0022030 <pthread_self> a0021c40: e1a01005 mov r1, r5 a0021c44: eb0000c0 bl a0021f4c <pthread_kill> a0021c48: eafffff9 b a0021c34 <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 );
a0021c4c: e59f0174 ldr r0, [pc, #372] ; a0021dc8 <killinfo+0x2cc> a0021c50: ebffa626 bl a000b4f0 <_Chain_Get>
if ( !psiginfo ) {
a0021c54: e2501000 subs r1, r0, #0
a0021c58: 0a000050 beq a0021da0 <killinfo+0x2a4>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
a0021c5c: e28d3004 add r3, sp, #4 a0021c60: e4932004 ldr r2, [r3], #4 a0021c64: e59d0000 ldr r0, [sp] a0021c68: e5933000 ldr r3, [r3] a0021c6c: e5810008 str r0, [r1, #8]
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
a0021c70: e59f0154 ldr r0, [pc, #340] ; a0021dcc <killinfo+0x2d0>
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
a0021c74: e581200c str r2, [r1, #12] a0021c78: e5813010 str r3, [r1, #16]
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
a0021c7c: e0800005 add r0, r0, r5 a0021c80: ebffa607 bl a000b4a4 <_Chain_Append> a0021c84: eaffffe8 b a0021c2c <killinfo+0x130>
* NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
a0021c88: e59f3140 ldr r3, [pc, #320] ; a0021dd0 <killinfo+0x2d4> a0021c8c: e59fa140 ldr sl, [pc, #320] ; a0021dd4 <killinfo+0x2d8>
* * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL;
a0021c90: e3a00000 mov r0, #0
interested_priority = PRIORITY_MAXIMUM + 1;
a0021c94: e5d3e000 ldrb lr, [r3]
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
a0021c98: e28a9008 add r9, sl, #8
* NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
a0021c9c: e28ee001 add lr, lr, #1
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 ] )
a0021ca0: e5ba3004 ldr r3, [sl, #4]! a0021ca4: e3530000 cmp r3, #0
a0021ca8: 0a000022 beq a0021d38 <killinfo+0x23c>
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
a0021cac: e5933004 ldr r3, [r3, #4]
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
a0021cb0: e1d371b0 ldrh r7, [r3, #16]
object_table = the_info->local_table;
a0021cb4: e593101c ldr r1, [r3, #28]
for ( index = 1 ; index <= maximum ; index++ ) {
a0021cb8: e3570000 cmp r7, #0
a0021cbc: 0a00001d beq a0021d38 <killinfo+0x23c>
a0021cc0: e3a02001 mov r2, #1
the_thread = (Thread_Control *) object_table[ index ];
a0021cc4: e5b13004 ldr r3, [r1, #4]!
if ( !the_thread )
a0021cc8: e3530000 cmp r3, #0
a0021ccc: 0a000016 beq a0021d2c <killinfo+0x230>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
a0021cd0: e593c014 ldr ip, [r3, #20] a0021cd4: e15c000e cmp ip, lr
a0021cd8: 8a000013 bhi a0021d2c <killinfo+0x230>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
a0021cdc: e59380fc ldr r8, [r3, #252] ; 0xfc a0021ce0: e59880d0 ldr r8, [r8, #208] ; 0xd0 a0021ce4: e1d48008 bics r8, r4, r8
a0021ce8: 0a00000f beq a0021d2c <killinfo+0x230>
*
* 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 ) {
a0021cec: e15c000e cmp ip, lr
a0021cf0: 3a00001a bcc a0021d60 <killinfo+0x264>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
a0021cf4: e3500000 cmp r0, #0
a0021cf8: 0a00000b beq a0021d2c <killinfo+0x230>
a0021cfc: e5908010 ldr r8, [r0, #16] a0021d00: e3580000 cmp r8, #0
a0021d04: 0a000008 beq a0021d2c <killinfo+0x230>
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
a0021d08: e593b010 ldr fp, [r3, #16] a0021d0c: e35b0000 cmp fp, #0
a0021d10: 0a000012 beq a0021d60 <killinfo+0x264>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
a0021d14: e3180201 tst r8, #268435456 ; 0x10000000
a0021d18: 1a000003 bne a0021d2c <killinfo+0x230>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
a0021d1c: e20bb201 and fp, fp, #268435456 ; 0x10000000
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
a0021d20: e35b0000 cmp fp, #0 a0021d24: 11a0e00c movne lr, ip a0021d28: 11a00003 movne r0, r3
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
a0021d2c: e2822001 add r2, r2, #1 a0021d30: e1570002 cmp r7, r2
a0021d34: 2affffe2 bcs a0021cc4 <killinfo+0x1c8>
* + 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++) {
a0021d38: e15a0009 cmp sl, r9
a0021d3c: 1affffd7 bne a0021ca0 <killinfo+0x1a4>
}
}
}
}
if ( interested ) {
a0021d40: e3500000 cmp r0, #0
a0021d44: 0affffb1 beq a0021c10 <killinfo+0x114>
/*
* 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 ) ) {
a0021d48: e1a01005 mov r1, r5 a0021d4c: e1a0200d mov r2, sp a0021d50: eb00002a bl a0021e00 <_POSIX_signals_Unblock_thread> a0021d54: e3500000 cmp r0, #0
a0021d58: 0affffac beq a0021c10 <killinfo+0x114>
a0021d5c: eaffffb2 b a0021c2c <killinfo+0x130> <== NOT EXECUTED
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
a0021d60: e2822001 add r2, r2, #1 a0021d64: e1570002 cmp r7, r2
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
a0021d68: e1a0e00c mov lr, ip a0021d6c: e1a00003 mov r0, r3
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
a0021d70: 2affffd3 bcs a0021cc4 <killinfo+0x1c8>
a0021d74: eaffffef b a0021d38 <killinfo+0x23c>
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
rtems_set_errno_and_return_minus_one( ESRCH );
a0021d78: ebffc534 bl a0013250 <__errno> a0021d7c: e3a03003 mov r3, #3 a0021d80: e5803000 str r3, [r0] a0021d84: e3e00000 mvn r0, #0 a0021d88: eaffffa9 b a0021c34 <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 );
a0021d8c: ebffc52f bl a0013250 <__errno> a0021d90: e3a03016 mov r3, #22 a0021d94: e5803000 str r3, [r0] a0021d98: e3e00000 mvn r0, #0 a0021d9c: eaffffa4 b a0021c34 <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();
a0021da0: ebffac84 bl a000cfb8 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
a0021da4: ebffc529 bl a0013250 <__errno> a0021da8: e3a0300b mov r3, #11 a0021dac: e5803000 str r3, [r0] a0021db0: e3e00000 mvn r0, #0 a0021db4: eaffff9e b a0021c34 <killinfo+0x138>
a000a79c <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
a000a79c: e3500000 cmp r0, #0
a000a7a0: 0a00000e beq a000a7e0 <pthread_attr_setschedpolicy+0x44>
a000a7a4: e5903000 ldr r3, [r0] a000a7a8: e3530000 cmp r3, #0
a000a7ac: 0a00000b beq a000a7e0 <pthread_attr_setschedpolicy+0x44>
return EINVAL;
switch ( policy ) {
a000a7b0: e3510004 cmp r1, #4
a000a7b4: 9a000001 bls a000a7c0 <pthread_attr_setschedpolicy+0x24>
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
a000a7b8: e3a00086 mov r0, #134 ; 0x86
} }
a000a7bc: e12fff1e bx lr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
a000a7c0: e3a03001 mov r3, #1 a000a7c4: e1a03113 lsl r3, r3, r1 a000a7c8: e3130017 tst r3, #23
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
a000a7cc: 15801014 strne r1, [r0, #20]
return 0;
a000a7d0: 13a00000 movne r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
a000a7d4: 112fff1e bxne lr
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
a000a7d8: e3a00086 mov r0, #134 ; 0x86 <== NOT EXECUTED
} }
a000a7dc: e12fff1e bx lr <== NOT EXECUTED
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
a000a7e0: e3a00016 mov r0, #22 a000a7e4: e12fff1e bx lr
a00064c8 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
a00064c8: e92d40f0 push {r4, r5, r6, r7, lr}
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Condition_variables_Default_attributes;
a00064cc: e59f60ac ldr r6, [pc, #172] ; a0006580 <pthread_cond_init+0xb8> a00064d0: e3510000 cmp r1, #0 a00064d4: 11a06001 movne r6, r1
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
a00064d8: e5963004 ldr r3, [r6, #4]
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
a00064dc: e1a05000 mov r5, r0
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
a00064e0: e3530001 cmp r3, #1
a00064e4: 0a000020 beq a000656c <pthread_cond_init+0xa4>
return EINVAL;
if ( !the_attr->is_initialized )
a00064e8: e5963000 ldr r3, [r6] a00064ec: e3530000 cmp r3, #0
a00064f0: 1a000001 bne a00064fc <pthread_cond_init+0x34>
return EINVAL;
a00064f4: e3a00016 mov r0, #22
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
a00064f8: e8bd80f0 pop {r4, r5, r6, r7, pc}
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
a00064fc: e59f3080 ldr r3, [pc, #128] ; a0006584 <pthread_cond_init+0xbc> a0006500: e5932000 ldr r2, [r3] a0006504: e2822001 add r2, r2, #1 a0006508: e5832000 str r2, [r3]
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
_Objects_Allocate( &_POSIX_Condition_variables_Information );
a000650c: e59f7074 ldr r7, [pc, #116] ; a0006588 <pthread_cond_init+0xc0> a0006510: e1a00007 mov r0, r7 a0006514: eb00099c bl a0008b8c <_Objects_Allocate>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
a0006518: e2504000 subs r4, r0, #0
a000651c: 0a000014 beq a0006574 <pthread_cond_init+0xac>
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
a0006520: e5963004 ldr r3, [r6, #4]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
a0006524: e3a02201 mov r2, #268435456 ; 0x10000000
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
a0006528: e3a06000 mov r6, #0
_Thread_queue_Initialize(
a000652c: e2840018 add r0, r4, #24
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
a0006530: e5843010 str r3, [r4, #16]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
a0006534: e1a01006 mov r1, r6 a0006538: e2822b02 add r2, r2, #2048 ; 0x800 a000653c: e3a03074 mov r3, #116 ; 0x74
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
a0006540: e5846014 str r6, [r4, #20]
_Thread_queue_Initialize(
a0006544: eb000fa7 bl a000a3e8 <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
a0006548: e5943008 ldr r3, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
a000654c: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
a0006550: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
a0006554: e7824721 str r4, [r2, r1, lsr #14]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
a0006558: e584600c str r6, [r4, #12]
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
a000655c: e5853000 str r3, [r5]
_Thread_Enable_dispatch();
a0006560: eb000da1 bl a0009bec <_Thread_Enable_dispatch>
return 0;
a0006564: e1a00006 mov r0, r6
a0006568: e8bd80f0 pop {r4, r5, r6, r7, pc}
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return EINVAL;
a000656c: e3a00016 mov r0, #22 <== NOT EXECUTED
a0006570: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
_Thread_Enable_dispatch();
a0006574: eb000d9c bl a0009bec <_Thread_Enable_dispatch>
return ENOMEM;
a0006578: e3a0000c mov r0, #12
a000657c: e8bd80f0 pop {r4, r5, r6, r7, pc}
a0007580 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
a0007580: e3500000 cmp r0, #0
a0007584: 0a000008 beq a00075ac <pthread_mutexattr_setpshared+0x2c>
a0007588: e5903000 ldr r3, [r0] a000758c: e3530000 cmp r3, #0
a0007590: 0a000005 beq a00075ac <pthread_mutexattr_setpshared+0x2c>
return EINVAL;
switch ( pshared ) {
a0007594: e3510001 cmp r1, #1
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
a0007598: 95801004 strls r1, [r0, #4]
return 0;
a000759c: 93a00000 movls r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
a00075a0: 912fff1e bxls lr
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
a00075a4: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
a00075a8: e12fff1e bx lr <== NOT EXECUTED
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
a00075ac: e3a00016 mov r0, #22 a00075b0: e12fff1e bx lr
a0006a40 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
a0006a40: e92d4030 push {r4, r5, lr}
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
a0006a44: e2505000 subs r5, r0, #0
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
a0006a48: e24dd00c sub sp, sp, #12
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
a0006a4c: 0a00001d beq a0006ac8 <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 );
a0006a50: e1a00001 mov r0, r1 a0006a54: e28d1004 add r1, sp, #4 a0006a58: eb001a14 bl a000d2b0 <_POSIX_Absolute_timeout_to_ticks> a0006a5c: e5951000 ldr r1, [r5] a0006a60: e1a04000 mov r4, r0 a0006a64: e28d2008 add r2, sp, #8 a0006a68: e59f0098 ldr r0, [pc, #152] ; a0006b08 <pthread_rwlock_timedrdlock+0xc8> a0006a6c: eb000ab0 bl a0009534 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
a0006a70: e59d3008 ldr r3, [sp, #8] a0006a74: e3530000 cmp r3, #0
a0006a78: 1a000012 bne a0006ac8 <pthread_rwlock_timedrdlock+0x88>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
a0006a7c: 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,
a0006a80: e3540003 cmp r4, #3 a0006a84: 13a05000 movne r5, #0 a0006a88: 03a05001 moveq r5, #1 a0006a8c: e58d3000 str r3, [sp] a0006a90: e2800010 add r0, r0, #16 a0006a94: e1a02005 mov r2, r5 a0006a98: e59d3004 ldr r3, [sp, #4] a0006a9c: eb00073a bl a000878c <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
a0006aa0: eb000d86 bl a000a0c0 <_Thread_Enable_dispatch>
if ( !do_wait ) {
a0006aa4: e3550000 cmp r5, #0
a0006aa8: 1a000011 bne a0006af4 <pthread_rwlock_timedrdlock+0xb4>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
a0006aac: e59f3058 ldr r3, [pc, #88] ; a0006b0c <pthread_rwlock_timedrdlock+0xcc> a0006ab0: e5933004 ldr r3, [r3, #4] a0006ab4: e5930034 ldr r0, [r3, #52] ; 0x34 a0006ab8: e3500002 cmp r0, #2
a0006abc: 0a000004 beq a0006ad4 <pthread_rwlock_timedrdlock+0x94>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
a0006ac0: eb000046 bl a0006be0 <_POSIX_RWLock_Translate_core_RWLock_return_code> a0006ac4: ea000000 b a0006acc <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;
a0006ac8: e3a00016 mov r0, #22
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
a0006acc: e28dd00c add sp, sp, #12
a0006ad0: 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 )
a0006ad4: e3540000 cmp r4, #0
a0006ad8: 0afffffa beq a0006ac8 <pthread_rwlock_timedrdlock+0x88> return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
a0006adc: e2444001 sub r4, r4, #1 a0006ae0: e3540001 cmp r4, #1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
a0006ae4: 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 ||
a0006ae8: 9afffff7 bls a0006acc <pthread_rwlock_timedrdlock+0x8c>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
a0006aec: eb00003b bl a0006be0 <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED a0006af0: eafffff5 b a0006acc <pthread_rwlock_timedrdlock+0x8c> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
a0006af4: e59f3010 ldr r3, [pc, #16] ; a0006b0c <pthread_rwlock_timedrdlock+0xcc> a0006af8: e5933004 ldr r3, [r3, #4] a0006afc: e5930034 ldr r0, [r3, #52] ; 0x34
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
a0006b00: eb000036 bl a0006be0 <_POSIX_RWLock_Translate_core_RWLock_return_code> a0006b04: eafffff0 b a0006acc <pthread_rwlock_timedrdlock+0x8c>
a0006b10 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
a0006b10: e92d4030 push {r4, r5, lr}
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
a0006b14: e2505000 subs r5, r0, #0
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
a0006b18: e24dd00c sub sp, sp, #12
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
a0006b1c: 0a00001d beq a0006b98 <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 );
a0006b20: e1a00001 mov r0, r1 a0006b24: e28d1004 add r1, sp, #4 a0006b28: eb0019e0 bl a000d2b0 <_POSIX_Absolute_timeout_to_ticks> a0006b2c: e5951000 ldr r1, [r5] a0006b30: e1a04000 mov r4, r0 a0006b34: e28d2008 add r2, sp, #8 a0006b38: e59f0098 ldr r0, [pc, #152] ; a0006bd8 <pthread_rwlock_timedwrlock+0xc8> a0006b3c: eb000a7c bl a0009534 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
a0006b40: e59d3008 ldr r3, [sp, #8] a0006b44: e3530000 cmp r3, #0
a0006b48: 1a000012 bne a0006b98 <pthread_rwlock_timedwrlock+0x88>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
a0006b4c: 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,
a0006b50: e3540003 cmp r4, #3 a0006b54: 13a05000 movne r5, #0 a0006b58: 03a05001 moveq r5, #1 a0006b5c: e58d3000 str r3, [sp] a0006b60: e2800010 add r0, r0, #16 a0006b64: e1a02005 mov r2, r5 a0006b68: e59d3004 ldr r3, [sp, #4] a0006b6c: eb00073d bl a0008868 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
a0006b70: eb000d52 bl a000a0c0 <_Thread_Enable_dispatch>
if ( !do_wait &&
a0006b74: e3550000 cmp r5, #0
a0006b78: 1a000011 bne a0006bc4 <pthread_rwlock_timedwrlock+0xb4>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
a0006b7c: e59f3058 ldr r3, [pc, #88] ; a0006bdc <pthread_rwlock_timedwrlock+0xcc> a0006b80: e5933004 ldr r3, [r3, #4] a0006b84: e5930034 ldr r0, [r3, #52] ; 0x34
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
a0006b88: e3500002 cmp r0, #2
a0006b8c: 0a000004 beq a0006ba4 <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(
a0006b90: eb000012 bl a0006be0 <_POSIX_RWLock_Translate_core_RWLock_return_code> a0006b94: ea000000 b a0006b9c <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;
a0006b98: e3a00016 mov r0, #22
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
a0006b9c: e28dd00c add sp, sp, #12
a0006ba0: 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 )
a0006ba4: e3540000 cmp r4, #0
a0006ba8: 0afffffa beq a0006b98 <pthread_rwlock_timedwrlock+0x88> return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
a0006bac: e2444001 sub r4, r4, #1 a0006bb0: e3540001 cmp r4, #1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
a0006bb4: 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 ||
a0006bb8: 9afffff7 bls a0006b9c <pthread_rwlock_timedwrlock+0x8c>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
a0006bbc: eb000007 bl a0006be0 <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED a0006bc0: eafffff5 b a0006b9c <pthread_rwlock_timedwrlock+0x8c> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
a0006bc4: e59f3010 ldr r3, [pc, #16] ; a0006bdc <pthread_rwlock_timedwrlock+0xcc> a0006bc8: e5933004 ldr r3, [r3, #4] a0006bcc: 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(
a0006bd0: eb000002 bl a0006be0 <_POSIX_RWLock_Translate_core_RWLock_return_code> a0006bd4: eafffff0 b a0006b9c <pthread_rwlock_timedwrlock+0x8c>
a0007370 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
a0007370: e3500000 cmp r0, #0
a0007374: 0a000008 beq a000739c <pthread_rwlockattr_setpshared+0x2c>
return EINVAL;
if ( !attr->is_initialized )
a0007378: e5903000 ldr r3, [r0] a000737c: e3530000 cmp r3, #0
a0007380: 0a000005 beq a000739c <pthread_rwlockattr_setpshared+0x2c>
return EINVAL;
switch ( pshared ) {
a0007384: e3510001 cmp r1, #1
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
a0007388: 95801004 strls r1, [r0, #4]
return 0;
a000738c: 93a00000 movls r0, #0
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
a0007390: 912fff1e bxls lr
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
a0007394: e3a00016 mov r0, #22
} }
a0007398: e12fff1e bx lr
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
a000739c: e3a00016 mov r0, #22 a00073a0: e12fff1e bx lr
a0005b70 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
a0005b70: e92d4010 push {r4, lr}
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
a0005b74: e59f4058 ldr r4, [pc, #88] ; a0005bd4 <pthread_testcancel+0x64> a0005b78: e5943000 ldr r3, [r4] a0005b7c: e3530000 cmp r3, #0
a0005b80: 1a000010 bne a0005bc8 <pthread_testcancel+0x58>
a0005b84: e59f304c ldr r3, [pc, #76] ; a0005bd8 <pthread_testcancel+0x68>
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
a0005b88: e5942004 ldr r2, [r4, #4] a0005b8c: e5931000 ldr r1, [r3] a0005b90: e59220fc ldr r2, [r2, #252] ; 0xfc a0005b94: e2811001 add r1, r1, #1 a0005b98: e5831000 str r1, [r3]
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
a0005b9c: e59230d8 ldr r3, [r2, #216] ; 0xd8 a0005ba0: e3530000 cmp r3, #0
a0005ba4: 1a000008 bne a0005bcc <pthread_testcancel+0x5c>
a0005ba8: e59230e0 ldr r3, [r2, #224] ; 0xe0 a0005bac: e3530000 cmp r3, #0
a0005bb0: 0a000005 beq a0005bcc <pthread_testcancel+0x5c>
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
a0005bb4: eb000a74 bl a000858c <_Thread_Enable_dispatch>
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
a0005bb8: e5940004 ldr r0, [r4, #4] a0005bbc: e3e01000 mvn r1, #0
}
a0005bc0: e8bd4010 pop {r4, lr}
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
a0005bc4: ea0017de b a000bb44 <_POSIX_Thread_Exit>
a0005bc8: e8bd8010 pop {r4, pc}
}
a0005bcc: e8bd4010 pop {r4, lr}
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
a0005bd0: ea000a6d b a000858c <_Thread_Enable_dispatch>
a00067b0 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
a00067b0: e92d41f0 push {r4, r5, r6, r7, r8, lr}
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
a00067b4: e59f41c4 ldr r4, [pc, #452] ; a0006980 <rtems_aio_enqueue+0x1d0>
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
a00067b8: e24dd024 sub sp, sp, #36 ; 0x24 a00067bc: e1a06000 mov r6, r0
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
a00067c0: e1a00004 mov r0, r4 a00067c4: eb00025a bl a0007134 <pthread_mutex_lock>
if (result != 0) {
a00067c8: e2505000 subs r5, r0, #0
a00067cc: 1a00002a bne a000687c <rtems_aio_enqueue+0xcc>
return result;
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
a00067d0: eb000488 bl a00079f8 <pthread_self> a00067d4: e28d101c add r1, sp, #28 a00067d8: e1a0200d mov r2, sp a00067dc: eb000383 bl a00075f0 <pthread_getschedparam>
req->caller_thread = pthread_self ();
a00067e0: eb000484 bl a00079f8 <pthread_self>
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
a00067e4: e5963014 ldr r3, [r6, #20] a00067e8: e59dc000 ldr ip, [sp]
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
a00067ec: e5941068 ldr r1, [r4, #104] ; 0x68
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
a00067f0: e5932014 ldr r2, [r3, #20]
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
a00067f4: e5860010 str r0, [r6, #16]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
a00067f8: e3510000 cmp r1, #0
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
a00067fc: e062200c rsb r2, r2, ip a0006800: e586200c str r2, [r6, #12]
req->policy = policy;
a0006804: e59d201c ldr r2, [sp, #28] a0006808: e5862008 str r2, [r6, #8]
req->aiocbp->error_code = EINPROGRESS;
a000680c: e3a02077 mov r2, #119 ; 0x77 a0006810: e5832030 str r2, [r3, #48] ; 0x30
req->aiocbp->return_value = 0;
a0006814: e5835034 str r5, [r3, #52] ; 0x34
if ((aio_request_queue.idle_threads == 0) &&
a0006818: 1a000002 bne a0006828 <rtems_aio_enqueue+0x78>
a000681c: e5942064 ldr r2, [r4, #100] ; 0x64 a0006820: e3520004 cmp r2, #4
a0006824: da000017 ble a0006888 <rtems_aio_enqueue+0xd8>
else
{
/* the maximum number of threads has been already created
even though some of them might be idle.
The request belongs to one of the active fd chain */
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
a0006828: e59f0154 ldr r0, [pc, #340] ; a0006984 <rtems_aio_enqueue+0x1d4> a000682c: e5931000 ldr r1, [r3] a0006830: e3a02000 mov r2, #0 a0006834: ebfffebf bl a0006338 <rtems_aio_search_fd>
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
a0006838: e2507000 subs r7, r0, #0
a000683c: 0a00002e beq a00068fc <rtems_aio_enqueue+0x14c>
{
pthread_mutex_lock (&r_chain->mutex);
a0006840: e287401c add r4, r7, #28 a0006844: e1a00004 mov r0, r4 a0006848: eb000239 bl a0007134 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
a000684c: e2870008 add r0, r7, #8 a0006850: e1a01006 mov r1, r6 a0006854: ebffff8e bl a0006694 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
a0006858: e2870020 add r0, r7, #32 a000685c: eb00011b bl a0006cd0 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
a0006860: e1a00004 mov r0, r4 a0006864: eb000253 bl a00071b8 <pthread_mutex_unlock>
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
a0006868: e59f0110 ldr r0, [pc, #272] ; a0006980 <rtems_aio_enqueue+0x1d0> a000686c: eb000251 bl a00071b8 <pthread_mutex_unlock>
return 0; }
a0006870: e1a00005 mov r0, r5
a0006874: e28dd024 add sp, sp, #36 ; 0x24
a0006878: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
if (result != 0) {
free (req);
a000687c: e1a00006 mov r0, r6 <== NOT EXECUTED a0006880: ebfff0bb bl a0002b74 <free> <== NOT EXECUTED
return result;
a0006884: eafffff9 b a0006870 <rtems_aio_enqueue+0xc0> <== NOT EXECUTED
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
a0006888: e5931000 ldr r1, [r3] a000688c: e2840048 add r0, r4, #72 ; 0x48 a0006890: e3a02001 mov r2, #1 a0006894: ebfffea7 bl a0006338 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
a0006898: e5903018 ldr r3, [r0, #24]
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
a000689c: e1a07000 mov r7, r0
if (r_chain->new_fd == 1) {
a00068a0: e3530001 cmp r3, #1
a00068a4: 1affffe5 bne a0006840 <rtems_aio_enqueue+0x90>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
a00068a8: e1a01006 mov r1, r6 a00068ac: e2800008 add r0, r0, #8 a00068b0: eb00089f bl a0008b34 <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL);
a00068b4: e1a01005 mov r1, r5
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
if (r_chain->new_fd == 1) {
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
a00068b8: e5875018 str r5, [r7, #24]
pthread_mutex_init (&r_chain->mutex, NULL);
a00068bc: e287001c add r0, r7, #28 a00068c0: eb0001c7 bl a0006fe4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
a00068c4: e1a01005 mov r1, r5 a00068c8: e2870020 add r0, r7, #32 a00068cc: eb0000ce bl a0006c0c <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
a00068d0: e28d0020 add r0, sp, #32 a00068d4: e2841008 add r1, r4, #8 a00068d8: e59f20a8 ldr r2, [pc, #168] ; a0006988 <rtems_aio_enqueue+0x1d8> a00068dc: e1a03007 mov r3, r7 a00068e0: eb00029a bl a0007350 <pthread_create>
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
a00068e4: e2506000 subs r6, r0, #0
a00068e8: 1a000020 bne a0006970 <rtems_aio_enqueue+0x1c0> pthread_mutex_unlock (&aio_request_queue.mutex); return result; } ++aio_request_queue.active_threads;
a00068ec: e5943064 ldr r3, [r4, #100] ; 0x64 a00068f0: e2833001 add r3, r3, #1 a00068f4: e5843064 str r3, [r4, #100] ; 0x64 a00068f8: eaffffda b a0006868 <rtems_aio_enqueue+0xb8>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
a00068fc: e5963014 ldr r3, [r6, #20] a0006900: e59f0084 ldr r0, [pc, #132] ; a000698c <rtems_aio_enqueue+0x1dc> a0006904: e3a02001 mov r2, #1 a0006908: e5931000 ldr r1, [r3] a000690c: ebfffe89 bl a0006338 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
a0006910: e5903018 ldr r3, [r0, #24]
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
a0006914: e1a08000 mov r8, r0
if (r_chain->new_fd == 1) {
a0006918: e3530001 cmp r3, #1
a000691c: 0a000003 beq a0006930 <rtems_aio_enqueue+0x180> pthread_cond_init (&r_chain->cond, NULL); pthread_cond_signal (&aio_request_queue.new_req); ++aio_request_queue.idle_threads; } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req);
a0006920: e2800008 add r0, r0, #8 a0006924: e1a01006 mov r1, r6 a0006928: ebffff59 bl a0006694 <rtems_aio_insert_prio> a000692c: eaffffcd b a0006868 <rtems_aio_enqueue+0xb8> a0006930: e2800008 add r0, r0, #8 a0006934: e1a01006 mov r1, r6 a0006938: eb00087d bl a0008b34 <_Chain_Insert>
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
a000693c: e1a01007 mov r1, r7
if (r_chain->new_fd == 1) {
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
a0006940: e5887018 str r7, [r8, #24]
pthread_mutex_init (&r_chain->mutex, NULL);
a0006944: e288001c add r0, r8, #28 a0006948: eb0001a5 bl a0006fe4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
a000694c: e1a01007 mov r1, r7 a0006950: e2880020 add r0, r8, #32 a0006954: eb0000ac bl a0006c0c <pthread_cond_init>
pthread_cond_signal (&aio_request_queue.new_req);
a0006958: e59f0030 ldr r0, [pc, #48] ; a0006990 <rtems_aio_enqueue+0x1e0> a000695c: eb0000db bl a0006cd0 <pthread_cond_signal>
++aio_request_queue.idle_threads;
a0006960: e5943068 ldr r3, [r4, #104] ; 0x68 a0006964: e2833001 add r3, r3, #1 a0006968: e5843068 str r3, [r4, #104] ; 0x68 a000696c: eaffffbd b a0006868 <rtems_aio_enqueue+0xb8>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
pthread_mutex_unlock (&aio_request_queue.mutex);
a0006970: e1a00004 mov r0, r4 <== NOT EXECUTED a0006974: eb00020f bl a00071b8 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
a0006978: e1a05006 mov r5, r6 <== NOT EXECUTED a000697c: eaffffbb b a0006870 <rtems_aio_enqueue+0xc0> <== NOT EXECUTED
a0006404 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
a0006404: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
a0006408: e24dd02c sub sp, sp, #44 ; 0x2c <== NOT EXECUTED
a000640c: e1a05000 mov r5, r0 <== NOT EXECUTED
a0006410: e280601c add r6, r0, #28 <== NOT EXECUTED
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
a0006414: e28d8028 add r8, sp, #40 ; 0x28 <== NOT EXECUTED a0006418: e28d7004 add r7, sp, #4 <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
a000641c: e3e0b000 mvn fp, #0 <== NOT EXECUTED
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
req->aiocbp->error_code = 0;
a0006420: e3a09000 mov r9, #0 <== NOT EXECUTED
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
a0006424: e1a00006 mov r0, r6 <== NOT EXECUTED a0006428: eb000341 bl a0007134 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
a000642c: e250a000 subs sl, r0, #0 <== NOT EXECUTED a0006430: 1a000021 bne a00064bc <rtems_aio_handle+0xb8> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
a0006434: e5954008 ldr r4, [r5, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
a0006438: e285300c add r3, r5, #12 <== NOT EXECUTED
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
a000643c: e1540003 cmp r4, r3 <== NOT EXECUTED a0006440: 0a000038 beq a0006528 <rtems_aio_handle+0x124> <== NOT EXECUTED
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
a0006444: eb00056b bl a00079f8 <pthread_self> <== NOT EXECUTED a0006448: e1a01008 mov r1, r8 <== NOT EXECUTED a000644c: e1a02007 mov r2, r7 <== NOT EXECUTED a0006450: eb000466 bl a00075f0 <pthread_getschedparam> <== NOT EXECUTED
param.sched_priority = req->priority;
a0006454: e594300c ldr r3, [r4, #12] <== NOT EXECUTED a0006458: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
pthread_setschedparam (pthread_self(), req->policy, ¶m);
a000645c: eb000565 bl a00079f8 <pthread_self> <== NOT EXECUTED a0006460: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED a0006464: e1a02007 mov r2, r7 <== NOT EXECUTED a0006468: eb000567 bl a0007a0c <pthread_setschedparam> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
a000646c: e1a00004 mov r0, r4 <== NOT EXECUTED a0006470: eb00099a bl a0008ae0 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
a0006474: e1a00006 mov r0, r6 <== NOT EXECUTED a0006478: eb00034e bl a00071b8 <pthread_mutex_unlock> <== NOT EXECUTED
switch (req->aiocbp->aio_lio_opcode) {
a000647c: e594a014 ldr sl, [r4, #20] <== NOT EXECUTED a0006480: e59a302c ldr r3, [sl, #44] ; 0x2c <== NOT EXECUTED a0006484: e3530002 cmp r3, #2 <== NOT EXECUTED a0006488: 0a00001e beq a0006508 <rtems_aio_handle+0x104> <== NOT EXECUTED a000648c: e3530003 cmp r3, #3 <== NOT EXECUTED a0006490: 0a000019 beq a00064fc <rtems_aio_handle+0xf8> <== NOT EXECUTED a0006494: e3530001 cmp r3, #1 <== NOT EXECUTED a0006498: 0a00000a beq a00064c8 <rtems_aio_handle+0xc4> <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
a000649c: e58ab034 str fp, [sl, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = errno;
a00064a0: eb0028ba bl a0010790 <__errno> <== NOT EXECUTED a00064a4: e5903000 ldr r3, [r0] <== NOT EXECUTED
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
a00064a8: e1a00006 mov r0, r6 <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
a00064ac: e58a3030 str r3, [sl, #48] ; 0x30 <== NOT EXECUTED
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
a00064b0: eb00031f bl a0007134 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
a00064b4: e250a000 subs sl, r0, #0 <== NOT EXECUTED a00064b8: 0affffdd beq a0006434 <rtems_aio_handle+0x30> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
a00064bc: e3a00000 mov r0, #0 <== NOT EXECUTED
a00064c0: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
a00064c4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
case LIO_READ:
result = pread (req->aiocbp->aio_fildes,
a00064c8: e59ac008 ldr ip, [sl, #8] <== NOT EXECUTED a00064cc: e59a0000 ldr r0, [sl] <== NOT EXECUTED a00064d0: e59a100c ldr r1, [sl, #12] <== NOT EXECUTED a00064d4: e59a2010 ldr r2, [sl, #16] <== NOT EXECUTED a00064d8: e59a3004 ldr r3, [sl, #4] <== NOT EXECUTED a00064dc: e58dc000 str ip, [sp] <== NOT EXECUTED a00064e0: eb002bac bl a0011398 <pread> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
a00064e4: e3700001 cmn r0, #1 <== NOT EXECUTED a00064e8: 0a000060 beq a0006670 <rtems_aio_handle+0x26c> <== NOT EXECUTED
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
a00064ec: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED a00064f0: e5830034 str r0, [r3, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = 0;
a00064f4: e5839030 str r9, [r3, #48] ; 0x30 <== NOT EXECUTED a00064f8: eaffffc9 b a0006424 <rtems_aio_handle+0x20> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
result = fsync (req->aiocbp->aio_fildes);
a00064fc: e59a0000 ldr r0, [sl] <== NOT EXECUTED a0006500: eb001aee bl a000d0c0 <fsync> <== NOT EXECUTED
break;
a0006504: eafffff6 b a00064e4 <rtems_aio_handle+0xe0> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
result = pwrite (req->aiocbp->aio_fildes,
a0006508: e59ac008 ldr ip, [sl, #8] <== NOT EXECUTED a000650c: e59a0000 ldr r0, [sl] <== NOT EXECUTED a0006510: e59a100c ldr r1, [sl, #12] <== NOT EXECUTED a0006514: e59a2010 ldr r2, [sl, #16] <== NOT EXECUTED a0006518: e59a3004 ldr r3, [sl, #4] <== NOT EXECUTED a000651c: e58dc000 str ip, [sp] <== NOT EXECUTED a0006520: eb002be4 bl a00114b8 <pwrite> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
a0006524: eaffffee b a00064e4 <rtems_aio_handle+0xe0> <== NOT EXECUTED
wait for a signal on chain, this will unlock the queue.
The fd chain is already unlocked */
struct timespec timeout;
pthread_mutex_unlock (&r_chain->mutex);
a0006528: e1a00006 mov r0, r6 <== NOT EXECUTED a000652c: eb000321 bl a00071b8 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
a0006530: e59f014c ldr r0, [pc, #332] ; a0006684 <rtems_aio_handle+0x280><== NOT EXECUTED a0006534: eb0002fe bl a0007134 <pthread_mutex_lock> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
a0006538: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED a000653c: e1540003 cmp r4, r3 <== NOT EXECUTED a0006540: 1affffb7 bne a0006424 <rtems_aio_handle+0x20> <== NOT EXECUTED
{
clock_gettime (CLOCK_REALTIME, &timeout);
a0006544: e28d1020 add r1, sp, #32 <== NOT EXECUTED a0006548: e3a00001 mov r0, #1 <== NOT EXECUTED a000654c: eb000158 bl a0006ab4 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
a0006550: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
a0006554: e2854020 add r4, r5, #32 <== NOT EXECUTED a0006558: e1a00004 mov r0, r4 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
a000655c: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
a0006560: e59f111c ldr r1, [pc, #284] ; a0006684 <rtems_aio_handle+0x280><== NOT EXECUTED a0006564: e28d2020 add r2, sp, #32 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
a0006568: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
a000656c: e58da024 str sl, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&r_chain->cond,
a0006570: eb0001f0 bl a0006d38 <pthread_cond_timedwait> <== NOT EXECUTED
&aio_request_queue.mutex, &timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
a0006574: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED a0006578: 1affffa9 bne a0006424 <rtems_aio_handle+0x20> <== NOT EXECUTED a000657c: e1a00005 mov r0, r5 <== NOT EXECUTED a0006580: eb000956 bl a0008ae0 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex);
a0006584: e1a00006 mov r0, r6 <== NOT EXECUTED a0006588: eb000243 bl a0006e9c <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
a000658c: e1a00004 mov r0, r4 <== NOT EXECUTED a0006590: eb000169 bl a0006b3c <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
a0006594: e1a00005 mov r0, r5 <== NOT EXECUTED a0006598: ebfff175 bl a0002b74 <free> <== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
a000659c: e59f20e0 ldr r2, [pc, #224] ; a0006684 <rtems_aio_handle+0x280><== NOT EXECUTED a00065a0: e5923054 ldr r3, [r2, #84] ; 0x54 <== NOT EXECUTED a00065a4: e59f20dc ldr r2, [pc, #220] ; a0006688 <rtems_aio_handle+0x284><== NOT EXECUTED a00065a8: e1530002 cmp r3, r2 <== NOT EXECUTED a00065ac: 0a000002 beq a00065bc <rtems_aio_handle+0x1b8> <== NOT EXECUTED
r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd; } else /* If there was a request added in the initial fd chain then release the mutex and process it */ pthread_mutex_unlock (&aio_request_queue.mutex);
a00065b0: e59f00cc ldr r0, [pc, #204] ; a0006684 <rtems_aio_handle+0x280><== NOT EXECUTED a00065b4: eb0002ff bl a00071b8 <pthread_mutex_unlock> <== NOT EXECUTED a00065b8: eaffff99 b a0006424 <rtems_aio_handle+0x20> <== NOT EXECUTED
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
++aio_request_queue.idle_threads;
a00065bc: e59f20c0 ldr r2, [pc, #192] ; a0006684 <rtems_aio_handle+0x280><== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
a00065c0: e3a00001 mov r0, #1 <== NOT EXECUTED a00065c4: e28d1020 add r1, sp, #32 <== NOT EXECUTED
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
++aio_request_queue.idle_threads;
a00065c8: e5923068 ldr r3, [r2, #104] ; 0x68 <== NOT EXECUTED a00065cc: e0833000 add r3, r3, r0 <== NOT EXECUTED a00065d0: e5823068 str r3, [r2, #104] ; 0x68 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
a00065d4: eb000136 bl a0006ab4 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
a00065d8: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&aio_request_queue.new_req,
a00065dc: e59f00a8 ldr r0, [pc, #168] ; a000668c <rtems_aio_handle+0x288><== NOT EXECUTED a00065e0: e59f109c ldr r1, [pc, #156] ; a0006684 <rtems_aio_handle+0x280><== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
++aio_request_queue.idle_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
a00065e4: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&aio_request_queue.new_req,
a00065e8: e28d2020 add r2, sp, #32 <== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
++aio_request_queue.idle_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
a00065ec: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
a00065f0: e58da024 str sl, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&aio_request_queue.new_req,
a00065f4: eb0001cf bl a0006d38 <pthread_cond_timedwait> <== NOT EXECUTED
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
a00065f8: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED a00065fc: 0a00001d beq a0006678 <rtems_aio_handle+0x274> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
a0006600: e59f307c ldr r3, [pc, #124] ; a0006684 <rtems_aio_handle+0x280><== NOT EXECUTED
return NULL; } /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads;
a0006604: e59f2078 ldr r2, [pc, #120] ; a0006684 <rtems_aio_handle+0x280><== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
a0006608: e5934054 ldr r4, [r3, #84] ; 0x54 <== NOT EXECUTED
return NULL; } /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads;
a000660c: e5933068 ldr r3, [r3, #104] ; 0x68 <== NOT EXECUTED a0006610: e1a00004 mov r0, r4 <== NOT EXECUTED a0006614: e2433001 sub r3, r3, #1 <== NOT EXECUTED a0006618: e5823068 str r3, [r2, #104] ; 0x68 <== NOT EXECUTED a000661c: eb00092f bl a0008ae0 <_Chain_Extract> <== NOT EXECUTED
node = rtems_chain_first (&aio_request_queue.idle_req); rtems_chain_extract (node); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
a0006620: e3a02001 mov r2, #1 <== NOT EXECUTED a0006624: e5941014 ldr r1, [r4, #20] <== NOT EXECUTED a0006628: e59f0060 ldr r0, [pc, #96] ; a0006690 <rtems_aio_handle+0x28c><== NOT EXECUTED a000662c: ebffff41 bl a0006338 <rtems_aio_search_fd> <== NOT EXECUTED
((rtems_aio_request_chain *)node)->fildes, 1); r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL);
a0006630: e280601c add r6, r0, #28 <== NOT EXECUTED
/* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads; node = rtems_chain_first (&aio_request_queue.idle_req); rtems_chain_extract (node); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
a0006634: e1a05000 mov r5, r0 <== NOT EXECUTED
((rtems_aio_request_chain *)node)->fildes, 1); r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL);
a0006638: e1a0100a mov r1, sl <== NOT EXECUTED
node = rtems_chain_first (&aio_request_queue.idle_req); rtems_chain_extract (node); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, ((rtems_aio_request_chain *)node)->fildes, 1); r_chain->new_fd = 0;
a000663c: e580a018 str sl, [r0, #24] <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
a0006640: e1a00006 mov r0, r6 <== NOT EXECUTED a0006644: eb000266 bl a0006fe4 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
a0006648: e2850020 add r0, r5, #32 <== NOT EXECUTED a000664c: e1a0100a mov r1, sl <== NOT EXECUTED a0006650: eb00016d bl a0006c0c <pthread_cond_init> <== NOT EXECUTED
r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd;
a0006654: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED a0006658: e5853008 str r3, [r5, #8] <== NOT EXECUTED a000665c: e594300c ldr r3, [r4, #12] <== NOT EXECUTED a0006660: e585300c str r3, [r5, #12] <== NOT EXECUTED a0006664: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED a0006668: e5853010 str r3, [r5, #16] <== NOT EXECUTED a000666c: eaffff6c b a0006424 <rtems_aio_handle+0x20> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
a0006670: e594a014 ldr sl, [r4, #20] <== NOT EXECUTED a0006674: eaffff88 b a000649c <rtems_aio_handle+0x98> <== NOT EXECUTED
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
pthread_mutex_unlock (&aio_request_queue.mutex);
a0006678: e59f0004 ldr r0, [pc, #4] ; a0006684 <rtems_aio_handle+0x280><== NOT EXECUTED a000667c: eb0002cd bl a00071b8 <pthread_mutex_unlock> <== NOT EXECUTED
return NULL;
a0006680: eaffff8d b a00064bc <rtems_aio_handle+0xb8> <== NOT EXECUTED
a0006234 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
a0006234: e92d4070 push {r4, r5, r6, lr}
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
a0006238: e59f00e8 ldr r0, [pc, #232] ; a0006328 <rtems_aio_init+0xf4> a000623c: eb000423 bl a00072d0 <pthread_attr_init>
if (result != 0)
a0006240: e2505000 subs r5, r0, #0
a0006244: 0a000001 beq a0006250 <rtems_aio_init+0x1c>
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
return result;
}
a0006248: e1a00005 mov r0, r5 <== NOT EXECUTED
a000624c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
result = pthread_attr_init (&aio_request_queue.attr);
if (result != 0)
return result;
result =
a0006250: e59f00d0 ldr r0, [pc, #208] ; a0006328 <rtems_aio_init+0xf4> a0006254: e1a01005 mov r1, r5 a0006258: eb00042f bl a000731c <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
a000625c: e3500000 cmp r0, #0
a0006260: 1a00001c bne a00062d8 <rtems_aio_init+0xa4>
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
a0006264: e59f40c0 ldr r4, [pc, #192] ; a000632c <rtems_aio_init+0xf8> a0006268: e3a01000 mov r1, #0 a000626c: e1a00004 mov r0, r4 a0006270: eb00035b bl a0006fe4 <pthread_mutex_init>
if (result != 0)
a0006274: e3500000 cmp r0, #0
a0006278: 1a00001e bne a00062f8 <rtems_aio_init+0xc4>
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
a000627c: e59f00ac ldr r0, [pc, #172] ; a0006330 <rtems_aio_init+0xfc> a0006280: e3a01000 mov r1, #0 a0006284: eb000260 bl a0006c0c <pthread_cond_init>
if (result != 0) {
a0006288: e2505000 subs r5, r0, #0
a000628c: 1a000020 bne a0006314 <rtems_aio_init+0xe0>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
a0006290: e59f209c ldr r2, [pc, #156] ; a0006334 <rtems_aio_init+0x100>
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
a0006294: e3a01a0b mov r1, #45056 ; 0xb000
head->previous = NULL;
a0006298: e3a03000 mov r3, #0
tail->previous = head;
a000629c: e2820008 add r0, r2, #8 a00062a0: e2426004 sub r6, r2, #4
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
a00062a4: e282c00c add ip, r2, #12 a00062a8: e281100b add r1, r1, #11
head->previous = NULL; tail->previous = head;
a00062ac: e584005c str r0, [r4, #92] ; 0x5c
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
a00062b0: e5842048 str r2, [r4, #72] ; 0x48
head->previous = NULL;
a00062b4: e584304c str r3, [r4, #76] ; 0x4c
tail->previous = head;
a00062b8: e5846050 str r6, [r4, #80] ; 0x50
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
a00062bc: e584c054 str ip, [r4, #84] ; 0x54
head->previous = NULL;
a00062c0: e5843058 str r3, [r4, #88] ; 0x58
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
a00062c4: e5843064 str r3, [r4, #100] ; 0x64
aio_request_queue.idle_threads = 0;
a00062c8: e5843068 str r3, [r4, #104] ; 0x68
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
a00062cc: e5841060 str r1, [r4, #96] ; 0x60
return result;
}
a00062d0: e1a00005 mov r0, r5
a00062d4: e8bd8070 pop {r4, r5, r6, pc}
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
a00062d8: e59f404c ldr r4, [pc, #76] ; a000632c <rtems_aio_init+0xf8><== NOT EXECUTED
result =
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
a00062dc: e59f0044 ldr r0, [pc, #68] ; a0006328 <rtems_aio_init+0xf4><== NOT EXECUTED a00062e0: eb0003f1 bl a00072ac <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
a00062e4: e3a01000 mov r1, #0 <== NOT EXECUTED a00062e8: e1a00004 mov r0, r4 <== NOT EXECUTED a00062ec: eb00033c bl a0006fe4 <pthread_mutex_init> <== NOT EXECUTED
if (result != 0)
a00062f0: e3500000 cmp r0, #0 <== NOT EXECUTED a00062f4: 0affffe0 beq a000627c <rtems_aio_init+0x48> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
a00062f8: e2840008 add r0, r4, #8 <== NOT EXECUTED a00062fc: eb0003ea bl a00072ac <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
a0006300: e59f0028 ldr r0, [pc, #40] ; a0006330 <rtems_aio_init+0xfc><== NOT EXECUTED a0006304: e3a01000 mov r1, #0 <== NOT EXECUTED a0006308: eb00023f bl a0006c0c <pthread_cond_init> <== NOT EXECUTED
if (result != 0) {
a000630c: e2505000 subs r5, r0, #0 <== NOT EXECUTED a0006310: 0affffde beq a0006290 <rtems_aio_init+0x5c> <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
a0006314: e59f0010 ldr r0, [pc, #16] ; a000632c <rtems_aio_init+0xf8><== NOT EXECUTED a0006318: eb0002df bl a0006e9c <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
a000631c: e59f0004 ldr r0, [pc, #4] ; a0006328 <rtems_aio_init+0xf4> <== NOT EXECUTED a0006320: eb0003e1 bl a00072ac <pthread_attr_destroy> <== NOT EXECUTED a0006324: eaffffd9 b a0006290 <rtems_aio_init+0x5c> <== NOT EXECUTED
a0006694 <rtems_aio_insert_prio>:
}
AIO_printf ("Thread finished\n");
return NULL;
}
a0006694: e1a02000 mov r2, r0 a0006698: e4923004 ldr r3, [r2], #4
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
a000669c: e1a0c001 mov ip, r1
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
a00066a0: e1530002 cmp r3, r2
a00066a4: 0a00000f beq a00066e8 <rtems_aio_insert_prio+0x54>
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
a00066a8: e5910014 ldr r0, [r1, #20]
if (rtems_chain_is_empty (chain)) {
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
a00066ac: e5931014 ldr r1, [r3, #20]
while (req->aiocbp->aio_reqprio > prio &&
a00066b0: e5900014 ldr r0, [r0, #20] a00066b4: e5911014 ldr r1, [r1, #20] a00066b8: e1510000 cmp r1, r0
a00066bc: ba000002 blt a00066cc <rtems_aio_insert_prio+0x38>
a00066c0: ea000006 b a00066e0 <rtems_aio_insert_prio+0x4c>
a00066c4: e1530002 cmp r3, r2 <== NOT EXECUTED a00066c8: 0a000004 beq a00066e0 <rtems_aio_insert_prio+0x4c> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
a00066cc: e5933000 ldr r3, [r3] <== NOT EXECUTED
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
a00066d0: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
a00066d4: e5911014 ldr r1, [r1, #20] <== NOT EXECUTED a00066d8: e1510000 cmp r1, r0 <== NOT EXECUTED a00066dc: bafffff8 blt a00066c4 <rtems_aio_insert_prio+0x30> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
a00066e0: e5930004 ldr r0, [r3, #4] a00066e4: e1a0100c mov r1, ip a00066e8: ea000911 b a0008b34 <_Chain_Insert>
a00066ec <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
a00066ec: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
a00066f0: e5904008 ldr r4, [r0, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
a00066f4: e280000c add r0, r0, #12 <== NOT EXECUTED
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
a00066f8: e1540000 cmp r4, r0 <== NOT EXECUTED a00066fc: 0a000010 beq a0006744 <rtems_aio_remove_fd+0x58> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
a0006700: e1a00004 mov r0, r4 <== NOT EXECUTED a0006704: eb0008f5 bl a0008ae0 <_Chain_Extract> <== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
a0006708: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED a000670c: e3a0608c mov r6, #140 ; 0x8c <== NOT EXECUTED
req->aiocbp->return_value = -1;
a0006710: e3e05000 mvn r5, #0 <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
a0006714: e5836030 str r6, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = -1;
a0006718: e5835034 str r5, [r3, #52] ; 0x34 <== NOT EXECUTED
free (req);
a000671c: e1a00004 mov r0, r4 <== NOT EXECUTED a0006720: ebfff113 bl a0002b74 <free> <== NOT EXECUTED a0006724: e1a00004 mov r0, r4 <== NOT EXECUTED a0006728: eb0008ec bl a0008ae0 <_Chain_Extract> <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
a000672c: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
req->aiocbp->return_value = -1;
free (req);
a0006730: e1a00004 mov r0, r4 <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
a0006734: e5836030 str r6, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = -1;
a0006738: e5835034 str r5, [r3, #52] ; 0x34 <== NOT EXECUTED
free (req);
a000673c: ebfff10c bl a0002b74 <free> <== NOT EXECUTED
a0006740: eafffff7 b a0006724 <rtems_aio_remove_fd+0x38> <== NOT EXECUTED
a0006744: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
a0006748 <rtems_aio_remove_req>:
* AIO_NOTCANCELED - if request was not canceled
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
a0006748: e92d4010 push {r4, lr} <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
a000674c: e4904004 ldr r4, [r0], #4 <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
a0006750: e1540000 cmp r4, r0 <== NOT EXECUTED a0006754: 1a000003 bne a0006768 <rtems_aio_remove_req+0x20> <== NOT EXECUTED a0006758: ea000012 b a00067a8 <rtems_aio_remove_req+0x60> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
a000675c: e5944000 ldr r4, [r4] <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
a0006760: e1540000 cmp r4, r0 <== NOT EXECUTED a0006764: 0a00000d beq a00067a0 <rtems_aio_remove_req+0x58> <== NOT EXECUTED a0006768: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED a000676c: e1530001 cmp r3, r1 <== NOT EXECUTED a0006770: 1afffff9 bne a000675c <rtems_aio_remove_req+0x14> <== NOT EXECUTED a0006774: e1a00004 mov r0, r4 <== NOT EXECUTED a0006778: eb0008d8 bl a0008ae0 <_Chain_Extract> <== NOT EXECUTED
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
a000677c: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED a0006780: e3a0208c mov r2, #140 ; 0x8c <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
a0006784: e1a00004 mov r0, r4 <== NOT EXECUTED
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
a0006788: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED
current->aiocbp->return_value = -1;
a000678c: e3e02000 mvn r2, #0 <== NOT EXECUTED a0006790: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
free (current);
a0006794: ebfff0f6 bl a0002b74 <free> <== NOT EXECUTED
}
return AIO_CANCELED;
a0006798: e3a00000 mov r0, #0 <== NOT EXECUTED
a000679c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
a00067a0: e3a00001 mov r0, #1 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
a00067a4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
a00067a8: e3a00001 mov r0, #1 <== NOT EXECUTED
a00067ac: e8bd8010 pop {r4, pc} <== NOT EXECUTED
a000629c <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
a000629c: e92d4030 push {r4, r5, lr}
a00062a0: e1a04002 mov r4, r2
a00062a4: e1a05003 mov r5, r3
RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Append_with_empty_check( chain, node );
a00062a8: eb000149 bl a00067d4 <_Chain_Append_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
a00062ac: e3500000 cmp r0, #0
a00062b0: 1a000000 bne a00062b8 <rtems_chain_append_with_notification+0x1c>
sc = rtems_event_send( task, events );
}
return sc;
}
a00062b4: e8bd8030 pop {r4, r5, pc}
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
sc = rtems_event_send( task, events );
a00062b8: e1a00004 mov r0, r4 a00062bc: e1a01005 mov r1, r5
}
return sc;
}
a00062c0: e8bd4030 pop {r4, r5, lr}
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
sc = rtems_event_send( task, events );
a00062c4: eafffd86 b a00058e4 <rtems_event_send>
a0006354 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
a0006354: e92d4030 push {r4, r5, lr}
a0006358: e1a04002 mov r4, r2
a000635c: e1a05003 mov r5, r3
RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Prepend_with_empty_check( chain, node );
a0006360: eb00016a bl a0006910 <_Chain_Prepend_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
a0006364: e3500000 cmp r0, #0
a0006368: 1a000000 bne a0006370 <rtems_chain_prepend_with_notification+0x1c>
sc = rtems_event_send( task, events );
}
return sc;
}
a000636c: e8bd8030 pop {r4, r5, pc}
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
sc = rtems_event_send( task, events );
a0006370: e1a00004 mov r0, r4 a0006374: e1a01005 mov r1, r5
}
return sc;
}
a0006378: e8bd4030 pop {r4, r5, lr}
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
sc = rtems_event_send( task, events );
a000637c: eafffd58 b a00058e4 <rtems_event_send>
a0006e04 <rtems_io_register_driver>:
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
)
{
a0006e04: e92d4030 push {r4, r5, lr}
a0006e08: e1a04000 mov r4, r0
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
a0006e0c: e59f014c ldr r0, [pc, #332] ; a0006f60 <rtems_io_register_driver+0x15c>
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;
a0006e10: e59f314c ldr r3, [pc, #332] ; a0006f64 <rtems_io_register_driver+0x160>
if ( rtems_interrupt_is_in_progress() )
a0006e14: e5900000 ldr r0, [r0] a0006e18: e3500000 cmp r0, #0
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;
a0006e1c: e5930000 ldr r0, [r3]
if ( rtems_interrupt_is_in_progress() )
a0006e20: 1a000033 bne a0006ef4 <rtems_io_register_driver+0xf0>
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
a0006e24: e3520000 cmp r2, #0
a0006e28: 0a000041 beq a0006f34 <rtems_io_register_driver+0x130>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
a0006e2c: e3510000 cmp r1, #0
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
a0006e30: e5820000 str r0, [r2]
if ( driver_table == NULL )
a0006e34: 0a00003e beq a0006f34 <rtems_io_register_driver+0x130>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
a0006e38: e591c000 ldr ip, [r1] a0006e3c: e35c0000 cmp ip, #0
a0006e40: 0a000038 beq a0006f28 <rtems_io_register_driver+0x124>
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
a0006e44: e1500004 cmp r0, r4
a0006e48: 9a000027 bls a0006eec <rtems_io_register_driver+0xe8>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
a0006e4c: e59f0114 ldr r0, [pc, #276] ; a0006f68 <rtems_io_register_driver+0x164> a0006e50: e590c000 ldr ip, [r0] a0006e54: e28cc001 add ip, ip, #1 a0006e58: e580c000 str ip, [r0]
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
a0006e5c: e3540000 cmp r4, #0
a0006e60: 1a000025 bne a0006efc <rtems_io_register_driver+0xf8>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
a0006e64: e593c000 ldr ip, [r3]
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
a0006e68: e35c0000 cmp ip, #0
a0006e6c: 0a000032 beq a0006f3c <rtems_io_register_driver+0x138>
a0006e70: e59fe0f4 ldr lr, [pc, #244] ; a0006f6c <rtems_io_register_driver+0x168> a0006e74: e59e3000 ldr r3, [lr] a0006e78: ea000003 b a0006e8c <rtems_io_register_driver+0x88> a0006e7c: e2844001 add r4, r4, #1 a0006e80: e15c0004 cmp ip, r4 a0006e84: e2833018 add r3, r3, #24
a0006e88: 9a000005 bls a0006ea4 <rtems_io_register_driver+0xa0>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
a0006e8c: e5930000 ldr r0, [r3] a0006e90: e3500000 cmp r0, #0
a0006e94: 1afffff8 bne a0006e7c <rtems_io_register_driver+0x78>
a0006e98: e5930004 ldr r0, [r3, #4] a0006e9c: e3500000 cmp r0, #0
a0006ea0: 1afffff5 bne a0006e7c <rtems_io_register_driver+0x78>
}
/* Assigns invalid value in case of failure */
*major = m;
if ( m != n )
a0006ea4: e15c0004 cmp ip, r4
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
a0006ea8: e5824000 str r4, [r2]
if ( m != n )
a0006eac: 0a000023 beq a0006f40 <rtems_io_register_driver+0x13c>
a0006eb0: e3a0c018 mov ip, #24 a0006eb4: e00c0c94 mul ip, r4, ip
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
a0006eb8: e59e5000 ldr r5, [lr]
a0006ebc: e1a0e001 mov lr, r1
a0006ec0: e8be000f ldm lr!, {r0, r1, r2, r3}
a0006ec4: e085c00c add ip, r5, ip
a0006ec8: e8ac000f stmia ip!, {r0, r1, r2, r3}
a0006ecc: e89e0003 ldm lr, {r0, r1}
a0006ed0: e88c0003 stm ip, {r0, r1}
_Thread_Enable_dispatch();
a0006ed4: eb000765 bl a0008c70 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
a0006ed8: e3a01000 mov r1, #0 a0006edc: e1a00004 mov r0, r4 a0006ee0: e1a02001 mov r2, r1
}
a0006ee4: e8bd4030 pop {r4, r5, lr}
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
a0006ee8: ea00215d b a000f464 <rtems_io_initialize>
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
a0006eec: e3a0000a mov r0, #10
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
a0006ef0: e8bd8030 pop {r4, r5, pc}
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
a0006ef4: e3a00012 mov r0, #18
a0006ef8: 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;
a0006efc: e59fe068 ldr lr, [pc, #104] ; a0006f6c <rtems_io_register_driver+0x168> a0006f00: e3a0c018 mov ip, #24 a0006f04: e00c0c94 mul ip, r4, ip a0006f08: e59e3000 ldr r3, [lr]
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
a0006f0c: e793000c ldr r0, [r3, ip]
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
a0006f10: 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;
a0006f14: e3500000 cmp r0, #0
a0006f18: 0a00000b beq a0006f4c <rtems_io_register_driver+0x148>
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();
a0006f1c: eb000753 bl a0008c70 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
a0006f20: e3a0000c mov r0, #12
a0006f24: 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;
a0006f28: e591c004 ldr ip, [r1, #4] a0006f2c: e35c0000 cmp ip, #0
a0006f30: 1affffc3 bne a0006e44 <rtems_io_register_driver+0x40>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
a0006f34: e3a00009 mov r0, #9
a0006f38: e8bd8030 pop {r4, r5, pc}
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
a0006f3c: 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();
a0006f40: eb00074a bl a0008c70 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
a0006f44: 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;
a0006f48: 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;
a0006f4c: e5933004 ldr r3, [r3, #4] a0006f50: e3530000 cmp r3, #0
a0006f54: 1afffff0 bne a0006f1c <rtems_io_register_driver+0x118>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
a0006f58: e5824000 str r4, [r2] a0006f5c: eaffffd5 b a0006eb8 <rtems_io_register_driver+0xb4>
a0005814 <rtems_object_get_api_class_name>:
)
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
a0005814: e3500001 cmp r0, #1
const char *rtems_object_get_api_class_name(
int the_api,
int the_class
)
{
a0005818: 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 )
a000581c: 0a00000d beq a0005858 <rtems_object_get_api_class_name+0x44>
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
a0005820: e3500002 cmp r0, #2
a0005824: 0a000004 beq a000583c <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 )
a0005828: e3500003 cmp r0, #3
api_assoc = rtems_object_api_posix_assoc;
a000582c: 059f003c ldreq r0, [pc, #60] ; a0005870 <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 )
a0005830: 0a000002 beq a0005840 <rtems_object_get_api_class_name+0x2c>
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
a0005834: e59f0038 ldr r0, [pc, #56] ; a0005874 <rtems_object_get_api_class_name+0x60>
a0005838: 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;
a000583c: e59f0034 ldr r0, [pc, #52] ; a0005878 <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 );
a0005840: eb00138f bl a000a684 <rtems_assoc_ptr_by_local>
if ( class_assoc )
a0005844: e3500000 cmp r0, #0
return class_assoc->name;
a0005848: 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 )
a000584c: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
return class_assoc->name;
return "BAD CLASS";
a0005850: e59f0024 ldr r0, [pc, #36] ; a000587c <rtems_object_get_api_class_name+0x68>
}
a0005854: 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;
a0005858: e59f0020 ldr r0, [pc, #32] ; a0005880 <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 );
a000585c: eb001388 bl a000a684 <rtems_assoc_ptr_by_local>
if ( class_assoc )
a0005860: e3500000 cmp r0, #0
return class_assoc->name;
a0005864: 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 )
a0005868: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
a000586c: eafffff7 b a0005850 <rtems_object_get_api_class_name+0x3c> <== NOT EXECUTED
a000d5e4 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
a000d5e4: 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 )
a000d5e8: e2525000 subs r5, r2, #0
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
a000d5ec: e1a04000 mov r4, r0 a000d5f0: e1a06001 mov r6, r1
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
a000d5f4: 0a000053 beq a000d748 <rtems_task_mode+0x164>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
a000d5f8: e59f9158 ldr r9, [pc, #344] ; a000d758 <rtems_task_mode+0x174> a000d5fc: e5997004 ldr r7, [r9, #4]
api = executing->API_Extensions[ THREAD_API_RTEMS ];
a000d600: e59780f8 ldr r8, [r7, #248] ; 0xf8
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
a000d604: e5d7a074 ldrb sl, [r7, #116] ; 0x74
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
a000d608: e597307c ldr r3, [r7, #124] ; 0x7c
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
a000d60c: 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;
a000d610: e35a0000 cmp sl, #0 a000d614: 03a0ac01 moveq sl, #256 ; 0x100 a000d618: 13a0a000 movne sl, #0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
a000d61c: e3530000 cmp r3, #0
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
a000d620: 138aac02 orrne sl, sl, #512 ; 0x200
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
a000d624: e35b0000 cmp fp, #0 a000d628: 03a0bb01 moveq fp, #1024 ; 0x400 a000d62c: 13a0b000 movne fp, #0
old_mode |= _ISR_Get_level();
a000d630: ebffee68 bl a0008fd8 <_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;
a000d634: e18bb000 orr fp, fp, r0
old_mode |= _ISR_Get_level();
a000d638: e18ba00a orr sl, fp, sl
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
a000d63c: 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;
a000d640: e585a000 str sl, [r5]
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
a000d644: 0a000003 beq a000d658 <rtems_task_mode+0x74>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
a000d648: e3140c01 tst r4, #256 ; 0x100 a000d64c: 13a03000 movne r3, #0 a000d650: 03a03001 moveq r3, #1 a000d654: e5c73074 strb r3, [r7, #116] ; 0x74
if ( mask & RTEMS_TIMESLICE_MASK ) {
a000d658: e3160c02 tst r6, #512 ; 0x200
a000d65c: 1a00001c bne a000d6d4 <rtems_task_mode+0xf0>
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
a000d660: e3160080 tst r6, #128 ; 0x80
a000d664: 1a000023 bne a000d6f8 <rtems_task_mode+0x114>
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
a000d668: e2166b01 ands r6, r6, #1024 ; 0x400
a000d66c: 0a000012 beq a000d6bc <rtems_task_mode+0xd8>
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
a000d670: e5d82008 ldrb r2, [r8, #8]
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
a000d674: e3140b01 tst r4, #1024 ; 0x400 a000d678: 13a03000 movne r3, #0 a000d67c: 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 ) {
a000d680: e1520003 cmp r2, r3
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
a000d684: 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 ) {
a000d688: 0a00000b beq a000d6bc <rtems_task_mode+0xd8>
asr->is_enabled = is_asr_enabled;
a000d68c: e5c83008 strb r3, [r8, #8]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a000d690: e10f3000 mrs r3, CPSR a000d694: e3832080 orr r2, r3, #128 ; 0x80 a000d698: e129f002 msr CPSR_fc, r2
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
a000d69c: e5981018 ldr r1, [r8, #24]
information->signals_pending = information->signals_posted;
a000d6a0: e5982014 ldr r2, [r8, #20]
information->signals_posted = _signals;
a000d6a4: 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;
a000d6a8: e5882018 str r2, [r8, #24]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a000d6ac: e129f003 msr CPSR_fc, r3
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
a000d6b0: e5986014 ldr r6, [r8, #20] a000d6b4: e3560000 cmp r6, #0
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
a000d6b8: 13a06001 movne r6, #1
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
a000d6bc: e59f3098 ldr r3, [pc, #152] ; a000d75c <rtems_task_mode+0x178> a000d6c0: e5933000 ldr r3, [r3] a000d6c4: e3530003 cmp r3, #3
a000d6c8: 0a00000d beq a000d704 <rtems_task_mode+0x120>
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
a000d6cc: e3a00000 mov r0, #0 <== NOT EXECUTED
a000d6d0: 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) ) {
a000d6d4: e2143c02 ands r3, r4, #512 ; 0x200
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
a000d6d8: 13a03001 movne r3, #1 a000d6dc: 1587307c strne r3, [r7, #124] ; 0x7c
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
a000d6e0: 159f3078 ldrne r3, [pc, #120] ; a000d760 <rtems_task_mode+0x17c>
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
a000d6e4: 0587307c streq r3, [r7, #124] ; 0x7c
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
a000d6e8: 15933000 ldrne r3, [r3] a000d6ec: 15873078 strne r3, [r7, #120] ; 0x78
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
a000d6f0: e3160080 tst r6, #128 ; 0x80
a000d6f4: 0affffdb beq a000d668 <rtems_task_mode+0x84>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
a000d6f8: e2040080 and r0, r4, #128 ; 0x80 a000d6fc: ebffee30 bl a0008fc4 <_CPU_ISR_Set_level> a000d700: eaffffd8 b a000d668 <rtems_task_mode+0x84>
{
Thread_Control *executing;
executing = _Thread_Executing;
if ( are_signals_pending ||
a000d704: e3560000 cmp r6, #0
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
a000d708: e5993004 ldr r3, [r9, #4]
if ( are_signals_pending ||
a000d70c: 1a000008 bne a000d734 <rtems_task_mode+0x150>
a000d710: e59f2040 ldr r2, [pc, #64] ; a000d758 <rtems_task_mode+0x174> a000d714: e5922008 ldr r2, [r2, #8] a000d718: e1530002 cmp r3, r2
a000d71c: 0a00000b beq a000d750 <rtems_task_mode+0x16c>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
a000d720: e5d33074 ldrb r3, [r3, #116] ; 0x74 a000d724: e3530000 cmp r3, #0
a000d728: 1a000001 bne a000d734 <rtems_task_mode+0x150>
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
a000d72c: e1a00006 mov r0, r6 <== NOT EXECUTED
}
a000d730: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
a000d734: e3a03001 mov r3, #1 a000d738: e5c93010 strb r3, [r9, #16]
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
a000d73c: ebffe841 bl a0007848 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
a000d740: e3a00000 mov r0, #0
a000d744: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
a000d748: e3a00009 mov r0, #9
a000d74c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
a000d750: e1a00006 mov r0, r6
a000d754: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
a0008618 <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
a0008618: e92d4010 push {r4, lr}
a000861c: e24dd004 sub sp, sp, #4
a0008620: 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 );
a0008624: e1a00001 mov r0, r1 a0008628: e1a0100d mov r1, sp a000862c: eb001682 bl a000e03c <_POSIX_Absolute_timeout_to_ticks>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
a0008630: e3500003 cmp r0, #3
a0008634: 0a000005 beq a0008650 <sem_timedwait+0x38>
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
a0008638: e1a00004 mov r0, r4 <== NOT EXECUTED a000863c: e3a01000 mov r1, #0 <== NOT EXECUTED a0008640: e59d2000 ldr r2, [sp] <== NOT EXECUTED a0008644: eb001998 bl a000ecac <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
a0008648: e28dd004 add sp, sp, #4
a000864c: 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 );
a0008650: e1a00004 mov r0, r4 a0008654: e3a01001 mov r1, #1 a0008658: e59d2000 ldr r2, [sp] a000865c: eb001992 bl a000ecac <_POSIX_Semaphore_Wait_support> a0008660: eafffff8 b a0008648 <sem_timedwait+0x30>
a0005e64 <sigaction>:
struct sigaction *oact
)
{
ISR_Level level;
if ( oact )
a0005e64: e3520000 cmp r2, #0
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
a0005e68: e92d4070 push {r4, r5, r6, lr}
a0005e6c: e1a04000 mov r4, r0
a0005e70: e1a05001 mov r5, r1
ISR_Level level;
if ( oact )
a0005e74: 0a00000a beq a0005ea4 <sigaction+0x40>
*oact = _POSIX_signals_Vectors[ sig ];
a0005e78: e3a0100c mov r1, #12 a0005e7c: e59f00ec ldr r0, [pc, #236] ; a0005f70 <sigaction+0x10c> a0005e80: e0010194 mul r1, r4, r1 a0005e84: e1a03002 mov r3, r2 a0005e88: e790c001 ldr ip, [r0, r1] a0005e8c: e0801001 add r1, r0, r1 a0005e90: e483c004 str ip, [r3], #4 a0005e94: e5910004 ldr r0, [r1, #4] a0005e98: e5820004 str r0, [r2, #4] a0005e9c: e5912008 ldr r2, [r1, #8] a0005ea0: e5832004 str r2, [r3, #4]
if ( !sig )
a0005ea4: e3540000 cmp r4, #0
a0005ea8: 0a00002b beq a0005f5c <sigaction+0xf8>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
a0005eac: e2443001 sub r3, r4, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
a0005eb0: e353001f cmp r3, #31
a0005eb4: 8a000028 bhi a0005f5c <sigaction+0xf8>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
a0005eb8: e3540009 cmp r4, #9
a0005ebc: 0a000026 beq a0005f5c <sigaction+0xf8>
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
a0005ec0: e3550000 cmp r5, #0
a0005ec4: 0a000022 beq a0005f54 <sigaction+0xf0>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a0005ec8: e10f6000 mrs r6, CPSR a0005ecc: e3863080 orr r3, r6, #128 ; 0x80 a0005ed0: 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 ) {
a0005ed4: e5953008 ldr r3, [r5, #8] a0005ed8: e3530000 cmp r3, #0
a0005edc: 0a00000f beq a0005f20 <sigaction+0xbc>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
a0005ee0: e1a00004 mov r0, r4 a0005ee4: eb001756 bl a000bc44 <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
a0005ee8: e1a03005 mov r3, r5 a0005eec: e3a0000c mov r0, #12 a0005ef0: e4931004 ldr r1, [r3], #4 a0005ef4: e59f2074 ldr r2, [pc, #116] ; a0005f70 <sigaction+0x10c> a0005ef8: e0040490 mul r4, r0, r4 a0005efc: e7821004 str r1, [r2, r4] a0005f00: e5951004 ldr r1, [r5, #4] a0005f04: e0824004 add r4, r2, r4 a0005f08: e5841004 str r1, [r4, #4] a0005f0c: e5933004 ldr r3, [r3, #4] a0005f10: e5843008 str r3, [r4, #8]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a0005f14: 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;
a0005f18: e3a00000 mov r0, #0
a0005f1c: 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 ];
a0005f20: e3a0300c mov r3, #12
a0005f24: e0040493 mul r4, r3, r4
a0005f28: e59f1044 ldr r1, [pc, #68] ; a0005f74 <sigaction+0x110>
a0005f2c: e59f203c ldr r2, [pc, #60] ; a0005f70 <sigaction+0x10c>
a0005f30: e0813004 add r3, r1, r4
a0005f34: e791c004 ldr ip, [r1, r4]
a0005f38: e9930003 ldmib r3, {r0, r1}
a0005f3c: e0823004 add r3, r2, r4
a0005f40: e782c004 str ip, [r2, r4]
a0005f44: e9830003 stmib r3, {r0, r1}
a0005f48: 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;
a0005f4c: e3a00000 mov r0, #0
a0005f50: e8bd8070 pop {r4, r5, r6, pc}
a0005f54: e1a00005 mov r0, r5
}
a0005f58: e8bd8070 pop {r4, r5, r6, pc}
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
rtems_set_errno_and_return_minus_one( EINVAL );
a0005f5c: eb0023cf bl a000eea0 <__errno>
a0005f60: e3a03016 mov r3, #22
a0005f64: e5803000 str r3, [r0]
a0005f68: e3e00000 mvn r0, #0
a0005f6c: e8bd8070 pop {r4, r5, r6, pc}
a00084b4 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
a00084b4: e92d4010 push {r4, lr}
a00084b8: e1a04001 mov r4, r1
int status;
status = sigtimedwait( set, NULL, NULL );
a00084bc: e3a01000 mov r1, #0 a00084c0: e1a02001 mov r2, r1 a00084c4: ebffff7f bl a00082c8 <sigtimedwait>
if ( status != -1 ) {
a00084c8: e3700001 cmn r0, #1
a00084cc: 0a000004 beq a00084e4 <sigwait+0x30>
if ( sig )
a00084d0: e3540000 cmp r4, #0
a00084d4: 0a000005 beq a00084f0 <sigwait+0x3c>
*sig = status;
a00084d8: e5840000 str r0, [r4]
return 0;
a00084dc: e3a00000 mov r0, #0
a00084e0: e8bd8010 pop {r4, pc}
}
return errno;
a00084e4: eb002328 bl a001118c <__errno>
a00084e8: e5900000 ldr r0, [r0]
a00084ec: e8bd8010 pop {r4, pc}
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
a00084f0: e1a00004 mov r0, r4 <== NOT EXECUTED
}
return errno;
}
a00084f4: e8bd8010 pop {r4, pc} <== NOT EXECUTED