3000a3dc <_CORE_mutex_Seize_interrupt_trylock>:
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000a3dc: e59f3154 ldr r3, [pc, #340] ; 3000a538 <_CORE_mutex_Seize_interrupt_trylock+0x15c>
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
3000a3e0: e3a02000 mov r2, #0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000a3e4: e5933000 ldr r3, [r3]
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
3000a3e8: e92d4070 push {r4, r5, r6, lr}
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
3000a3ec: e5832034 str r2, [r3, #52] ; 0x34
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000a3f0: e590c050 ldr ip, [r0, #80] ; 0x50 3000a3f4: e15c0002 cmp ip, r2
3000a3f8: 0a00000e beq 3000a438 <_CORE_mutex_Seize_interrupt_trylock+0x5c>
the_mutex->lock = CORE_MUTEX_LOCKED;
3000a3fc: e5802050 str r2, [r0, #80] ; 0x50
*/
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
CORE_mutex_Attributes *the_attribute
)
{
return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
3000a400: e590c048 ldr ip, [r0, #72] ; 0x48
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
3000a404: e5935008 ldr r5, [r3, #8]
the_mutex->nest_count = 1;
3000a408: e3a04001 mov r4, #1
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000a40c: e35c0002 cmp ip, #2
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
3000a410: e5805060 str r5, [r0, #96] ; 0x60
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
3000a414: e580305c str r3, [r0, #92] ; 0x5c
the_mutex->holder_id = executing->Object.id;
the_mutex->nest_count = 1;
3000a418: e5804054 str r4, [r0, #84] ; 0x54
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000a41c: 0a00000a beq 3000a44c <_CORE_mutex_Seize_interrupt_trylock+0x70>
3000a420: e35c0003 cmp ip, #3
3000a424: 0a000019 beq 3000a490 <_CORE_mutex_Seize_interrupt_trylock+0xb4>
3000a428: e5913000 ldr r3, [r1]
3000a42c: e129f003 msr CPSR_fc, r3
3000a430: e3a00000 mov r0, #0
3000a434: e8bd8070 pop {r4, r5, r6, pc}
/*
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
3000a438: e590205c ldr r2, [r0, #92] ; 0x5c 3000a43c: e1530002 cmp r3, r2
3000a440: 0a000008 beq 3000a468 <_CORE_mutex_Seize_interrupt_trylock+0x8c>
3000a444: e3a00001 mov r0, #1
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); }
3000a448: e8bd8070 pop {r4, r5, r6, pc}
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000a44c: e593201c ldr r2, [r3, #28]
3000a450: e2822001 add r2, r2, #1
3000a454: e583201c str r2, [r3, #28]
3000a458: e5913000 ldr r3, [r1]
3000a45c: e129f003 msr CPSR_fc, r3
3000a460: e3a00000 mov r0, #0
3000a464: e8bd8070 pop {r4, r5, r6, pc}
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
3000a468: e5902040 ldr r2, [r0, #64] ; 0x40 3000a46c: e3520000 cmp r2, #0
3000a470: 1a000017 bne 3000a4d4 <_CORE_mutex_Seize_interrupt_trylock+0xf8>
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
3000a474: e5903054 ldr r3, [r0, #84] ; 0x54
3000a478: e2833001 add r3, r3, #1
3000a47c: e5803054 str r3, [r0, #84] ; 0x54
3000a480: e5913000 ldr r3, [r1]
3000a484: e129f003 msr CPSR_fc, r3
3000a488: e3a00000 mov r0, #0
3000a48c: e8bd8070 pop {r4, r5, r6, pc}
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000a490: e593c01c ldr ip, [r3, #28]
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
3000a494: e5935014 ldr r5, [r3, #20]
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000a498: e08c6004 add r6, ip, r4 3000a49c: e583601c str r6, [r3, #28]
*/
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
3000a4a0: e590604c ldr r6, [r0, #76] ; 0x4c
current = executing->current_priority;
if ( current == ceiling ) {
3000a4a4: e1560005 cmp r6, r5
3000a4a8: 0a00001e beq 3000a528 <_CORE_mutex_Seize_interrupt_trylock+0x14c>
_ISR_Enable( *level_p );
return 0;
}
if ( current > ceiling ) {
3000a4ac: 3a000010 bcc 3000a4f4 <_CORE_mutex_Seize_interrupt_trylock+0x118>
);
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
3000a4b0: e3a05006 mov r5, #6 3000a4b4: e5835034 str r5, [r3, #52] ; 0x34
the_mutex->lock = CORE_MUTEX_UNLOCKED;
the_mutex->nest_count = 0; /* undo locking above */
3000a4b8: e5802054 str r2, [r0, #84] ; 0x54
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
the_mutex->lock = CORE_MUTEX_UNLOCKED;
3000a4bc: e5804050 str r4, [r0, #80] ; 0x50
the_mutex->nest_count = 0; /* undo locking above */
executing->resource_count--; /* undo locking above */
3000a4c0: e583c01c str ip, [r3, #28]
3000a4c4: e5913000 ldr r3, [r1]
3000a4c8: e129f003 msr CPSR_fc, r3
3000a4cc: e3a00000 mov r0, #0
3000a4d0: e8bd8070 pop {r4, r5, r6, pc}
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
3000a4d4: e3520001 cmp r2, #1
3000a4d8: 1affffd9 bne 3000a444 <_CORE_mutex_Seize_interrupt_trylock+0x68>
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
_ISR_Enable( *level_p );
return 0;
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
3000a4dc: e3a02002 mov r2, #2 <== NOT EXECUTED
3000a4e0: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
3000a4e4: e5913000 ldr r3, [r1] <== NOT EXECUTED
3000a4e8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
3000a4ec: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a4f0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000a4f4: e59f3040 ldr r3, [pc, #64] ; 3000a53c <_CORE_mutex_Seize_interrupt_trylock+0x160> 3000a4f8: e5932000 ldr r2, [r3] 3000a4fc: e2822001 add r2, r2, #1 3000a500: e5832000 str r2, [r3] 3000a504: e5913000 ldr r3, [r1] 3000a508: e129f003 msr CPSR_fc, r3
}
if ( current > ceiling ) {
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
_Thread_Change_priority(
3000a50c: e3a02000 mov r2, #0 3000a510: e590104c ldr r1, [r0, #76] ; 0x4c 3000a514: e590005c ldr r0, [r0, #92] ; 0x5c 3000a518: ebfff175 bl 30006af4 <_Thread_Change_priority>
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
3000a51c: ebfff2de bl 3000709c <_Thread_Enable_dispatch>
3000a520: e3a00000 mov r0, #0
3000a524: e8bd8070 pop {r4, r5, r6, pc}
3000a528: e5913000 ldr r3, [r1]
3000a52c: e129f003 msr CPSR_fc, r3
3000a530: e3a00000 mov r0, #0
3000a534: e8bd8070 pop {r4, r5, r6, pc}
3000a628 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000a628: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000a62c: e1a08002 mov r8, r2
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
Heap_Block *block = _Heap_Free_list_first( heap );
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_BLOCK_SIZE_OFFSET;
uintptr_t const page_size = heap->page_size;
3000a630: e5902010 ldr r2, [r0, #16]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000a634: e24dd01c sub sp, sp, #28 3000a638: e1a05001 mov r5, r1
- HEAP_BLOCK_SIZE_OFFSET;
uintptr_t const page_size = heap->page_size;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
if ( block_size_floor < alloc_size ) {
3000a63c: e2911004 adds r1, r1, #4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000a640: e1a07000 mov r7, r0
- HEAP_BLOCK_SIZE_OFFSET;
uintptr_t const page_size = heap->page_size;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
if ( block_size_floor < alloc_size ) {
3000a644: e58d1000 str r1, [sp]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000a648: e1a0b003 mov fp, r3
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
3000a64c: e590a008 ldr sl, [r0, #8]
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
Heap_Block *block = _Heap_Free_list_first( heap );
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_BLOCK_SIZE_OFFSET;
uintptr_t const page_size = heap->page_size;
3000a650: e58d200c str r2, [sp, #12]
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
if ( block_size_floor < alloc_size ) {
3000a654: 2a000074 bcs 3000a82c <_Heap_Allocate_aligned_with_boundary+0x204>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
3000a658: e3530000 cmp r3, #0
3000a65c: 1a000070 bne 3000a824 <_Heap_Allocate_aligned_with_boundary+0x1fc>
if ( alignment == 0 ) {
alignment = page_size;
}
}
while ( block != free_list_tail ) {
3000a660: e157000a cmp r7, sl 3000a664: 03a06000 moveq r6, #0
3000a668: 0a000072 beq 3000a838 <_Heap_Allocate_aligned_with_boundary+0x210>
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;
3000a66c: e59d300c ldr r3, [sp, #12]
uintptr_t alloc_end = block_end + HEAP_BLOCK_SIZE_OFFSET;
uintptr_t alloc_begin = alloc_end - alloc_size;
3000a670: e2651004 rsb r1, r5, #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;
3000a674: e2833007 add r3, r3, #7
if ( alignment == 0 ) {
alignment = page_size;
}
}
while ( block != free_list_tail ) {
3000a678: e3a06000 mov r6, #0
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;
3000a67c: e58d3010 str r3, [sp, #16]
uintptr_t alloc_end = block_end + HEAP_BLOCK_SIZE_OFFSET;
uintptr_t alloc_begin = alloc_end - alloc_size;
3000a680: e58d1014 str r1, [sp, #20] 3000a684: ea000004 b 3000a69c <_Heap_Allocate_aligned_with_boundary+0x74>
boundary
);
}
}
if ( alloc_begin != 0 ) {
3000a688: e3540000 cmp r4, #0
3000a68c: 1a000057 bne 3000a7f0 <_Heap_Allocate_aligned_with_boundary+0x1c8>
break;
}
block = block->next;
3000a690: e59aa008 ldr sl, [sl, #8]
if ( alignment == 0 ) {
alignment = page_size;
}
}
while ( block != free_list_tail ) {
3000a694: e157000a cmp r7, sl
3000a698: 0a000066 beq 3000a838 <_Heap_Allocate_aligned_with_boundary+0x210>
/*
* 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 ) {
3000a69c: e59a9004 ldr r9, [sl, #4] 3000a6a0: e59d2000 ldr r2, [sp]
while ( block != free_list_tail ) {
_HAssert( _Heap_Is_prev_used( block ) );
/* Statistics */
++search_count;
3000a6a4: e2866001 add r6, r6, #1
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
3000a6a8: e1520009 cmp r2, r9
3000a6ac: 2afffff7 bcs 3000a690 <_Heap_Allocate_aligned_with_boundary+0x68>
if ( alignment == 0 ) {
3000a6b0: 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;
3000a6b4: 028a4008 addeq r4, sl, #8
3000a6b8: 0afffff2 beq 3000a688 <_Heap_Allocate_aligned_with_boundary+0x60>
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_BLOCK_SIZE_OFFSET;
uintptr_t alloc_begin = alloc_end - alloc_size;
3000a6bc: e59d1014 ldr r1, [sp, #20]
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;
3000a6c0: e3c99001 bic r9, r9, #1 3000a6c4: e08a9009 add r9, sl, r9
uintptr_t alignment,
uintptr_t boundary
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
3000a6c8: e5973014 ldr r3, [r7, #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;
3000a6cc: e59d2010 ldr r2, [sp, #16]
uintptr_t alloc_end = block_end + HEAP_BLOCK_SIZE_OFFSET;
uintptr_t alloc_begin = alloc_end - alloc_size;
3000a6d0: e0814009 add r4, r1, r9
uintptr_t alignment,
uintptr_t boundary
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
3000a6d4: e58d3004 str r3, [sp, #4]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000a6d8: e1a00004 mov r0, r4
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;
3000a6dc: e0633002 rsb r3, r3, r2 3000a6e0: e1a01008 mov r1, r8 3000a6e4: e0839009 add r9, r3, r9 3000a6e8: eb002e5c bl 30016060 <__umodsi3> 3000a6ec: e0604004 rsb r4, r0, r4
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
3000a6f0: e28a3008 add r3, sl, #8
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 ) {
3000a6f4: e1590004 cmp r9, r4 3000a6f8: e58d3008 str r3, [sp, #8]
3000a6fc: 2a000003 bcs 3000a710 <_Heap_Allocate_aligned_with_boundary+0xe8>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000a700: e1a00009 mov r0, r9 3000a704: e1a01008 mov r1, r8 3000a708: eb002e54 bl 30016060 <__umodsi3> 3000a70c: e0604009 rsb r4, r0, r9
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
3000a710: e35b0000 cmp fp, #0
3000a714: 0a000025 beq 3000a7b0 <_Heap_Allocate_aligned_with_boundary+0x188>
/* 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;
3000a718: e0849005 add r9, r4, r5 3000a71c: e1a00009 mov r0, r9 3000a720: e1a0100b mov r1, fp 3000a724: eb002e4d bl 30016060 <__umodsi3> 3000a728: e0600009 rsb r0, r0, r9
/* 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 ) {
3000a72c: e1590000 cmp r9, r0 3000a730: 93a03000 movls r3, #0 3000a734: 83a03001 movhi r3, #1 3000a738: e1540000 cmp r4, r0 3000a73c: 23a03000 movcs r3, #0 3000a740: e3530000 cmp r3, #0
3000a744: 0a000019 beq 3000a7b0 <_Heap_Allocate_aligned_with_boundary+0x188>
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
3000a748: e59d1008 ldr r1, [sp, #8] 3000a74c: e0819005 add r9, 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 ) {
3000a750: e1590000 cmp r9, r0 3000a754: 958d6018 strls r6, [sp, #24]
3000a758: 9a000002 bls 3000a768 <_Heap_Allocate_aligned_with_boundary+0x140>
3000a75c: eaffffcb b 3000a690 <_Heap_Allocate_aligned_with_boundary+0x68> 3000a760: e1590000 cmp r9, r0
3000a764: 8a000035 bhi 3000a840 <_Heap_Allocate_aligned_with_boundary+0x218>
return 0;
}
alloc_begin = boundary_line - alloc_size;
3000a768: e0654000 rsb r4, r5, r0 3000a76c: e1a01008 mov r1, r8 3000a770: e1a00004 mov r0, r4 3000a774: eb002e39 bl 30016060 <__umodsi3> 3000a778: e0604004 rsb r4, r0, r4
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
3000a77c: e0846005 add r6, r4, r5 3000a780: e1a00006 mov r0, r6 3000a784: e1a0100b mov r1, fp 3000a788: eb002e34 bl 30016060 <__umodsi3> 3000a78c: e0600006 rsb r0, r0, r6
/* 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 ) {
3000a790: e1560000 cmp r6, r0 3000a794: 93a03000 movls r3, #0 3000a798: 83a03001 movhi r3, #1 3000a79c: e1540000 cmp r4, r0 3000a7a0: 23a03000 movcs r3, #0 3000a7a4: e3530000 cmp r3, #0
3000a7a8: 1affffec bne 3000a760 <_Heap_Allocate_aligned_with_boundary+0x138>
3000a7ac: e59d6018 ldr r6, [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 ) {
3000a7b0: e59d2008 ldr r2, [sp, #8] 3000a7b4: e1520004 cmp r2, r4
3000a7b8: 8affffb4 bhi 3000a690 <_Heap_Allocate_aligned_with_boundary+0x68>
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;
3000a7bc: e59d100c ldr r1, [sp, #12] 3000a7c0: e1a00004 mov r0, r4 3000a7c4: eb002e25 bl 30016060 <__umodsi3> 3000a7c8: e3e09007 mvn r9, #7 3000a7cc: e06a9009 rsb r9, sl, r9 3000a7d0: e0899004 add r9, r9, r4
if ( free_size >= min_block_size || free_size == 0 ) {
3000a7d4: e59d1004 ldr r1, [sp, #4] 3000a7d8: e0603009 rsb r3, r0, r9 3000a7dc: e1590000 cmp r9, r0 3000a7e0: 11510003 cmpne r1, r3
3000a7e4: 8affffa9 bhi 3000a690 <_Heap_Allocate_aligned_with_boundary+0x68>
boundary
);
}
}
if ( alloc_begin != 0 ) {
3000a7e8: e3540000 cmp r4, #0
3000a7ec: 0affffa7 beq 3000a690 <_Heap_Allocate_aligned_with_boundary+0x68>
block = block->next;
}
if ( alloc_begin != 0 ) {
/* Statistics */
stats->searches += search_count;
3000a7f0: e597304c ldr r3, [r7, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000a7f4: e1a0100a mov r1, sl
block = block->next;
}
if ( alloc_begin != 0 ) {
/* Statistics */
stats->searches += search_count;
3000a7f8: e0833006 add r3, r3, r6 3000a7fc: e587304c str r3, [r7, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000a800: e1a00007 mov r0, r7 3000a804: e1a03005 mov r3, r5 3000a808: e1a02004 mov r2, r4 3000a80c: ebffee30 bl 300060d4 <_Heap_Block_allocate> 3000a810: e1a00004 mov r0, r4
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
Heap_Statistics *const stats = &heap->stats;
3000a814: e5973044 ldr r3, [r7, #68] ; 0x44 3000a818: e1530006 cmp r3, r6
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
3000a81c: 35876044 strcc r6, [r7, #68] ; 0x44 3000a820: ea000002 b 3000a830 <_Heap_Allocate_aligned_with_boundary+0x208>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
3000a824: e1550003 cmp r5, r3
3000a828: 9a000006 bls 3000a848 <_Heap_Allocate_aligned_with_boundary+0x220>
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
3000a82c: e3a00000 mov r0, #0
}
return (void *) alloc_begin;
}
3000a830: e28dd01c add sp, sp, #28
3000a834: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if ( alignment == 0 ) {
alignment = page_size;
}
}
while ( block != free_list_tail ) {
3000a838: e3a00000 mov r0, #0 3000a83c: eafffff4 b 3000a814 <_Heap_Allocate_aligned_with_boundary+0x1ec>
3000a840: e59d6018 ldr r6, [sp, #24] <== NOT EXECUTED 3000a844: eaffff91 b 3000a690 <_Heap_Allocate_aligned_with_boundary+0x68><== NOT EXECUTED
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
return NULL;
}
if ( alignment == 0 ) {
3000a848: e3580000 cmp r8, #0 3000a84c: 01a08002 moveq r8, r2 3000a850: eaffff82 b 3000a660 <_Heap_Allocate_aligned_with_boundary+0x38>
30006e5c <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
30006e5c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = heap->first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
30006e60: e59f35d0 ldr r3, [pc, #1488] ; 30007438 <_Heap_Walk+0x5dc>
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = heap->first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
30006e64: e31200ff tst r2, #255 ; 0xff
if ( !_System_state_Is_up( _System_state_Get() ) ) {
30006e68: e5933000 ldr r3, [r3]
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = heap->first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
30006e6c: e59f25c8 ldr r2, [pc, #1480] ; 3000743c <_Heap_Walk+0x5e0> 30006e70: e59fa5c8 ldr sl, [pc, #1480] ; 30007440 <_Heap_Walk+0x5e4>
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
30006e74: e24dd038 sub sp, sp, #56 ; 0x38
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = heap->first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
30006e78: 01a0a002 moveq sl, r2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
30006e7c: e3530003 cmp r3, #3
Heap_Control *heap,
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
30006e80: e5902010 ldr r2, [r0, #16]
uintptr_t const min_block_size = heap->min_block_size; Heap_Block *const last_block = heap->last_block;
30006e84: e5903024 ldr r3, [r0, #36] ; 0x24
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
30006e88: e1a04000 mov r4, r0 30006e8c: e1a08001 mov r8, r1
uintptr_t const page_size = heap->page_size;
30006e90: e58d2020 str r2, [sp, #32]
uintptr_t const min_block_size = heap->min_block_size;
30006e94: e590b014 ldr fp, [r0, #20]
Heap_Block *const last_block = heap->last_block;
30006e98: e58d3024 str r3, [sp, #36] ; 0x24
Heap_Block *block = heap->first_block;
30006e9c: e5905020 ldr r5, [r0, #32]
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
30006ea0: 0a000002 beq 30006eb0 <_Heap_Walk+0x54>
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
}
while ( block != last_block ) {
30006ea4: e3a00001 mov r0, #1
block = next_block;
}
return true;
}
30006ea8: e28dd038 add sp, sp, #56 ; 0x38
30006eac: 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)(
30006eb0: e5900018 ldr r0, [r0, #24]
30006eb4: e594101c ldr r1, [r4, #28]
30006eb8: e5942008 ldr r2, [r4, #8]
30006ebc: e594300c ldr r3, [r4, #12]
30006ec0: e59dc024 ldr ip, [sp, #36] ; 0x24
30006ec4: e98d0003 stmib sp, {r0, r1}
30006ec8: e58d2014 str r2, [sp, #20]
30006ecc: e58d3018 str r3, [sp, #24]
30006ed0: e59f256c ldr r2, [pc, #1388] ; 30007444 <_Heap_Walk+0x5e8>
30006ed4: e58db000 str fp, [sp]
30006ed8: e58d500c str r5, [sp, #12]
30006edc: e58dc010 str ip, [sp, #16]
30006ee0: e1a00008 mov r0, r8
30006ee4: e3a01000 mov r1, #0
30006ee8: e59d3020 ldr r3, [sp, #32]
30006eec: e1a0e00f mov lr, pc
30006ef0: e12fff1a bx sl
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
30006ef4: e59d2020 ldr r2, [sp, #32] 30006ef8: e3520000 cmp r2, #0
30006efc: 0a000032 beq 30006fcc <_Heap_Walk+0x170>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
30006f00: e59d3020 ldr r3, [sp, #32] 30006f04: e2139003 ands r9, r3, #3
30006f08: 1a000036 bne 30006fe8 <_Heap_Walk+0x18c>
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
30006f0c: e1a0000b mov r0, fp 30006f10: e59d1020 ldr r1, [sp, #32] 30006f14: ebffe73d bl 30000c10 <__umodsi3> 30006f18: e2506000 subs r6, r0, #0
30006f1c: 1a000038 bne 30007004 <_Heap_Walk+0x1a8>
);
return false;
}
if (
30006f20: e2850008 add r0, r5, #8 30006f24: e59d1020 ldr r1, [sp, #32] 30006f28: ebffe738 bl 30000c10 <__umodsi3> 30006f2c: e2509000 subs r9, r0, #0
30006f30: 1a00003b bne 30007024 <_Heap_Walk+0x1c8>
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;
30006f34: e5957004 ldr r7, [r5, #4]
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
30006f38: e2176001 ands r6, r7, #1
30006f3c: 0a000040 beq 30007044 <_Heap_Walk+0x1e8>
);
return false;
}
if ( first_block->prev_size != page_size ) {
30006f40: e5953000 ldr r3, [r5] 30006f44: e59dc020 ldr ip, [sp, #32] 30006f48: e15c0003 cmp ip, r3
30006f4c: 1a000016 bne 30006fac <_Heap_Walk+0x150>
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
30006f50: e59d2024 ldr r2, [sp, #36] ; 0x24 30006f54: e5923004 ldr r3, [r2, #4] 30006f58: e3c33001 bic r3, r3, #1 30006f5c: e0823003 add r3, r2, r3 30006f60: e5939004 ldr r9, [r3, #4] 30006f64: e2199001 ands r9, r9, #1
30006f68: 0a000112 beq 300073b8 <_Heap_Walk+0x55c>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
30006f6c: e5949008 ldr r9, [r4, #8]
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
30006f70: e5943010 ldr r3, [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 ) {
30006f74: e1540009 cmp r4, r9
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
30006f78: e58d3028 str r3, [sp, #40] ; 0x28
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 ) {
30006f7c: 0a00006c beq 30007134 <_Heap_Walk+0x2d8>
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;
30006f80: e594c020 ldr ip, [r4, #32]
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
30006f84: e15c0009 cmp ip, r9
30006f88: 9a000034 bls 30007060 <_Heap_Walk+0x204>
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
30006f8c: e1a00008 mov r0, r8 30006f90: e1a03009 mov r3, r9 30006f94: e3a01001 mov r1, #1 30006f98: e59f24a8 ldr r2, [pc, #1192] ; 30007448 <_Heap_Walk+0x5ec> 30006f9c: e1a0e00f mov lr, pc 30006fa0: e12fff1a bx sl 30006fa4: e3a00000 mov r0, #0 30006fa8: eaffffbe b 30006ea8 <_Heap_Walk+0x4c>
return false;
}
if ( first_block->prev_size != page_size ) {
(*printer)(
30006fac: e1a00008 mov r0, r8 30006fb0: e58dc000 str ip, [sp] 30006fb4: e3a01001 mov r1, #1 30006fb8: e59f248c ldr r2, [pc, #1164] ; 3000744c <_Heap_Walk+0x5f0> 30006fbc: e1a0e00f mov lr, pc 30006fc0: e12fff1a bx sl 30006fc4: e1a00009 mov r0, r9 30006fc8: eaffffb6 b 30006ea8 <_Heap_Walk+0x4c>
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
(*printer)( source, true, "page size is zero\n" );
30006fcc: e1a00008 mov r0, r8 30006fd0: e3a01001 mov r1, #1 30006fd4: e59f2474 ldr r2, [pc, #1140] ; 30007450 <_Heap_Walk+0x5f4> 30006fd8: e1a0e00f mov lr, pc 30006fdc: e12fff1a bx sl 30006fe0: e59d0020 ldr r0, [sp, #32] 30006fe4: eaffffaf b 30006ea8 <_Heap_Walk+0x4c>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
30006fe8: e1a00008 mov r0, r8 30006fec: e3a01001 mov r1, #1 30006ff0: e59f245c ldr r2, [pc, #1116] ; 30007454 <_Heap_Walk+0x5f8> 30006ff4: e1a0e00f mov lr, pc 30006ff8: e12fff1a bx sl 30006ffc: e3a00000 mov r0, #0 30007000: eaffffa8 b 30006ea8 <_Heap_Walk+0x4c>
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
30007004: e1a00008 mov r0, r8 30007008: e1a0300b mov r3, fp 3000700c: e3a01001 mov r1, #1 30007010: e59f2440 ldr r2, [pc, #1088] ; 30007458 <_Heap_Walk+0x5fc> 30007014: e1a0e00f mov lr, pc 30007018: e12fff1a bx sl 3000701c: e1a00009 mov r0, r9 30007020: eaffffa0 b 30006ea8 <_Heap_Walk+0x4c>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
30007024: e1a00008 mov r0, r8 30007028: e1a03005 mov r3, r5 3000702c: e3a01001 mov r1, #1 30007030: e59f2424 ldr r2, [pc, #1060] ; 3000745c <_Heap_Walk+0x600> 30007034: e1a0e00f mov lr, pc 30007038: e12fff1a bx sl 3000703c: e1a00006 mov r0, r6 30007040: eaffff98 b 30006ea8 <_Heap_Walk+0x4c>
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
30007044: e1a00008 mov r0, r8 30007048: e3a01001 mov r1, #1 3000704c: e59f240c ldr r2, [pc, #1036] ; 30007460 <_Heap_Walk+0x604> 30007050: e1a0e00f mov lr, pc 30007054: e12fff1a bx sl 30007058: e1a00006 mov r0, r6 3000705c: eaffff91 b 30006ea8 <_Heap_Walk+0x4c>
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
30007060: e5942024 ldr r2, [r4, #36] ; 0x24
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
30007064: e1520009 cmp r2, r9
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
30007068: e58d202c str r2, [sp, #44] ; 0x2c
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
3000706c: 3affffc6 bcc 30006f8c <_Heap_Walk+0x130>
);
return false;
}
if (
30007070: e2890008 add r0, r9, #8 30007074: e1a01003 mov r1, r3 30007078: e58dc01c str ip, [sp, #28] 3000707c: ebffe6e3 bl 30000c10 <__umodsi3> 30007080: e3500000 cmp r0, #0 30007084: e59dc01c ldr ip, [sp, #28]
30007088: 1a0000d1 bne 300073d4 <_Heap_Walk+0x578>
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000708c: e5993004 ldr r3, [r9, #4] 30007090: e3c33001 bic r3, r3, #1 30007094: e0893003 add r3, r9, r3 30007098: e5933004 ldr r3, [r3, #4] 3000709c: e3130001 tst r3, #1
300070a0: 1a0000dc bne 30007418 <_Heap_Walk+0x5bc>
);
return false;
}
if ( free_block->prev != prev_block ) {
300070a4: e599200c ldr r2, [r9, #12] 300070a8: e1540002 cmp r4, r2
300070ac: 1a0000d0 bne 300073f4 <_Heap_Walk+0x598>
300070b0: e58d7030 str r7, [sp, #48] ; 0x30 300070b4: e58db034 str fp, [sp, #52] ; 0x34 300070b8: e59d702c ldr r7, [sp, #44] ; 0x2c 300070bc: e59db028 ldr fp, [sp, #40] ; 0x28 300070c0: e58d502c str r5, [sp, #44] ; 0x2c 300070c4: e58d6028 str r6, [sp, #40] ; 0x28 300070c8: e1a0600c mov r6, ip 300070cc: ea000011 b 30007118 <_Heap_Walk+0x2bc> 300070d0: e1590006 cmp r9, r6
300070d4: 3affffac bcc 30006f8c <_Heap_Walk+0x130>
300070d8: e1570009 cmp r7, r9
);
return false;
}
if (
300070dc: e2890008 add r0, r9, #8 300070e0: e1a0100b mov r1, fp
300070e4: 3affffa8 bcc 30006f8c <_Heap_Walk+0x130>
300070e8: ebffe6c8 bl 30000c10 <__umodsi3> 300070ec: e3500000 cmp r0, #0
300070f0: 1a0000b7 bne 300073d4 <_Heap_Walk+0x578>
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
300070f4: e5993004 ldr r3, [r9, #4] 300070f8: e3c33001 bic r3, r3, #1 300070fc: e0833009 add r3, r3, r9 30007100: e5933004 ldr r3, [r3, #4] 30007104: e3130001 tst r3, #1
30007108: 1a0000c2 bne 30007418 <_Heap_Walk+0x5bc>
);
return false;
}
if ( free_block->prev != prev_block ) {
3000710c: e599200c ldr r2, [r9, #12] 30007110: e1520005 cmp r2, r5
30007114: 1a0000b6 bne 300073f4 <_Heap_Walk+0x598>
(*printer)(
30007118: e1a05009 mov r5, r9
return false;
}
prev_block = free_block;
free_block = free_block->next;
3000711c: e5999008 ldr r9, [r9, #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 ) {
30007120: e1540009 cmp r4, r9
30007124: 1affffe9 bne 300070d0 <_Heap_Walk+0x274>
30007128: e28d502c add r5, sp, #44 ; 0x2c
3000712c: e89508a0 ldm r5, {r5, r7, fp}
30007130: e59d6028 ldr r6, [sp, #40] ; 0x28
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
}
while ( block != last_block ) {
30007134: e59d3024 ldr r3, [sp, #36] ; 0x24 30007138: e1530005 cmp r3, r5
"block 0x%08x: prev 0x%08x%s, next 0x%08x%s\n",
block,
block->prev,
block->prev == first_free_block ?
" (= first)"
: (block->prev == free_list_head ? " (= head)" : ""),
3000713c: 158db028 strne fp, [sp, #40] ; 0x28
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
}
while ( block != last_block ) {
30007140: 0affff57 beq 30006ea4 <_Heap_Walk+0x48>
- 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;
30007144: e3c77001 bic r7, r7, #1
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;
if ( prev_used ) {
30007148: e21610ff ands r1, r6, #255 ; 0xff
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000714c: e0876005 add r6, r7, r5
30007150: 0a000012 beq 300071a0 <_Heap_Walk+0x344>
(*printer)(
30007154: e1a03005 mov r3, r5 30007158: e58d7000 str r7, [sp] 3000715c: e1a00008 mov r0, r8 30007160: e3a01000 mov r1, #0 30007164: e59f22f8 ldr r2, [pc, #760] ; 30007464 <_Heap_Walk+0x608> 30007168: e1a0e00f mov lr, pc 3000716c: e12fff1a bx sl
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
30007170: e5943020 ldr r3, [r4, #32] 30007174: e1530006 cmp r3, r6
30007178: 9a000013 bls 300071cc <_Heap_Walk+0x370>
block->prev_size
);
}
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
(*printer)(
3000717c: e1a00008 mov r0, r8 30007180: e58d6000 str r6, [sp] 30007184: e1a03005 mov r3, r5 30007188: e3a01001 mov r1, #1 3000718c: e59f22d4 ldr r2, [pc, #724] ; 30007468 <_Heap_Walk+0x60c> 30007190: e1a0e00f mov lr, pc 30007194: e12fff1a bx sl 30007198: e3a00000 mov r0, #0
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
3000719c: eaffff41 b 30006ea8 <_Heap_Walk+0x4c>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
300071a0: e58d7000 str r7, [sp] 300071a4: e5953000 ldr r3, [r5] 300071a8: e1a00008 mov r0, r8 300071ac: e58d3004 str r3, [sp, #4] 300071b0: e59f22b4 ldr r2, [pc, #692] ; 3000746c <_Heap_Walk+0x610> 300071b4: e1a03005 mov r3, r5 300071b8: e1a0e00f mov lr, pc 300071bc: e12fff1a bx sl 300071c0: e5943020 ldr r3, [r4, #32] 300071c4: e1530006 cmp r3, r6
300071c8: 8affffeb bhi 3000717c <_Heap_Walk+0x320>
300071cc: e5943024 ldr r3, [r4, #36] ; 0x24 300071d0: e1530006 cmp r3, r6
300071d4: 3affffe8 bcc 3000717c <_Heap_Walk+0x320>
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) ) {
300071d8: e1a00007 mov r0, r7 300071dc: e59d1020 ldr r1, [sp, #32] 300071e0: ebffe68a bl 30000c10 <__umodsi3> 300071e4: e2509000 subs r9, r0, #0
300071e8: 1a000055 bne 30007344 <_Heap_Walk+0x4e8>
);
return false;
}
if ( block_size < min_block_size ) {
300071ec: e59d3028 ldr r3, [sp, #40] ; 0x28 300071f0: e1530007 cmp r3, r7
300071f4: 8a00005b bhi 30007368 <_Heap_Walk+0x50c>
);
return false;
}
if ( next_block_begin <= block_begin ) {
300071f8: e1550006 cmp r5, r6
300071fc: 2a000064 bcs 30007394 <_Heap_Walk+0x538>
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
30007200: e5963004 ldr r3, [r6, #4] 30007204: e3130001 tst r3, #1
30007208: 1a000036 bne 300072e8 <_Heap_Walk+0x48c>
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;
3000720c: e595b004 ldr fp, [r5, #4]
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)(
30007210: e595200c ldr r2, [r5, #12]
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
30007214: e5943008 ldr r3, [r4, #8]
- 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;
30007218: e3cb7001 bic r7, fp, #1
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
3000721c: e1530002 cmp r3, r2
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_last( Heap_Control *heap )
{
return _Heap_Free_list_tail(heap)->prev;
30007220: e594100c ldr r1, [r4, #12]
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
30007224: e0859007 add r9, r5, r7
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
30007228: 059f0240 ldreq r0, [pc, #576] ; 30007470 <_Heap_Walk+0x614>
3000722c: 0a000003 beq 30007240 <_Heap_Walk+0x3e4>
"block 0x%08x: prev 0x%08x%s, next 0x%08x%s\n",
block,
block->prev,
block->prev == first_free_block ?
" (= first)"
: (block->prev == free_list_head ? " (= head)" : ""),
30007230: e59fc23c ldr ip, [pc, #572] ; 30007474 <_Heap_Walk+0x618> 30007234: e1520004 cmp r2, r4 30007238: e59f0238 ldr r0, [pc, #568] ; 30007478 <_Heap_Walk+0x61c> 3000723c: 11a0000c movne r0, 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)(
30007240: e5953008 ldr r3, [r5, #8] 30007244: e1510003 cmp r1, r3 30007248: 059f122c ldreq r1, [pc, #556] ; 3000747c <_Heap_Walk+0x620>
3000724c: 0a000003 beq 30007260 <_Heap_Walk+0x404>
" (= first)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last)"
: (block->next == free_list_tail ? " (= tail)" : "")
30007250: e59fc21c ldr ip, [pc, #540] ; 30007474 <_Heap_Walk+0x618> 30007254: e1530004 cmp r3, r4 30007258: e59f1220 ldr r1, [pc, #544] ; 30007480 <_Heap_Walk+0x624> 3000725c: 11a0100c movne 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)(
30007260: e58d2000 str r2, [sp]
30007264: e98d0009 stmib sp, {r0, r3}
30007268: e58d100c str r1, [sp, #12]
3000726c: e1a03005 mov r3, r5
30007270: e1a00008 mov r0, r8
30007274: e3a01000 mov r1, #0
30007278: e59f2204 ldr r2, [pc, #516] ; 30007484 <_Heap_Walk+0x628>
3000727c: e1a0e00f mov lr, pc
30007280: e12fff1a bx sl
block->next == last_free_block ?
" (= last)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
30007284: e5993000 ldr r3, [r9] 30007288: e1570003 cmp r7, r3
3000728c: 0a00000a beq 300072bc <_Heap_Walk+0x460>
(*printer)(
30007290: e58d3004 str r3, [sp, #4] 30007294: e1a00008 mov r0, r8 30007298: e58d7000 str r7, [sp] 3000729c: e58d9008 str r9, [sp, #8] 300072a0: e1a03005 mov r3, r5 300072a4: e3a01001 mov r1, #1 300072a8: e59f21d8 ldr r2, [pc, #472] ; 30007488 <_Heap_Walk+0x62c> 300072ac: e1a0e00f mov lr, pc 300072b0: e12fff1a bx sl 300072b4: e3a00000 mov r0, #0 300072b8: eafffefa b 30006ea8 <_Heap_Walk+0x4c>
);
return false;
}
if ( !prev_used ) {
300072bc: e21b9001 ands r9, fp, #1
300072c0: 0a000017 beq 30007324 <_Heap_Walk+0x4c8>
300072c4: 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 ) {
300072c8: e1530004 cmp r3, r4
300072cc: 1a000003 bne 300072e0 <_Heap_Walk+0x484>
300072d0: ea00000b b 30007304 <_Heap_Walk+0x4a8> <== NOT EXECUTED
if ( free_block == block ) {
return true;
}
free_block = free_block->next;
300072d4: 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 ) {
300072d8: e1530004 cmp r3, r4
300072dc: 0a000008 beq 30007304 <_Heap_Walk+0x4a8>
if ( free_block == block ) {
300072e0: e1530005 cmp r3, r5
300072e4: 1afffffa bne 300072d4 <_Heap_Walk+0x478>
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
}
while ( block != last_block ) {
300072e8: e59d2024 ldr r2, [sp, #36] ; 0x24 300072ec: e1520006 cmp r2, r6
300072f0: 0afffeeb beq 30006ea4 <_Heap_Walk+0x48>
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 ) {
300072f4: e5967004 ldr r7, [r6, #4] 300072f8: e1a05006 mov r5, r6 300072fc: e2076001 and r6, r7, #1 30007300: eaffff8f b 30007144 <_Heap_Walk+0x2e8>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
30007304: e1a00008 mov r0, r8 30007308: e1a03005 mov r3, r5 3000730c: e3a01001 mov r1, #1 30007310: e59f2174 ldr r2, [pc, #372] ; 3000748c <_Heap_Walk+0x630> 30007314: e1a0e00f mov lr, pc 30007318: e12fff1a bx sl 3000731c: e3a00000 mov r0, #0 30007320: eafffee0 b 30006ea8 <_Heap_Walk+0x4c>
return false;
}
if ( !prev_used ) {
(*printer)(
30007324: e1a00008 mov r0, r8 30007328: e1a03005 mov r3, r5 3000732c: e3a01001 mov r1, #1 30007330: e59f2158 ldr r2, [pc, #344] ; 30007490 <_Heap_Walk+0x634> 30007334: e1a0e00f mov lr, pc 30007338: e12fff1a bx sl 3000733c: e1a00009 mov r0, r9 30007340: eafffed8 b 30006ea8 <_Heap_Walk+0x4c>
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) ) {
(*printer)(
30007344: e1a00008 mov r0, r8 30007348: e58d7000 str r7, [sp] 3000734c: e1a03005 mov r3, r5 30007350: e3a01001 mov r1, #1 30007354: e59f2138 ldr r2, [pc, #312] ; 30007494 <_Heap_Walk+0x638> 30007358: e1a0e00f mov lr, pc 3000735c: e12fff1a bx sl 30007360: e3a00000 mov r0, #0
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
30007364: eafffecf b 30006ea8 <_Heap_Walk+0x4c>
}
if ( block_size < min_block_size ) {
(*printer)(
30007368: e58d3004 str r3, [sp, #4] 3000736c: e1a00008 mov r0, r8 30007370: e1a0b003 mov fp, r3 30007374: e58d7000 str r7, [sp] 30007378: e1a03005 mov r3, r5 3000737c: e3a01001 mov r1, #1 30007380: e59f2110 ldr r2, [pc, #272] ; 30007498 <_Heap_Walk+0x63c> 30007384: e1a0e00f mov lr, pc 30007388: e12fff1a bx sl 3000738c: e1a00009 mov r0, r9
block,
block_size,
min_block_size
);
return false;
30007390: eafffec4 b 30006ea8 <_Heap_Walk+0x4c>
}
if ( next_block_begin <= block_begin ) {
(*printer)(
30007394: e1a00008 mov r0, r8 30007398: e58d6000 str r6, [sp] 3000739c: e1a03005 mov r3, r5 300073a0: e3a01001 mov r1, #1 300073a4: e59f20f0 ldr r2, [pc, #240] ; 3000749c <_Heap_Walk+0x640> 300073a8: e1a0e00f mov lr, pc 300073ac: e12fff1a bx sl 300073b0: e1a00009 mov r0, r9
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
300073b4: eafffebb b 30006ea8 <_Heap_Walk+0x4c>
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
300073b8: e1a00008 mov r0, r8 300073bc: e3a01001 mov r1, #1 300073c0: e59f20d8 ldr r2, [pc, #216] ; 300074a0 <_Heap_Walk+0x644> 300073c4: e1a0e00f mov lr, pc 300073c8: e12fff1a bx sl 300073cc: e1a00009 mov r0, r9 300073d0: eafffeb4 b 30006ea8 <_Heap_Walk+0x4c>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
300073d4: e1a00008 mov r0, r8 300073d8: e1a03009 mov r3, r9 300073dc: e3a01001 mov r1, #1 300073e0: e59f20bc ldr r2, [pc, #188] ; 300074a4 <_Heap_Walk+0x648> 300073e4: e1a0e00f mov lr, pc 300073e8: e12fff1a bx sl 300073ec: e3a00000 mov r0, #0 300073f0: eafffeac b 30006ea8 <_Heap_Walk+0x4c>
return false;
}
if ( free_block->prev != prev_block ) {
(*printer)(
300073f4: e58d2000 str r2, [sp] 300073f8: e1a00008 mov r0, r8 300073fc: e1a03009 mov r3, r9 30007400: e3a01001 mov r1, #1 30007404: e59f209c ldr r2, [pc, #156] ; 300074a8 <_Heap_Walk+0x64c> 30007408: e1a0e00f mov lr, pc 3000740c: e12fff1a bx sl 30007410: e3a00000 mov r0, #0 30007414: eafffea3 b 30006ea8 <_Heap_Walk+0x4c>
return false;
}
if ( _Heap_Is_used( free_block ) ) {
(*printer)(
30007418: e1a00008 mov r0, r8 3000741c: e1a03009 mov r3, r9 30007420: e3a01001 mov r1, #1 30007424: e59f2080 ldr r2, [pc, #128] ; 300074ac <_Heap_Walk+0x650> 30007428: e1a0e00f mov lr, pc 3000742c: e12fff1a bx sl 30007430: e3a00000 mov r0, #0 30007434: eafffe9b b 30006ea8 <_Heap_Walk+0x4c>
30006344 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
30006344: 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 )
30006348: e5908034 ldr r8, [r0, #52] ; 0x34
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
3000634c: e24dd014 sub sp, sp, #20
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
30006350: e3580000 cmp r8, #0
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
30006354: e1a05000 mov r5, r0
/*
* Search for a free block of indexes. The block variable ends up set
* to block_count + 1 if the table needs to be extended.
*/
minimum_index = _Objects_Get_index( information->minimum_id );
30006358: e1d070b8 ldrh r7, [r0, #8]
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
3000635c: 0a00009c beq 300065d4 <_Objects_Extend_information+0x290>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
30006360: e1d091b4 ldrh r9, [r0, #20] 30006364: e1d0a1b0 ldrh sl, [r0, #16] 30006368: e1a01009 mov r1, r9 3000636c: e1a0000a mov r0, sl 30006370: eb003ef6 bl 30015f50 <__aeabi_uidiv> 30006374: e1a03800 lsl r3, r0, #16
for ( ; block < block_count; block++ ) {
30006378: e1b03823 lsrs r3, r3, #16 3000637c: 01a01009 moveq r1, r9 30006380: 01a06007 moveq r6, r7 30006384: 01a04003 moveq r4, r3
30006388: 0a00000f beq 300063cc <_Objects_Extend_information+0x88>
if ( information->object_blocks[ block ] == NULL )
3000638c: e5984000 ldr r4, [r8] 30006390: e3540000 cmp r4, #0 30006394: 11a01009 movne r1, r9 30006398: 11a06007 movne r6, r7 3000639c: 13a04000 movne r4, #0 300063a0: 01a01009 moveq r1, r9 300063a4: 01a06007 moveq r6, r7
300063a8: 1a000003 bne 300063bc <_Objects_Extend_information+0x78>
300063ac: ea000006 b 300063cc <_Objects_Extend_information+0x88> <== NOT EXECUTED
300063b0: e7982104 ldr r2, [r8, r4, lsl #2] 300063b4: e3520000 cmp r2, #0
300063b8: 0a000003 beq 300063cc <_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++ ) {
300063bc: e2844001 add r4, r4, #1 300063c0: e1530004 cmp r3, r4
if ( information->object_blocks[ block ] == NULL )
break;
else
index_base += information->allocation_size;
300063c4: e0866009 add r6, r6, r9
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
300063c8: 8afffff8 bhi 300063b0 <_Objects_Extend_information+0x6c>
else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
300063cc: 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 ) {
300063d0: e35a0801 cmp sl, #65536 ; 0x10000
300063d4: 2a000064 bcs 3000656c <_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 ) {
300063d8: e5d50012 ldrb r0, [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;
300063dc: e5952018 ldr r2, [r5, #24]
if ( information->auto_extend ) {
300063e0: e3500000 cmp r0, #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;
300063e4: e0000192 mul r0, r2, r1
if ( information->auto_extend ) {
300063e8: 1a000061 bne 30006574 <_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 );
300063ec: e58d3000 str r3, [sp] 300063f0: eb000811 bl 3000843c <_Workspace_Allocate_or_fatal_error> 300063f4: e59d3000 ldr r3, [sp] 300063f8: e1a09000 mov r9, r0
}
/*
* If the index_base is the maximum we need to grow the tables.
*/
if (index_base >= information->maximum ) {
300063fc: e1d521b0 ldrh r2, [r5, #16] 30006400: e1560002 cmp r6, r2
30006404: 3a000038 bcc 300064ec <_Objects_Extend_information+0x1a8>
*/
/*
* Up the block count and maximum
*/
block_count++;
30006408: e283c001 add ip, r3, #1
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
3000640c: e08c008c add r0, ip, ip, lsl #1
30006410: e08a0000 add r0, sl, r0
30006414: e0800007 add r0, r0, r7
30006418: e1a00100 lsl r0, r0, #2
3000641c: e88d1008 stm sp, {r3, ip}
30006420: eb000811 bl 3000846c <_Workspace_Allocate>
if ( !object_blocks ) {
30006424: e250b000 subs fp, r0, #0
30006428: e89d1008 ldm sp, {r3, ip}
3000642c: 0a00006e beq 300065ec <_Objects_Extend_information+0x2a8>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
30006430: e1d521b0 ldrh r2, [r5, #16]
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
30006434: e08b818c add r8, fp, ip, lsl #3 30006438: e1570002 cmp r7, r2 3000643c: e08bc10c add ip, fp, ip, lsl #2
30006440: 3a000051 bcc 3000658c <_Objects_Extend_information+0x248>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
30006444: e3570000 cmp r7, #0
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
30006448: 13a02000 movne r2, #0
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
local_table[ index ] = NULL;
3000644c: 11a01002 movne r1, r2
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
30006450: 0a000003 beq 30006464 <_Objects_Extend_information+0x120>
local_table[ index ] = NULL;
30006454: e7881102 str r1, [r8, r2, lsl #2]
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
30006458: e2822001 add r2, r2, #1 3000645c: e1570002 cmp r7, r2
30006460: 8afffffb bhi 30006454 <_Objects_Extend_information+0x110>
30006464: 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 );
30006468: e1d511b4 ldrh r1, [r5, #20]
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
3000646c: e3a00000 mov r0, #0
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
30006470: 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 ;
30006474: e1560001 cmp r6, r1
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
30006478: e78c0003 str r0, [ip, r3]
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
3000647c: e78b0003 str r0, [fp, r3]
inactive_per_block[block_count] = 0;
for ( index=index_base ;
30006480: 2a000005 bcs 3000649c <_Objects_Extend_information+0x158>
30006484: e0882106 add r2, r8, r6, lsl #2 30006488: e1a03006 mov r3, r6
index < ( information->allocation_size + index_base );
index++ ) {
3000648c: 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 ;
30006490: e1530001 cmp r3, r1
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
30006494: 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 ;
30006498: 3afffffb bcc 3000648c <_Objects_Extend_information+0x148>
3000649c: e10f3000 mrs r3, CPSR 300064a0: e3832080 orr r2, r3, #128 ; 0x80 300064a4: e129f002 msr CPSR_fc, r2
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(
300064a8: e5952000 ldr r2, [r5] 300064ac: e1d510b4 ldrh r1, [r5, #4] 300064b0: e1a02c02 lsl r2, r2, #24
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
300064b4: e1a0a80a lsl sl, sl, #16
information->maximum_id = _Objects_Build_id(
300064b8: e3822801 orr r2, r2, #65536 ; 0x10000
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;
300064bc: e1a0a82a lsr sl, sl, #16
information->maximum_id = _Objects_Build_id(
300064c0: e1822d81 orr r2, r2, r1, lsl #27 300064c4: e182200a orr r2, r2, sl
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
300064c8: e5950034 ldr r0, [r5, #52] ; 0x34
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
300064cc: e585c030 str ip, [r5, #48] ; 0x30
information->local_table = local_table;
300064d0: e585801c str r8, [r5, #28]
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
300064d4: e585200c str r2, [r5, #12]
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;
300064d8: e1c5a1b0 strh sl, [r5, #16]
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
300064dc: e585b034 str fp, [r5, #52] ; 0x34
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
300064e0: e129f003 msr CPSR_fc, r3
information->maximum
);
_ISR_Enable( level );
if ( old_tables )
300064e4: e3500000 cmp r0, #0
_Workspace_Free( old_tables );
300064e8: 1b0007e5 blne 30008484 <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
300064ec: e5953034 ldr r3, [r5, #52] ; 0x34
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
300064f0: e28d7008 add r7, sp, #8
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
300064f4: e7839104 str r9, [r3, r4, lsl #2]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
300064f8: e1a01009 mov r1, r9 300064fc: e1a00007 mov r0, r7 30006500: e1d521b4 ldrh r2, [r5, #20] 30006504: e5953018 ldr r3, [r5, #24] 30006508: eb000fa4 bl 3000a3a0 <_Chain_Initialize>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
3000650c: e1a04104 lsl r4, r4, #2
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
30006510: 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 ) {
30006514: ea000008 b 3000653c <_Objects_Extend_information+0x1f8>
the_object->id = _Objects_Build_id(
30006518: e5952000 ldr r2, [r5] 3000651c: e1d5c0b4 ldrh ip, [r5, #4] 30006520: e1a02c02 lsl r2, r2, #24 30006524: e3822801 orr r2, r2, #65536 ; 0x10000 30006528: e1822d8c orr r2, r2, ip, lsl #27 3000652c: e1822006 orr r2, r2, r6 30006530: e5832008 str r2, [r3, #8]
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
30006534: ebfffd19 bl 300059a0 <_Chain_Append>
index++;
30006538: 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 ) {
3000653c: e1a00007 mov r0, r7 30006540: ebfffd21 bl 300059cc <_Chain_Get> 30006544: e2503000 subs r3, r0, #0
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
30006548: e1a01003 mov r1, r3 3000654c: e1a00008 mov r0, r8
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
30006550: 1afffff0 bne 30006518 <_Objects_Extend_information+0x1d4>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
30006554: e1d531b4 ldrh r3, [r5, #20]
information->inactive =
30006558: e1d522bc ldrh r2, [r5, #44] ; 0x2c
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
3000655c: e5951030 ldr r1, [r5, #48] ; 0x30
information->inactive =
30006560: e0832002 add r2, r3, r2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
30006564: e7813004 str r3, [r1, r4]
information->inactive =
30006568: e1c522bc strh r2, [r5, #44] ; 0x2c
(Objects_Maximum)(information->inactive + information->allocation_size);
}
3000656c: e28dd014 add sp, sp, #20
30006570: 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 );
30006574: e58d3000 str r3, [sp] 30006578: eb0007bb bl 3000846c <_Workspace_Allocate>
if ( !new_object_block )
3000657c: e2509000 subs r9, r0, #0 30006580: e59d3000 ldr r3, [sp]
30006584: 1affff9c bne 300063fc <_Objects_Extend_information+0xb8>
30006588: eafffff7 b 3000656c <_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,
3000658c: e1a03103 lsl r3, r3, #2
30006590: e1a02003 mov r2, r3
30006594: e5951034 ldr r1, [r5, #52] ; 0x34
30006598: e88d1008 stm sp, {r3, ip}
3000659c: eb001af6 bl 3000d17c <memcpy>
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
300065a0: e89d1008 ldm sp, {r3, ip}
300065a4: e1a0000c mov r0, ip
300065a8: e1a02003 mov r2, r3
300065ac: e5951030 ldr r1, [r5, #48] ; 0x30
300065b0: eb001af1 bl 3000d17c <memcpy>
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
300065b4: e1d521b0 ldrh r2, [r5, #16]
300065b8: e1a00008 mov r0, r8
300065bc: e0872002 add r2, r7, r2
300065c0: e1a02102 lsl r2, r2, #2
300065c4: e595101c ldr r1, [r5, #28]
300065c8: eb001aeb bl 3000d17c <memcpy>
300065cc: e89d1008 ldm sp, {r3, ip}
300065d0: eaffffa4 b 30006468 <_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 )
300065d4: e1a04008 mov r4, r8 300065d8: e1d0a1b0 ldrh sl, [r0, #16] 300065dc: e1d011b4 ldrh r1, [r0, #20] 300065e0: e1a06007 mov r6, r7 300065e4: e1a03008 mov r3, r8 300065e8: eaffff77 b 300063cc <_Objects_Extend_information+0x88>
(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 );
300065ec: e1a00009 mov r0, r9 300065f0: eb0007a3 bl 30008484 <_Workspace_Free>
return;
300065f4: eaffffdc b 3000656c <_Objects_Extend_information+0x228>
30007614 <_Thread_queue_Enqueue_priority>:
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
30007614: 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
)
{
30007618: e92d05f0 push {r4, r5, r6, r7, r8, sl}
_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 ];
3000761c: e1a0c323 lsr ip, r3, #6
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
30007620: e281503c add r5, r1, #60 ; 0x3c 30007624: e08cc08c add ip, ip, ip, lsl #1
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
30007628: e3130020 tst r3, #32
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
3000762c: e2814038 add r4, r1, #56 ; 0x38
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
30007630: e5815038 str r5, [r1, #56] ; 0x38
the_chain->permanent_null = NULL;
30007634: e3a05000 mov r5, #0 30007638: e581503c str r5, [r1, #60] ; 0x3c
the_chain->last = _Chain_Head(the_chain);
3000763c: e5814040 str r4, [r1, #64] ; 0x40
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
30007640: e080c10c add ip, r0, ip, lsl #2
block_state = the_thread_queue->state;
30007644: e5906038 ldr r6, [r0, #56] ; 0x38 30007648: 159fa178 ldrne sl, [pc, #376] ; 300077c8 <_Thread_queue_Enqueue_priority+0x1b4>
if ( _Thread_queue_Is_reverse_search( priority ) )
3000764c: 1a00001c bne 300076c4 <_Thread_queue_Enqueue_priority+0xb0>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
30007650: e28ca004 add sl, ip, #4
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30007654: e10f8000 mrs r8, CPSR 30007658: e3884080 orr r4, r8, #128 ; 0x80 3000765c: e129f004 msr CPSR_fc, r4
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
30007660: e59c4000 ldr r4, [ip]
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
30007664: e154000a cmp r4, sl
30007668: 1a000009 bne 30007694 <_Thread_queue_Enqueue_priority+0x80>
3000766c: ea000052 b 300077bc <_Thread_queue_Enqueue_priority+0x1a8>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
30007670: e10f7000 mrs r7, CPSR 30007674: e129f008 msr CPSR_fc, r8 30007678: e129f007 msr CPSR_fc, r7
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) ) {
3000767c: e5947010 ldr r7, [r4, #16] 30007680: e1160007 tst r6, r7
30007684: 0a000033 beq 30007758 <_Thread_queue_Enqueue_priority+0x144>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
30007688: e5944000 ldr r4, [r4]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
3000768c: e154000a cmp r4, sl
30007690: 0a000002 beq 300076a0 <_Thread_queue_Enqueue_priority+0x8c>
search_priority = search_thread->current_priority;
30007694: e5945014 ldr r5, [r4, #20]
if ( priority <= search_priority )
30007698: e1530005 cmp r3, r5
3000769c: 8afffff3 bhi 30007670 <_Thread_queue_Enqueue_priority+0x5c>
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
300076a0: e1a06008 mov r6, r8
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
300076a4: e590c030 ldr ip, [r0, #48] ; 0x30 300076a8: e35c0001 cmp ip, #1
300076ac: 0a00002b beq 30007760 <_Thread_queue_Enqueue_priority+0x14c> * 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;
300076b0: e5826000 str r6, [r2]
return the_thread_queue->sync_state;
300076b4: e1a0000c mov r0, ip
}
300076b8: e8bd05f0 pop {r4, r5, r6, r7, r8, sl}
300076bc: e12fff1e bx lr
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
300076c0: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
300076c4: e5da5000 ldrb r5, [sl] 300076c8: e2855001 add r5, r5, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
300076cc: e10f8000 mrs r8, CPSR 300076d0: e3884080 orr r4, r8, #128 ; 0x80 300076d4: e129f004 msr CPSR_fc, r4
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
300076d8: e59c4008 ldr r4, [ip, #8]
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
300076dc: e154000c cmp r4, ip
300076e0: 1a000009 bne 3000770c <_Thread_queue_Enqueue_priority+0xf8>
300076e4: ea00000b b 30007718 <_Thread_queue_Enqueue_priority+0x104>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
300076e8: e10f7000 mrs r7, CPSR 300076ec: e129f008 msr CPSR_fc, r8 300076f0: e129f007 msr CPSR_fc, r7
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) ) {
300076f4: e5947010 ldr r7, [r4, #16] 300076f8: e1160007 tst r6, r7
300076fc: 0affffef beq 300076c0 <_Thread_queue_Enqueue_priority+0xac>
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
30007700: e5944004 ldr r4, [r4, #4]
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
30007704: e154000c cmp r4, ip
30007708: 0a000002 beq 30007718 <_Thread_queue_Enqueue_priority+0x104>
search_priority = search_thread->current_priority;
3000770c: e5945014 ldr r5, [r4, #20]
if ( priority >= search_priority )
30007710: e1530005 cmp r3, r5
30007714: 3afffff3 bcc 300076e8 <_Thread_queue_Enqueue_priority+0xd4>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
30007718: e590c030 ldr ip, [r0, #48] ; 0x30
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
3000771c: e1a06008 mov r6, r8
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
30007720: e35c0001 cmp ip, #1
30007724: 1affffe1 bne 300076b0 <_Thread_queue_Enqueue_priority+0x9c>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
30007728: e1530005 cmp r3, r5
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000772c: e3a03000 mov r3, #0 30007730: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
30007734: 0a000016 beq 30007794 <_Thread_queue_Enqueue_priority+0x180>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
30007738: e5943000 ldr r3, [r4]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
3000773c: e8810018 stm r1, {r3, r4}
search_node->next = the_node; next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
30007740: e5810044 str r0, [r1, #68] ; 0x44
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;
30007744: e5841000 str r1, [r4]
next_node->previous = the_node;
30007748: e5831004 str r1, [r3, #4]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3000774c: e129f008 msr CPSR_fc, r8 30007750: e3a00001 mov r0, #1
the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30007754: eaffffd7 b 300076b8 <_Thread_queue_Enqueue_priority+0xa4>
30007758: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED 3000775c: eaffffbc b 30007654 <_Thread_queue_Enqueue_priority+0x40> <== NOT EXECUTED
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
30007760: e1530005 cmp r3, r5
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
30007764: e3a03000 mov r3, #0 30007768: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
3000776c: 0a000008 beq 30007794 <_Thread_queue_Enqueue_priority+0x180>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
30007770: e5943004 ldr r3, [r4, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
30007774: e5814000 str r4, [r1]
the_node->previous = previous_node;
30007778: e5813004 str r3, [r1, #4]
previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
3000777c: e5810044 str r0, [r1, #68] ; 0x44
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
previous_node->next = the_node;
30007780: e5831000 str r1, [r3]
search_node->previous = the_node;
30007784: e5841004 str r1, [r4, #4] 30007788: e129f008 msr CPSR_fc, r8 3000778c: e3a00001 mov r0, #1
the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30007790: eaffffc8 b 300076b8 <_Thread_queue_Enqueue_priority+0xa4> 30007794: e284403c add r4, r4, #60 ; 0x3c
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
30007798: e5943004 ldr r3, [r4, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
3000779c: e5814000 str r4, [r1]
the_node->previous = previous_node;
300077a0: e5813004 str r3, [r1, #4]
previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
300077a4: e5810044 str r0, [r1, #68] ; 0x44
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
previous_node->next = the_node;
300077a8: e5831000 str r1, [r3]
search_node->previous = the_node;
300077ac: e5841004 str r1, [r4, #4] 300077b0: e129f006 msr CPSR_fc, r6 300077b4: e3a00001 mov r0, #1
the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
300077b8: eaffffbe b 300076b8 <_Thread_queue_Enqueue_priority+0xa4>
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
300077bc: e1a06008 mov r6, r8 300077c0: e3e05000 mvn r5, #0 300077c4: eaffffb6 b 300076a4 <_Thread_queue_Enqueue_priority+0x90>
30016270 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
30016270: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30016274: e24dd024 sub sp, sp, #36 ; 0x24
30016278: e1a04000 mov r4, r0
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
3001627c: e3a03000 mov r3, #0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
30016280: e28d0018 add r0, sp, #24 30016284: e28d700c add r7, sp, #12 30016288: e280a004 add sl, r0, #4 3001628c: e2872004 add r2, r7, #4
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
30016290: e58d301c str r3, [sp, #28]
the_chain->last = _Chain_Head(the_chain);
30016294: e58d0020 str r0, [sp, #32]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
30016298: e58d3010 str r3, [sp, #16]
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
3001629c: e2840040 add r0, r4, #64 ; 0x40
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
300162a0: e2843008 add r3, r4, #8 300162a4: e59f91ac ldr r9, [pc, #428] ; 30016458 <_Timer_server_Body+0x1e8> 300162a8: e59fb1ac ldr fp, [pc, #428] ; 3001645c <_Timer_server_Body+0x1ec>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
300162ac: e58d2000 str r2, [sp]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
300162b0: e58da018 str sl, [sp, #24] 300162b4: e58d200c str r2, [sp, #12]
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
300162b8: e58d7014 str r7, [sp, #20]
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
300162bc: e2846030 add r6, r4, #48 ; 0x30
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
300162c0: e2848068 add r8, r4, #104 ; 0x68
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
300162c4: e98d0009 stmib sp, {r0, r3}
{
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
300162c8: e28d2018 add r2, sp, #24 300162cc: e5842078 str r2, [r4, #120] ; 0x78
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
300162d0: e5993000 ldr r3, [r9]
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
300162d4: e594103c ldr r1, [r4, #60] ; 0x3c
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
300162d8: e1a00006 mov r0, r6 300162dc: e0611003 rsb r1, r1, r3
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
300162e0: e584303c str r3, [r4, #60] ; 0x3c
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
300162e4: e1a02007 mov r2, r7 300162e8: eb00109f bl 3001a56c <_Watchdog_Adjust_to_chain>
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
300162ec: e59b5000 ldr r5, [fp]
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
300162f0: e5941074 ldr r1, [r4, #116] ; 0x74
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
300162f4: e1550001 cmp r5, r1
300162f8: 8a000022 bhi 30016388 <_Timer_server_Body+0x118>
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
300162fc: 3a000018 bcc 30016364 <_Timer_server_Body+0xf4>
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
30016300: e5845074 str r5, [r4, #116] ; 0x74
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
30016304: e5940078 ldr r0, [r4, #120] ; 0x78 30016308: eb000248 bl 30016c30 <_Chain_Get>
if ( timer == NULL ) {
3001630c: e3500000 cmp r0, #0
30016310: 0a00000b beq 30016344 <_Timer_server_Body+0xd4>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
30016314: e5903038 ldr r3, [r0, #56] ; 0x38 30016318: e3530001 cmp r3, #1
3001631c: 0a000015 beq 30016378 <_Timer_server_Body+0x108>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
30016320: e3530003 cmp r3, #3
30016324: 1afffff6 bne 30016304 <_Timer_server_Body+0x94>
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
30016328: e2801010 add r1, r0, #16 3001632c: e1a00008 mov r0, r8 30016330: eb0010bc bl 3001a628 <_Watchdog_Insert>
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
30016334: e5940078 ldr r0, [r4, #120] ; 0x78 30016338: eb00023c bl 30016c30 <_Chain_Get>
if ( timer == NULL ) {
3001633c: e3500000 cmp r0, #0
30016340: 1afffff3 bne 30016314 <_Timer_server_Body+0xa4>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30016344: e10f2000 mrs r2, CPSR 30016348: e3823080 orr r3, r2, #128 ; 0x80 3001634c: e129f003 msr CPSR_fc, r3
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
30016350: e59d3018 ldr r3, [sp, #24] 30016354: e15a0003 cmp sl, r3
30016358: 0a00000f beq 3001639c <_Timer_server_Body+0x12c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3001635c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 30016360: eaffffda b 300162d0 <_Timer_server_Body+0x60> <== NOT EXECUTED
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
30016364: e0652001 rsb r2, r5, r1 30016368: e1a00008 mov r0, r8 3001636c: e3a01001 mov r1, #1 30016370: eb00104e bl 3001a4b0 <_Watchdog_Adjust> 30016374: eaffffe1 b 30016300 <_Timer_server_Body+0x90>
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
30016378: e2801010 add r1, r0, #16 3001637c: e1a00006 mov r0, r6 30016380: eb0010a8 bl 3001a628 <_Watchdog_Insert> 30016384: eaffffde b 30016304 <_Timer_server_Body+0x94>
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
30016388: e0611005 rsb r1, r1, r5 3001638c: e1a00008 mov r0, r8 30016390: e1a02007 mov r2, r7 30016394: eb001074 bl 3001a56c <_Watchdog_Adjust_to_chain> 30016398: eaffffd8 b 30016300 <_Timer_server_Body+0x90>
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
3001639c: e5840078 str r0, [r4, #120] ; 0x78 300163a0: e129f002 msr CPSR_fc, r2
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
300163a4: e59d300c ldr r3, [sp, #12] 300163a8: e59d0000 ldr r0, [sp] 300163ac: e1500003 cmp r0, r3 300163b0: 159d5000 ldrne r5, [sp]
300163b4: 1a00000a bne 300163e4 <_Timer_server_Body+0x174>
300163b8: ea000011 b 30016404 <_Timer_server_Body+0x194>
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
300163bc: e5932000 ldr r2, [r3]
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
300163c0: e3a00000 mov r0, #0
the_chain->first = new_first;
300163c4: e58d200c str r2, [sp, #12] 300163c8: e5830008 str r0, [r3, #8]
new_first->previous = _Chain_Head(the_chain);
300163cc: e5827004 str r7, [r2, #4] 300163d0: e129f001 msr CPSR_fc, r1
/*
* The timer server may block here and wait for resources or time.
* The system watchdogs are inactive and will remain inactive since
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
300163d4: e5930020 ldr r0, [r3, #32] 300163d8: e5931024 ldr r1, [r3, #36] ; 0x24 300163dc: e1a0e00f mov lr, pc 300163e0: e593f01c ldr pc, [r3, #28]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
300163e4: e10f1000 mrs r1, CPSR 300163e8: e3813080 orr r3, r1, #128 ; 0x80 300163ec: e129f003 msr CPSR_fc, r3
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
300163f0: e59d300c ldr r3, [sp, #12]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
300163f4: e1550003 cmp r5, r3
300163f8: 1affffef bne 300163bc <_Timer_server_Body+0x14c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
300163fc: e129f001 msr CPSR_fc, r1 30016400: eaffffb0 b 300162c8 <_Timer_server_Body+0x58> 30016404: e59f0054 ldr r0, [pc, #84] ; 30016460 <_Timer_server_Body+0x1f0>
}
} else {
ts->active = false;
30016408: e3a02000 mov r2, #0 3001640c: e5c4207c strb r2, [r4, #124] ; 0x7c 30016410: e5903000 ldr r3, [r0] 30016414: e2833001 add r3, r3, #1 30016418: e5803000 str r3, [r0]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
3001641c: e3a01008 mov r1, #8 30016420: e5940000 ldr r0, [r4] 30016424: eb000db5 bl 30019b00 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
30016428: e1a00004 mov r0, r4 3001642c: ebffff63 bl 300161c0 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
30016430: e1a00004 mov r0, r4 30016434: ebffff77 bl 30016218 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
30016438: eb000b07 bl 3001905c <_Thread_Enable_dispatch>
ts->active = true;
3001643c: e3a02001 mov r2, #1 30016440: e5c4207c strb r2, [r4, #124] ; 0x7c
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
30016444: e59d0008 ldr r0, [sp, #8] 30016448: eb0010e3 bl 3001a7dc <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
3001644c: e59d0004 ldr r0, [sp, #4] 30016450: eb0010e1 bl 3001a7dc <_Watchdog_Remove> 30016454: eaffff9b b 300162c8 <_Timer_server_Body+0x58>
3000a0b8 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
3000a0b8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
3000a0bc: e1a04000 mov r4, r0
3000a0c0: e1a05002 mov r5, r2
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
3000a0c4: e10f3000 mrs r3, CPSR 3000a0c8: e3832080 orr r2, r3, #128 ; 0x80 3000a0cc: e129f002 msr CPSR_fc, r2
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
3000a0d0: e1a07000 mov r7, r0 3000a0d4: 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 ) ) {
3000a0d8: e1520007 cmp r2, r7
3000a0dc: 0a000018 beq 3000a144 <_Watchdog_Adjust+0x8c>
switch ( direction ) {
3000a0e0: e3510000 cmp r1, #0
3000a0e4: 1a000018 bne 3000a14c <_Watchdog_Adjust+0x94>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
3000a0e8: e3550000 cmp r5, #0
3000a0ec: 0a000014 beq 3000a144 <_Watchdog_Adjust+0x8c>
if ( units < _Watchdog_First( header )->delta_interval ) {
3000a0f0: e5926010 ldr r6, [r2, #16] 3000a0f4: e1550006 cmp r5, r6
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000a0f8: 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 ) {
3000a0fc: 2a000005 bcs 3000a118 <_Watchdog_Adjust+0x60>
3000a100: ea000018 b 3000a168 <_Watchdog_Adjust+0xb0> <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
3000a104: e0555006 subs r5, r5, r6
3000a108: 0a00000d beq 3000a144 <_Watchdog_Adjust+0x8c>
if ( units < _Watchdog_First( header )->delta_interval ) {
3000a10c: e5926010 ldr r6, [r2, #16] 3000a110: e1560005 cmp r6, r5
3000a114: 8a000013 bhi 3000a168 <_Watchdog_Adjust+0xb0>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000a118: e5828010 str r8, [r2, #16]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3000a11c: e129f003 msr CPSR_fc, r3
_ISR_Enable( level );
_Watchdog_Tickle( header );
3000a120: e1a00004 mov r0, r4 3000a124: eb0000aa bl 3000a3d4 <_Watchdog_Tickle>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
3000a128: e10f3000 mrs r3, CPSR 3000a12c: e3832080 orr r2, r3, #128 ; 0x80 3000a130: e129f002 msr CPSR_fc, r2 3000a134: e5941000 ldr r1, [r4]
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000a138: e1570001 cmp r7, r1
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) header->first );
3000a13c: e1a02001 mov r2, r1
3000a140: 1affffef bne 3000a104 <_Watchdog_Adjust+0x4c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3000a144: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
3000a148: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
3000a14c: e3510001 cmp r1, #1
3000a150: 1afffffb bne 3000a144 <_Watchdog_Adjust+0x8c>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
3000a154: e5921010 ldr r1, [r2, #16] 3000a158: e0815005 add r5, r1, r5 3000a15c: e5825010 str r5, [r2, #16] 3000a160: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
3000a164: 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;
3000a168: e0655006 rsb r5, r5, r6 3000a16c: e5825010 str r5, [r2, #16]
break;
3000a170: eafffff3 b 3000a144 <_Watchdog_Adjust+0x8c>
30007408 <rtems_io_register_driver>:
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
30007408: e59fc144 ldr ip, [pc, #324] ; 30007554 <rtems_io_register_driver+0x14c>
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;
3000740c: e59f3144 ldr r3, [pc, #324] ; 30007558 <rtems_io_register_driver+0x150>
if ( rtems_interrupt_is_in_progress() )
30007410: e59cc000 ldr ip, [ip]
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
)
{
30007414: e92d4010 push {r4, lr}
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
30007418: e35c0000 cmp ip, #0
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
3000741c: e1a04000 mov r4, r0
rtems_device_major_number major_limit = _IO_Number_of_drivers;
30007420: e5930000 ldr r0, [r3]
if ( rtems_interrupt_is_in_progress() )
30007424: 13a00012 movne r0, #18
30007428: 18bd8010 popne {r4, pc}
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
3000742c: e3520000 cmp r2, #0
30007430: 0a00003c beq 30007528 <rtems_io_register_driver+0x120>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
30007434: e3510000 cmp r1, #0
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
30007438: e5820000 str r0, [r2]
if ( driver_table == NULL )
3000743c: 0a000039 beq 30007528 <rtems_io_register_driver+0x120>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
30007440: e591c000 ldr ip, [r1] 30007444: e35c0000 cmp ip, #0
30007448: 0a000033 beq 3000751c <rtems_io_register_driver+0x114>
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
3000744c: e1500004 cmp r0, r4
30007450: 93a0000a movls r0, #10
30007454: 98bd8010 popls {r4, pc}
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30007458: e59f00fc ldr r0, [pc, #252] ; 3000755c <rtems_io_register_driver+0x154> 3000745c: e590c000 ldr ip, [r0] 30007460: e28cc001 add ip, ip, #1 30007464: e580c000 str ip, [r0]
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
30007468: e3540000 cmp r4, #0
3000746c: 1a000020 bne 300074f4 <rtems_io_register_driver+0xec>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
30007470: e593e000 ldr lr, [r3]
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
30007474: e35e0000 cmp lr, #0
30007478: 0a00002c beq 30007530 <rtems_io_register_driver+0x128>
3000747c: e59f30dc ldr r3, [pc, #220] ; 30007560 <rtems_io_register_driver+0x158> 30007480: e593c000 ldr ip, [r3] 30007484: e1a0300c mov r3, ip 30007488: ea000003 b 3000749c <rtems_io_register_driver+0x94> 3000748c: e2844001 add r4, r4, #1 30007490: e15e0004 cmp lr, r4 30007494: e2833018 add r3, r3, #24
30007498: 9a000005 bls 300074b4 <rtems_io_register_driver+0xac>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000749c: e5930000 ldr r0, [r3] 300074a0: e3500000 cmp r0, #0
300074a4: 1afffff8 bne 3000748c <rtems_io_register_driver+0x84>
300074a8: e5930004 ldr r0, [r3, #4] 300074ac: e3500000 cmp r0, #0
300074b0: 1afffff5 bne 3000748c <rtems_io_register_driver+0x84>
}
/* Assigns invalid value in case of failure */
*major = m;
if ( m != n )
300074b4: e15e0004 cmp lr, r4 300074b8: 10843084 addne r3, r4, r4, lsl #1
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
300074bc: e5824000 str r4, [r2]
if ( m != n )
300074c0: 108cc183 addne ip, ip, r3, lsl #3
300074c4: 0a00001a beq 30007534 <rtems_io_register_driver+0x12c>
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
300074c8: e1a0e001 mov lr, r1
300074cc: e8be000f ldm lr!, {r0, r1, r2, r3}
300074d0: e8ac000f stmia ip!, {r0, r1, r2, r3}
300074d4: e89e0003 ldm lr, {r0, r1}
300074d8: e88c0003 stm ip, {r0, r1}
_Thread_Enable_dispatch();
300074dc: eb0006a1 bl 30008f68 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
300074e0: e3a01000 mov r1, #0 300074e4: e1a00004 mov r0, r4 300074e8: e1a02001 mov r2, r1
}
300074ec: e8bd4010 pop {r4, lr}
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
300074f0: ea0021b3 b 3000fbc4 <rtems_io_initialize>
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
300074f4: e59f3064 ldr r3, [pc, #100] ; 30007560 <rtems_io_register_driver+0x158> 300074f8: e084c084 add ip, r4, r4, lsl #1 300074fc: e5933000 ldr r3, [r3]
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
30007500: e793018c ldr r0, [r3, ip, lsl #3]
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
30007504: e083c18c add ip, r3, ip, lsl #3
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
30007508: e3500000 cmp r0, #0
3000750c: 0a00000b beq 30007540 <rtems_io_register_driver+0x138>
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();
30007510: eb000694 bl 30008f68 <_Thread_Enable_dispatch> 30007514: e3a0000c mov r0, #12
return RTEMS_RESOURCE_IN_USE;
30007518: e8bd8010 pop {r4, pc}
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000751c: e591c004 ldr ip, [r1, #4] 30007520: e35c0000 cmp ip, #0
30007524: 1affffc8 bne 3000744c <rtems_io_register_driver+0x44>
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
30007528: e3a00009 mov r0, #9
}
3000752c: e8bd8010 pop {r4, pc}
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
30007530: 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();
30007534: eb00068b bl 30008f68 <_Thread_Enable_dispatch> 30007538: e3a00005 mov r0, #5
return sc;
3000753c: e8bd8010 pop {r4, pc}
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
30007540: e59c3004 ldr r3, [ip, #4] 30007544: e3530000 cmp r3, #0
30007548: 1afffff0 bne 30007510 <rtems_io_register_driver+0x108>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
3000754c: e5824000 str r4, [r2] 30007550: eaffffdc b 300074c8 <rtems_io_register_driver+0xc0>