RTEMS-6
Annotated Report
score
Sun Feb 28 23:37:39 2021
00108ef0 <_CORE_message_queue_Broadcast>:
const void *buffer,
size_t size,
uint32_t *count,
Thread_queue_Context *queue_context
)
{
108ef0: e92d 4ff8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}
108ef4: 469b mov fp, r3
Thread_Control *the_thread;
uint32_t number_broadcasted;
if ( size > the_message_queue->maximum_message_size ) {
108ef6: 6983 ldr r3, [r0, #24]
{
108ef8: f8dd 8028 ldr.w r8, [sp, #40] ; 0x28
if ( size > the_message_queue->maximum_message_size ) {
108efc: 4293 cmp r3, r2
108efe: d331 bcc.n 108f64 <_CORE_message_queue_Broadcast+0x74>
*
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
108f00: 6946 ldr r6, [r0, #20]
108f02: 4605 mov r5, r0
108f04: 2e00 cmp r6, #0
108f06: d135 bne.n 108f74 <_CORE_message_queue_Broadcast+0x84>
108f08: 4617 mov r7, r2
108f0a: 4689 mov r9, r1
if ( the_thread == NULL ) {
return NULL;
}
*(size_t *) the_thread->Wait.return_argument = size;
the_thread->Wait.count = (uint32_t) submit_type;
108f0c: 46b2 mov sl, r6
RTEMS_INLINE_ROUTINE Thread_Control *_Thread_queue_First_locked(
Thread_queue_Control *the_thread_queue,
const Thread_queue_Operations *operations
)
{
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
108f0e: 6828 ldr r0, [r5, #0]
the_thread = _Thread_queue_First_locked(
108f10: 68eb ldr r3, [r5, #12]
if ( heads != NULL ) {
108f12: b1f0 cbz r0, 108f52 <_CORE_message_queue_Broadcast+0x62>
return ( *operations->first )( heads );
108f14: 691b ldr r3, [r3, #16]
108f16: 4798 blx r3
memcpy(destination, source, size);
108f18: 4649 mov r1, r9
108f1a: 463a mov r2, r7
if ( the_thread == NULL ) {
108f1c: 4604 mov r4, r0
108f1e: b1c0 cbz r0, 108f52 <_CORE_message_queue_Broadcast+0x62>
memcpy(destination, source, size);
108f20: e9d0 3010 ldrd r3, r0, [r0, #64] ; 0x40
0,
queue_context
)
)
) {
number_broadcasted += 1;
108f24: 3601 adds r6, #1
*(size_t *) the_thread->Wait.return_argument = size;
108f26: 601f str r7, [r3, #0]
the_thread->Wait.count = (uint32_t) submit_type;
108f28: f8c4 a03c str.w sl, [r4, #60] ; 0x3c
memcpy(destination, source, size);
108f2c: f006 ec08 blx 10f740 <memcpy>
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
_Thread_queue_Extract_critical(
108f30: 68e9 ldr r1, [r5, #12]
108f32: 4643 mov r3, r8
108f34: 4622 mov r2, r4
108f36: 4628 mov r0, r5
108f38: f001 fa9c bl 10a474 <_Thread_queue_Extract_critical>
__asm__ volatile (
108f3c: f3ef 8300 mrs r3, CPSR
108f40: f043 0280 orr.w r2, r3, #128 ; 0x80
108f44: f382 8900 msr CPSR_fc, r2
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
108f48: f8c8 3000 str.w r3, [r8]
if ( the_message_queue->number_of_pending_messages != 0 ) {
108f4c: 696b ldr r3, [r5, #20]
108f4e: 2b00 cmp r3, #0
108f50: d0dd beq.n 108f0e <_CORE_message_queue_Broadcast+0x1e> <== NEVER TAKEN
__asm__ volatile (
108f52: f8d8 3000 ldr.w r3, [r8]
108f56: f383 8900 msr CPSR_fc, r3
}
_CORE_message_queue_Release( the_message_queue, queue_context );
*count = number_broadcasted;
return STATUS_SUCCESSFUL;
108f5a: 2000 movs r0, #0
*count = number_broadcasted;
108f5c: f8cb 6000 str.w r6, [fp]
}
108f60: e8bd 8ff8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
108f64: f8d8 3000 ldr.w r3, [r8]
108f68: f383 8900 msr CPSR_fc, r3
return STATUS_MESSAGE_INVALID_SIZE;
108f6c: f647 2008 movw r0, #31240 ; 0x7a08
}
108f70: e8bd 8ff8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
number_broadcasted = 0;
108f74: 2600 movs r6, #0
108f76: e7ec b.n 108f52 <_CORE_message_queue_Broadcast+0x62>
00108bb8 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
108bb8: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
108bbc: 460f mov r7, r1
108bbe: 4699 mov r9, r3
108bc0: 3104 adds r1, #4
108bc2: bf2c ite cs
108bc4: 2601 movcs r6, #1
108bc6: 2600 movcc r6, #0
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
108bc8: 6903 ldr r3, [r0, #16]
{
108bca: b089 sub sp, #36 ; 0x24
108bcc: 9101 str r1, [sp, #4]
uintptr_t const page_size = heap->page_size;
108bce: 9303 str r3, [sp, #12]
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
108bd0: 2e00 cmp r6, #0
108bd2: f040 80c9 bne.w 108d68 <_Heap_Allocate_aligned_with_boundary+0x1b0>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
108bd6: 4680 mov r8, r0
108bd8: 4693 mov fp, r2
108bda: f1b9 0f00 cmp.w r9, #0
108bde: f040 80ba bne.w 108d56 <_Heap_Allocate_aligned_with_boundary+0x19e>
*
* @return The first block of the free list.
*/
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
108be2: f8d8 5008 ldr.w r5, [r8, #8]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
108be6: 45a8 cmp r8, r5
108be8: f000 80a6 beq.w 108d38 <_Heap_Allocate_aligned_with_boundary+0x180>
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
108bec: 9b03 ldr r3, [sp, #12]
108bee: 3307 adds r3, #7
108bf0: 9304 str r3, [sp, #16]
uintptr_t alloc_begin = alloc_end - alloc_size;
108bf2: f1c7 0304 rsb r3, r7, #4
108bf6: 9305 str r3, [sp, #20]
uintptr_t const free_size = alloc_block_begin - block_begin;
108bf8: 465b mov r3, fp
108bfa: 46b3 mov fp, r6
108bfc: 461e mov r6, r3
108bfe: e006 b.n 108c0e <_Heap_Allocate_aligned_with_boundary+0x56>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
108c00: 9b02 ldr r3, [sp, #8]
108c02: 2b00 cmp r3, #0
108c04: d175 bne.n 108cf2 <_Heap_Allocate_aligned_with_boundary+0x13a> <== NEVER TAKEN
break;
}
block = block->next;
108c06: 68ad ldr r5, [r5, #8]
while ( block != free_list_tail ) {
108c08: 45a8 cmp r8, r5
108c0a: f000 8094 beq.w 108d36 <_Heap_Allocate_aligned_with_boundary+0x17e>
if ( block->size_and_flag > block_size_floor ) {
108c0e: 6869 ldr r1, [r5, #4]
++search_count;
108c10: f10b 0b01 add.w fp, fp, #1
if ( block->size_and_flag > block_size_floor ) {
108c14: 9b01 ldr r3, [sp, #4]
108c16: 4299 cmp r1, r3
108c18: d9f5 bls.n 108c06 <_Heap_Allocate_aligned_with_boundary+0x4e>
*/
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
108c1a: f105 0308 add.w r3, r5, #8
108c1e: 9302 str r3, [sp, #8]
if ( alignment == 0 ) {
108c20: 2e00 cmp r6, #0
108c22: d0ed beq.n 108c00 <_Heap_Allocate_aligned_with_boundary+0x48>
uintptr_t alloc_begin = alloc_end - alloc_size;
108c24: 9a05 ldr r2, [sp, #20]
*
* @return The block size.
*/
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
108c26: f021 0a01 bic.w sl, r1, #1
uintptr_t const block_end = block_begin + block_size;
108c2a: eb0a 0c05 add.w ip, sl, r5
108c2e: f8d8 3014 ldr.w r3, [r8, #20]
return value - (value % alignment);
108c32: 4631 mov r1, r6
uintptr_t alloc_begin = alloc_end - alloc_size;
108c34: eb02 040c add.w r4, r2, ip
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
108c38: 9a04 ldr r2, [sp, #16]
108c3a: 4620 mov r0, r4
108c3c: 9306 str r3, [sp, #24]
108c3e: eba2 0a03 sub.w sl, r2, r3
108c42: 44e2 add sl, ip
108c44: f007 fb46 bl 1102d4 <__aeabi_uidivmod>
108c48: 1a64 subs r4, r4, r1
if ( alloc_begin > alloc_begin_ceiling ) {
108c4a: 45a2 cmp sl, r4
108c4c: d205 bcs.n 108c5a <_Heap_Allocate_aligned_with_boundary+0xa2>
108c4e: 4631 mov r1, r6
108c50: 4650 mov r0, sl
108c52: f007 fb3f bl 1102d4 <__aeabi_uidivmod>
108c56: ebaa 0401 sub.w r4, sl, r1
if ( boundary != 0 ) {
108c5a: f1b9 0f00 cmp.w r9, #0
108c5e: d02f beq.n 108cc0 <_Heap_Allocate_aligned_with_boundary+0x108>
alloc_end = alloc_begin + alloc_size;
108c60: eb07 0a04 add.w sl, r7, r4
108c64: 4649 mov r1, r9
108c66: 4650 mov r0, sl
108c68: f007 fb34 bl 1102d4 <__aeabi_uidivmod>
108c6c: ebaa 0101 sub.w r1, sl, r1
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
108c70: 9b02 ldr r3, [sp, #8]
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
108c72: 458a cmp sl, r1
108c74: bf94 ite ls
108c76: 2000 movls r0, #0
108c78: 2001 movhi r0, #1
108c7a: 428c cmp r4, r1
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
108c7c: 443b add r3, r7
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
108c7e: bf28 it cs
108c80: 2000 movcs r0, #0
108c82: b1e8 cbz r0, 108cc0 <_Heap_Allocate_aligned_with_boundary+0x108>
if ( boundary_line < boundary_floor ) {
108c84: 428b cmp r3, r1
108c86: bf9c itt ls
108c88: 469a movls sl, r3
108c8a: 9507 strls r5, [sp, #28]
108c8c: d902 bls.n 108c94 <_Heap_Allocate_aligned_with_boundary+0xdc>
108c8e: e7ba b.n 108c06 <_Heap_Allocate_aligned_with_boundary+0x4e>
108c90: 458a cmp sl, r1
108c92: d867 bhi.n 108d64 <_Heap_Allocate_aligned_with_boundary+0x1ac> <== ALWAYS TAKEN
alloc_begin = boundary_line - alloc_size;
108c94: 1bcc subs r4, r1, r7
108c96: 4631 mov r1, r6
108c98: 4620 mov r0, r4
108c9a: f007 fb1b bl 1102d4 <__aeabi_uidivmod>
108c9e: 1a64 subs r4, r4, r1
108ca0: 4649 mov r1, r9
alloc_end = alloc_begin + alloc_size;
108ca2: 193d adds r5, r7, r4
108ca4: 4628 mov r0, r5
108ca6: f007 fb15 bl 1102d4 <__aeabi_uidivmod>
108caa: 1a69 subs r1, r5, r1
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
108cac: 428c cmp r4, r1
108cae: bf2c ite cs
108cb0: 2200 movcs r2, #0
108cb2: 2201 movcc r2, #1
108cb4: 428d cmp r5, r1
108cb6: bf98 it ls
108cb8: 2200 movls r2, #0
108cba: 2a00 cmp r2, #0
108cbc: d1e8 bne.n 108c90 <_Heap_Allocate_aligned_with_boundary+0xd8>
108cbe: 9d07 ldr r5, [sp, #28]
if ( alloc_begin >= alloc_begin_floor ) {
108cc0: 9b02 ldr r3, [sp, #8]
108cc2: 429c cmp r4, r3
108cc4: d39f bcc.n 108c06 <_Heap_Allocate_aligned_with_boundary+0x4e>
uintptr_t const free_size = alloc_block_begin - block_begin;
108cc6: f64f 73f8 movw r3, #65528 ; 0xfff8
108cca: 9903 ldr r1, [sp, #12]
108ccc: f6cf 73ff movt r3, #65535 ; 0xffff
108cd0: 4620 mov r0, r4
108cd2: 1b5b subs r3, r3, r5
108cd4: eb03 0a04 add.w sl, r3, r4
108cd8: f007 fafc bl 1102d4 <__aeabi_uidivmod>
if ( free_size >= min_block_size || free_size == 0 ) {
108cdc: 9a06 ldr r2, [sp, #24]
uintptr_t const free_size = alloc_block_begin - block_begin;
108cde: ebaa 0301 sub.w r3, sl, r1
if ( free_size >= min_block_size || free_size == 0 ) {
108ce2: 2b00 cmp r3, #0
108ce4: bf18 it ne
108ce6: 429a cmpne r2, r3
108ce8: d88d bhi.n 108c06 <_Heap_Allocate_aligned_with_boundary+0x4e>
108cea: 9402 str r4, [sp, #8]
if ( alloc_begin != 0 ) {
108cec: 9b02 ldr r3, [sp, #8]
108cee: 2b00 cmp r3, #0
108cf0: d089 beq.n 108c06 <_Heap_Allocate_aligned_with_boundary+0x4e> <== ALWAYS TAKEN
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
108cf2: 9c02 ldr r4, [sp, #8]
108cf4: 463b mov r3, r7
108cf6: 4629 mov r1, r5
108cf8: 4640 mov r0, r8
108cfa: 465e mov r6, fp
108cfc: 4622 mov r2, r4
108cfe: f000 f943 bl 108f88 <_Heap_Block_allocate>
boundary
);
/* Statistics */
++stats->allocs;
stats->searches += search_count;
108d02: f8d8 3054 ldr.w r3, [r8, #84] ; 0x54
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
108d06: 6842 ldr r2, [r0, #4]
/* Statistics */
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
108d08: 4620 mov r0, r4
++stats->allocs;
108d0a: f8d8 1058 ldr.w r1, [r8, #88] ; 0x58
stats->searches += search_count;
108d0e: 445b add r3, fp
108d10: f8c8 3054 str.w r3, [r8, #84] ; 0x54
108d14: f022 0201 bic.w r2, r2, #1
stats->lifetime_allocated += _Heap_Block_size( block );
108d18: f8d8 3028 ldr.w r3, [r8, #40] ; 0x28
++stats->allocs;
108d1c: 3101 adds r1, #1
108d1e: f8c8 1058 str.w r1, [r8, #88] ; 0x58
stats->lifetime_allocated += _Heap_Block_size( block );
108d22: 189b adds r3, r3, r2
108d24: f8c8 3028 str.w r3, [r8, #40] ; 0x28
108d28: f8d8 302c ldr.w r3, [r8, #44] ; 0x2c
108d2c: f143 0300 adc.w r3, r3, #0
108d30: f8c8 302c str.w r3, [r8, #44] ; 0x2c
108d34: e006 b.n 108d44 <_Heap_Allocate_aligned_with_boundary+0x18c>
108d36: 465e mov r6, fp
++stats->failed_allocs;
108d38: f8d8 305c ldr.w r3, [r8, #92] ; 0x5c
108d3c: 2000 movs r0, #0
108d3e: 3301 adds r3, #1
108d40: f8c8 305c str.w r3, [r8, #92] ; 0x5c
if ( stats->max_search < search_count ) {
108d44: f8d8 3050 ldr.w r3, [r8, #80] ; 0x50
108d48: 42b3 cmp r3, r6
stats->max_search = search_count;
108d4a: bf38 it cc
108d4c: f8c8 6050 strcc.w r6, [r8, #80] ; 0x50
}
108d50: b009 add sp, #36 ; 0x24
108d52: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if ( boundary < alloc_size ) {
108d56: 454f cmp r7, r9
108d58: 4630 mov r0, r6
108d5a: d8f9 bhi.n 108d50 <_Heap_Allocate_aligned_with_boundary+0x198>
alignment = page_size;
108d5c: 2a00 cmp r2, #0
108d5e: bf08 it eq
108d60: 469b moveq fp, r3
108d62: e73e b.n 108be2 <_Heap_Allocate_aligned_with_boundary+0x2a>
108d64: 9d07 ldr r5, [sp, #28] <== NOT EXECUTED
108d66: e74e b.n 108c06 <_Heap_Allocate_aligned_with_boundary+0x4e> <== NOT EXECUTED
return NULL;
108d68: 2000 movs r0, #0
}
108d6a: b009 add sp, #36 ; 0x24
108d6c: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0010e6e4 <_Heap_Free>:
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
10e6e4: 2900 cmp r1, #0
10e6e6: d06c beq.n 10e7c2 <_Heap_Free+0xde>
{
10e6e8: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
10e6ec: 4605 mov r5, r0
10e6ee: 4608 mov r0, r1
return value - (value % alignment);
10e6f0: 6929 ldr r1, [r5, #16]
- HEAP_BLOCK_HEADER_SIZE);
10e6f2: f1a0 0408 sub.w r4, r0, #8
return value - (value % alignment);
10e6f6: f001 fded bl 1102d4 <__aeabi_uidivmod>
return (uintptr_t) block >= (uintptr_t) heap->first_block
10e6fa: 6a2a ldr r2, [r5, #32]
- HEAP_BLOCK_HEADER_SIZE);
10e6fc: 1a61 subs r1, r4, r1
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10e6fe: 4291 cmp r1, r2
10e700: d345 bcc.n 10e78e <_Heap_Free+0xaa>
10e702: f8d5 c024 ldr.w ip, [r5, #36] ; 0x24
10e706: 4561 cmp r1, ip
10e708: d841 bhi.n 10e78e <_Heap_Free+0xaa>
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10e70a: 684c ldr r4, [r1, #4]
10e70c: f024 0701 bic.w r7, r4, #1
return (Heap_Block *) ((uintptr_t) block + offset);
10e710: 19cb adds r3, r1, r7
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10e712: 429a cmp r2, r3
10e714: d83b bhi.n 10e78e <_Heap_Free+0xaa> <== ALWAYS TAKEN
10e716: 459c cmp ip, r3
10e718: d339 bcc.n 10e78e <_Heap_Free+0xaa>
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
10e71a: 685e ldr r6, [r3, #4]
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
10e71c: f016 0001 ands.w r0, r6, #1
10e720: d036 beq.n 10e790 <_Heap_Free+0xac> <== ALWAYS TAKEN
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
10e722: 459c cmp ip, r3
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10e724: f026 0601 bic.w r6, r6, #1
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
10e728: f004 0401 and.w r4, r4, #1
10e72c: d026 beq.n 10e77c <_Heap_Free+0x98>
10e72e: eb03 0e06 add.w lr, r3, r6
10e732: f8de e004 ldr.w lr, [lr, #4]
10e736: f01e 0f01 tst.w lr, #1
10e73a: d11f bne.n 10e77c <_Heap_Free+0x98>
if ( !_Heap_Is_prev_used( block ) ) {
10e73c: 2c00 cmp r4, #0
10e73e: d061 beq.n 10e804 <_Heap_Free+0x120>
Heap_Block *prev = old_block->prev;
10e740: e9d3 2302 ldrd r2, r3, [r3, #8]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
10e744: 443e add r6, r7
new_block->prev = prev;
10e746: e9c1 2302 strd r2, r3, [r1, #8]
next->prev = new_block;
10e74a: 60d1 str r1, [r2, #12]
prev->next = new_block;
10e74c: 6099 str r1, [r3, #8]
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10e74e: f046 0301 orr.w r3, r6, #1
10e752: 604b str r3, [r1, #4]
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
10e754: 518e str r6, [r1, r6]
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
10e756: 6cea ldr r2, [r5, #76] ; 0x4c
++stats->frees;
stats->free_size += block_size;
stats->lifetime_freed += block_size;
10e758: 6b2b ldr r3, [r5, #48] ; 0x30
--stats->used_blocks;
10e75a: 3a01 subs r2, #1
10e75c: 64ea str r2, [r5, #76] ; 0x4c
stats->lifetime_freed += block_size;
10e75e: 19db adds r3, r3, r7
++stats->frees;
10e760: 6e2a ldr r2, [r5, #96] ; 0x60
stats->lifetime_freed += block_size;
10e762: 632b str r3, [r5, #48] ; 0x30
stats->free_size += block_size;
10e764: 6beb ldr r3, [r5, #60] ; 0x3c
++stats->frees;
10e766: f102 0201 add.w r2, r2, #1
10e76a: 662a str r2, [r5, #96] ; 0x60
stats->lifetime_freed += block_size;
10e76c: 6b6a ldr r2, [r5, #52] ; 0x34
stats->free_size += block_size;
10e76e: 443b add r3, r7
10e770: 63eb str r3, [r5, #60] ; 0x3c
stats->lifetime_freed += block_size;
10e772: f142 0200 adc.w r2, r2, #0
10e776: 636a str r2, [r5, #52] ; 0x34
return( true );
}
10e778: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
if ( !_Heap_Is_prev_used( block ) ) {
10e77c: bb1c cbnz r4, 10e7c6 <_Heap_Free+0xe2>
uintptr_t const prev_size = block->prev_size;
10e77e: f8d1 e000 ldr.w lr, [r1]
return (Heap_Block *) ((uintptr_t) block + offset);
10e782: eba1 080e sub.w r8, r1, lr
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10e786: 4590 cmp r8, r2
10e788: d301 bcc.n 10e78e <_Heap_Free+0xaa> <== ALWAYS TAKEN
10e78a: 45e0 cmp r8, ip
10e78c: d902 bls.n 10e794 <_Heap_Free+0xb0> <== NEVER TAKEN
return false;
10e78e: 2000 movs r0, #0
}
10e790: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
10e794: f8d8 2004 ldr.w r2, [r8, #4]
if ( !_Heap_Is_prev_used ( prev_block) ) {
10e798: f012 0201 ands.w r2, r2, #1
10e79c: d0f7 beq.n 10e78e <_Heap_Free+0xaa> <== ALWAYS TAKEN
uintptr_t const size = block_size + prev_size + next_block_size;
10e79e: eb0e 0207 add.w r2, lr, r7
if ( next_is_free ) { /* coalesce both */
10e7a2: b32c cbz r4, 10e7f0 <_Heap_Free+0x10c>
Heap_Block *prev = block->prev;
10e7a4: e9d3 1302 ldrd r1, r3, [r3, #8]
uintptr_t const size = block_size + prev_size + next_block_size;
10e7a8: 4416 add r6, r2
stats->free_blocks -= 1;
10e7aa: 6c6a ldr r2, [r5, #68] ; 0x44
prev->next = next;
10e7ac: 6099 str r1, [r3, #8]
10e7ae: 3a01 subs r2, #1
next->prev = prev;
10e7b0: 60cb str r3, [r1, #12]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10e7b2: f046 0301 orr.w r3, r6, #1
stats->free_blocks -= 1;
10e7b6: 646a str r2, [r5, #68] ; 0x44
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10e7b8: f8c8 3004 str.w r3, [r8, #4]
next_block->prev_size = size;
10e7bc: f848 6006 str.w r6, [r8, r6]
10e7c0: e7c9 b.n 10e756 <_Heap_Free+0x72>
return true;
10e7c2: 2001 movs r0, #1
}
10e7c4: 4770 bx lr
Heap_Block *next = block_before->next;
10e7c6: 68aa ldr r2, [r5, #8]
new_block->next = next;
10e7c8: e9c1 2502 strd r2, r5, [r1, #8]
block_before->next = new_block;
10e7cc: 60a9 str r1, [r5, #8]
next->prev = new_block;
10e7ce: 60d1 str r1, [r2, #12]
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
10e7d0: f047 0201 orr.w r2, r7, #1
10e7d4: 604a str r2, [r1, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10e7d6: 685c ldr r4, [r3, #4]
++stats->free_blocks;
10e7d8: 6c6a ldr r2, [r5, #68] ; 0x44
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10e7da: f024 0401 bic.w r4, r4, #1
10e7de: 605c str r4, [r3, #4]
++stats->free_blocks;
10e7e0: 3201 adds r2, #1
if ( stats->max_free_blocks < stats->free_blocks ) {
10e7e2: 6cab ldr r3, [r5, #72] ; 0x48
next_block->prev_size = block_size;
10e7e4: 51cf str r7, [r1, r7]
++stats->free_blocks;
10e7e6: 646a str r2, [r5, #68] ; 0x44
if ( stats->max_free_blocks < stats->free_blocks ) {
10e7e8: 429a cmp r2, r3
stats->max_free_blocks = stats->free_blocks;
10e7ea: bf88 it hi
10e7ec: 64aa strhi r2, [r5, #72] ; 0x48
10e7ee: e7b2 b.n 10e756 <_Heap_Free+0x72>
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10e7f0: f042 0401 orr.w r4, r2, #1
10e7f4: f8c8 4004 str.w r4, [r8, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10e7f8: 685c ldr r4, [r3, #4]
10e7fa: f024 0401 bic.w r4, r4, #1
10e7fe: 605c str r4, [r3, #4]
next_block->prev_size = size;
10e800: 51ca str r2, [r1, r7]
10e802: e7a8 b.n 10e756 <_Heap_Free+0x72>
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
10e804: 2401 movs r4, #1
10e806: e7ba b.n 10e77e <_Heap_Free+0x9a>
0010cf90 <_Heap_Get_free_information>:
return _Heap_Free_list_head(heap)->next;
10cf90: 6882 ldr r2, [r0, #8]
void _Heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
)
{
10cf92: b470 push {r4, r5, r6}
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
10cf94: 2400 movs r4, #0
info->largest = 0;
10cf96: e9c1 4400 strd r4, r4, [r1]
info->total = 0;
for(the_block = _Heap_Free_list_first(the_heap);
10cf9a: 4290 cmp r0, r2
info->total = 0;
10cf9c: 608c str r4, [r1, #8]
for(the_block = _Heap_Free_list_first(the_heap);
10cf9e: d012 beq.n 10cfc6 <_Heap_Get_free_information+0x36> <== ALWAYS TAKEN
10cfa0: 2601 movs r6, #1
10cfa2: 4625 mov r5, r4
10cfa4: e001 b.n 10cfaa <_Heap_Get_free_information+0x1a>
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
info->total += the_size;
if ( info->largest < the_size )
10cfa6: 684c ldr r4, [r1, #4]
10cfa8: 4666 mov r6, ip
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10cfaa: 6853 ldr r3, [r2, #4]
for(the_block = _Heap_Free_list_first(the_heap);
10cfac: f106 0c01 add.w ip, r6, #1
the_block = the_block->next)
10cfb0: 6892 ldr r2, [r2, #8]
10cfb2: f023 0301 bic.w r3, r3, #1
if ( info->largest < the_size )
10cfb6: 42a3 cmp r3, r4
info->total += the_size;
10cfb8: 441d add r5, r3
info->largest = the_size;
10cfba: bf88 it hi
10cfbc: 604b strhi r3, [r1, #4]
for(the_block = _Heap_Free_list_first(the_heap);
10cfbe: 4290 cmp r0, r2
10cfc0: d1f1 bne.n 10cfa6 <_Heap_Get_free_information+0x16>
10cfc2: 600e str r6, [r1, #0]
10cfc4: 608d str r5, [r1, #8]
}
}
10cfc6: bc70 pop {r4, r5, r6}
10cfc8: 4770 bx lr
10cfca: bf00 nop
001083fc <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
1083fc: e92d 43f8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
108400: 4605 mov r5, r0
Heap_Block *current;
size_t i;
_Heap_Protection_free_all_delayed_blocks( heap );
for (i = 0; i < block_count; ++i) {
108402: 4617 mov r7, r2
108404: b3b2 cbz r2, 108474 <_Heap_Greedy_allocate+0x78>
108406: 2400 movs r4, #0
108408: f1a1 0804 sub.w r8, r1, #4
Heap_Block *allocated_blocks = NULL;
10840c: 4626 mov r6, r4
* @retval pointer The starting address of the allocated memory area.
* @retval NULL No memory is available of the parameters are inconsistent.
*/
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
10840e: 2300 movs r3, #0
108410: f858 1f04 ldr.w r1, [r8, #4]!
108414: 461a mov r2, r3
108416: 4628 mov r0, r5
108418: f003 f97e bl 10b718 <_Heap_Allocate_aligned_with_boundary>
for (i = 0; i < block_count; ++i) {
10841c: 3401 adds r4, #1
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
10841e: f1a0 0908 sub.w r9, r0, #8
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
108422: b130 cbz r0, 108432 <_Heap_Greedy_allocate+0x36>
return value - (value % alignment);
108424: 6929 ldr r1, [r5, #16]
108426: f005 fa65 bl 10d8f4 <__aeabi_uidivmod>
- HEAP_BLOCK_HEADER_SIZE);
10842a: eba9 0101 sub.w r1, r9, r1
Heap_Block *next_block = _Heap_Block_of_alloc_area(
(uintptr_t) next,
heap->page_size
);
next_block->next = allocated_blocks;
10842e: 608e str r6, [r1, #8]
108430: 460e mov r6, r1
for (i = 0; i < block_count; ++i) {
108432: 42a7 cmp r7, r4
108434: d1eb bne.n 10840e <_Heap_Greedy_allocate+0x12>
return _Heap_Free_list_head(heap)->next;
108436: 68ac ldr r4, [r5, #8]
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
108438: 42a5 cmp r5, r4
10843a: d021 beq.n 108480 <_Heap_Greedy_allocate+0x84>
Heap_Block *blocks = NULL;
10843c: 2700 movs r7, #0
*
* @return The block size.
*/
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10843e: 6863 ldr r3, [r4, #4]
_Heap_Block_allocate(
108440: f104 0208 add.w r2, r4, #8
108444: 4621 mov r1, r4
108446: 4628 mov r0, r5
108448: f023 0301 bic.w r3, r3, #1
10844c: 3b08 subs r3, #8
10844e: f003 fb4b bl 10bae8 <_Heap_Block_allocate>
current,
_Heap_Alloc_area_of_block( current ),
_Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE
);
current->next = blocks;
108452: 60a7 str r7, [r4, #8]
return &heap->free_list;
108454: 4627 mov r7, r4
return _Heap_Free_list_head(heap)->next;
108456: 68ac ldr r4, [r5, #8]
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
108458: 42a5 cmp r5, r4
10845a: d1f0 bne.n 10843e <_Heap_Greedy_allocate+0x42>
blocks = current;
}
while ( allocated_blocks != NULL ) {
10845c: b13e cbz r6, 10846e <_Heap_Greedy_allocate+0x72>
current = allocated_blocks;
allocated_blocks = allocated_blocks->next;
10845e: 4631 mov r1, r6
108460: 68b6 ldr r6, [r6, #8]
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
108462: 3108 adds r1, #8
108464: 4628 mov r0, r5
108466: f003 fcb7 bl 10bdd8 <_Heap_Free>
while ( allocated_blocks != NULL ) {
10846a: 2e00 cmp r6, #0
10846c: d1f7 bne.n 10845e <_Heap_Greedy_allocate+0x62>
}
return blocks;
}
10846e: 4638 mov r0, r7
108470: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
108474: 6884 ldr r4, [r0, #8]
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
108476: 4284 cmp r4, r0
Heap_Block *allocated_blocks = NULL;
108478: bf18 it ne
10847a: 4616 movne r6, r2
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
10847c: d1de bne.n 10843c <_Heap_Greedy_allocate+0x40> <== NEVER TAKEN
10847e: e7f6 b.n 10846e <_Heap_Greedy_allocate+0x72> <== NOT EXECUTED
Heap_Block *blocks = NULL;
108480: 2700 movs r7, #0
108482: e7eb b.n 10845c <_Heap_Greedy_allocate+0x60>
001090cc <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
1090cc: b5f8 push {r3, r4, r5, r6, r7, lr}
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
1090ce: e9d0 4608 ldrd r4, r6, [r0, #32]
bool stop = false;
while ( !stop && current != end ) {
1090d2: 42b4 cmp r4, r6
1090d4: d014 beq.n 109100 <_Heap_Iterate+0x34> <== ALWAYS TAKEN
1090d6: 460d mov r5, r1
1090d8: 4617 mov r7, r2
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
1090da: 6861 ldr r1, [r4, #4]
1090dc: 4620 mov r0, r4
uintptr_t size = _Heap_Block_size( current );
Heap_Block *next = _Heap_Block_at( current, size );
bool used = _Heap_Is_prev_used( next );
stop = (*visitor)( current, size, used, visitor_arg );
1090de: 463b mov r3, r7
1090e0: f021 0101 bic.w r1, r1, #1
return (Heap_Block *) ((uintptr_t) block + offset);
1090e4: 440c add r4, r1
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
1090e6: 6862 ldr r2, [r4, #4]
1090e8: f002 0201 and.w r2, r2, #1
1090ec: 47a8 blx r5
while ( !stop && current != end ) {
1090ee: f080 0001 eor.w r0, r0, #1
1090f2: 42a6 cmp r6, r4
1090f4: bf0c ite eq
1090f6: 2000 moveq r0, #0
1090f8: f000 0001 andne.w r0, r0, #1
1090fc: 2800 cmp r0, #0
1090fe: d1ec bne.n 1090da <_Heap_Iterate+0xe>
current = next;
}
}
109100: bdf8 pop {r3, r4, r5, r6, r7, pc}
109102: bf00 nop
00107a6c <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
107a6c: b570 push {r4, r5, r6, lr}
107a6e: 460c mov r4, r1
107a70: 4605 mov r5, r0
return value - (value % alignment);
107a72: 6901 ldr r1, [r0, #16]
107a74: 4620 mov r0, r4
107a76: 4616 mov r6, r2
107a78: f004 ff28 bl 10c8cc <__aeabi_uidivmod>
return (uintptr_t) block >= (uintptr_t) heap->first_block
107a7c: 6a2a ldr r2, [r5, #32]
- HEAP_BLOCK_HEADER_SIZE);
107a7e: f1a4 0308 sub.w r3, r4, #8
107a82: 1a59 subs r1, r3, r1
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
107a84: 428a cmp r2, r1
107a86: d813 bhi.n 107ab0 <_Heap_Size_of_alloc_area+0x44> <== ALWAYS TAKEN
107a88: 6a68 ldr r0, [r5, #36] ; 0x24
107a8a: 4288 cmp r0, r1
107a8c: d310 bcc.n 107ab0 <_Heap_Size_of_alloc_area+0x44> <== ALWAYS TAKEN
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
107a8e: 684b ldr r3, [r1, #4]
107a90: f023 0301 bic.w r3, r3, #1
return (Heap_Block *) ((uintptr_t) block + offset);
107a94: 4419 add r1, r3
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
107a96: 428a cmp r2, r1
107a98: d80a bhi.n 107ab0 <_Heap_Size_of_alloc_area+0x44> <== ALWAYS TAKEN
107a9a: 4288 cmp r0, r1
107a9c: d308 bcc.n 107ab0 <_Heap_Size_of_alloc_area+0x44> <== ALWAYS TAKEN
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
107a9e: 6848 ldr r0, [r1, #4]
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
107aa0: f010 0001 ands.w r0, r0, #1
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
107aa4: bf1e ittt ne
107aa6: f1c4 0404 rsbne r4, r4, #4
107aaa: 1909 addne r1, r1, r4
107aac: 6031 strne r1, [r6, #0]
return true;
}
107aae: bd70 pop {r4, r5, r6, pc}
return false;
107ab0: 2000 movs r0, #0 <== NOT EXECUTED
}
107ab2: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
00111300 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
111300: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
111304: f241 23bd movw r3, #4797 ; 0x12bd
111308: f241 24c5 movw r4, #4805 ; 0x12c5
11130c: f2c0 0311 movt r3, #17
111310: f2c0 0411 movt r4, #17
{
111314: b091 sub sp, #68 ; 0x44
_Heap_Walk_print : _Heap_Walk_print_nothing;
111316: 2a00 cmp r2, #0
111318: bf08 it eq
11131a: 461c moveq r4, r3
return _System_state_Current;
11131c: f647 0370 movw r3, #30832 ; 0x7870
111320: f2c0 0320 movt r3, #32
111324: 9408 str r4, [sp, #32]
if ( !_System_state_Is_up( _System_state_Get() ) ) {
111326: 681b ldr r3, [r3, #0]
111328: 2b02 cmp r3, #2
11132a: d004 beq.n 111336 <_Heap_Walk+0x36>
return true;
11132c: 2701 movs r7, #1
block = next_block;
} while ( block != first_block );
return true;
}
11132e: 4638 mov r0, r7
111330: b011 add sp, #68 ; 0x44
111332: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
uintptr_t const min_block_size = heap->min_block_size;
111336: e9d0 b304 ldrd fp, r3, [r0, #16]
11133a: 468a mov sl, r1
(*printer)(
11133c: f640 5210 movw r2, #3344 ; 0xd10
111340: 4680 mov r8, r0
111342: f2c0 0216 movt r2, #22
111346: 2100 movs r1, #0
111348: 9300 str r3, [sp, #0]
Heap_Block *const first_block = heap->first_block;
11134a: 6a05 ldr r5, [r0, #32]
uintptr_t const min_block_size = heap->min_block_size;
11134c: 930c str r3, [sp, #48] ; 0x30
(*printer)(
11134e: 9503 str r5, [sp, #12]
Heap_Block *const last_block = heap->last_block;
111350: 6a43 ldr r3, [r0, #36] ; 0x24
(*printer)(
111352: 9304 str r3, [sp, #16]
Heap_Block *const last_block = heap->last_block;
111354: 930a str r3, [sp, #40] ; 0x28
(*printer)(
111356: 68c3 ldr r3, [r0, #12]
111358: 9306 str r3, [sp, #24]
11135a: 6883 ldr r3, [r0, #8]
11135c: 9305 str r3, [sp, #20]
11135e: 69c3 ldr r3, [r0, #28]
111360: 9302 str r3, [sp, #8]
111362: 6983 ldr r3, [r0, #24]
111364: 4650 mov r0, sl
111366: 9301 str r3, [sp, #4]
111368: 465b mov r3, fp
11136a: 47a0 blx r4
if ( page_size == 0 ) {
11136c: f1bb 0f00 cmp.w fp, #0
111370: d04e beq.n 111410 <_Heap_Walk+0x110>
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
111372: f01b 0607 ands.w r6, fp, #7
(*printer)(
111376: bf1e ittt ne
111378: f640 52b8 movwne r2, #3512 ; 0xdb8
11137c: 465b movne r3, fp
11137e: f2c0 0216 movtne r2, #22
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
111382: d13f bne.n 111404 <_Heap_Walk+0x104>
return (value % alignment) == 0;
111384: 980c ldr r0, [sp, #48] ; 0x30
111386: 4659 mov r1, fp
111388: f01f fd38 bl 130dfc <__aeabi_uidivmod>
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
11138c: 460f mov r7, r1
11138e: 2900 cmp r1, #0
111390: d154 bne.n 11143c <_Heap_Walk+0x13c>
111392: 4659 mov r1, fp
111394: f105 0008 add.w r0, r5, #8
111398: f01f fd30 bl 130dfc <__aeabi_uidivmod>
if (
11139c: 460b mov r3, r1
11139e: 2900 cmp r1, #0
1113a0: d157 bne.n 111452 <_Heap_Walk+0x152>
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
1113a2: 686f ldr r7, [r5, #4]
if ( !_Heap_Is_prev_used( first_block ) ) {
1113a4: f017 0701 ands.w r7, r7, #1
1113a8: d03f beq.n 11142a <_Heap_Walk+0x12a>
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
1113aa: 990a ldr r1, [sp, #40] ; 0x28
1113ac: 684a ldr r2, [r1, #4]
1113ae: f022 0201 bic.w r2, r2, #1
return (Heap_Block *) ((uintptr_t) block + offset);
1113b2: 188a adds r2, r1, r2
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
1113b4: 6854 ldr r4, [r2, #4]
return (Heap_Block *) ((uintptr_t) block + offset);
1113b6: 920b str r2, [sp, #44] ; 0x2c
if ( _Heap_Is_free( last_block ) ) {
1113b8: f014 0701 ands.w r7, r4, #1
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
1113bc: f004 0901 and.w r9, r4, #1
1113c0: d051 beq.n 111466 <_Heap_Walk+0x166>
if (
1113c2: 9a0b ldr r2, [sp, #44] ; 0x2c
1113c4: 4295 cmp r5, r2
1113c6: d009 beq.n 1113dc <_Heap_Walk+0xdc>
(*printer)(
1113c8: f640 6278 movw r2, #3704 ; 0xe78
return false;
1113cc: 461f mov r7, r3
(*printer)(
1113ce: 2101 movs r1, #1
1113d0: 9b08 ldr r3, [sp, #32]
1113d2: f2c0 0216 movt r2, #22
1113d6: 4650 mov r0, sl
1113d8: 4798 blx r3
return false;
1113da: e7a8 b.n 11132e <_Heap_Walk+0x2e>
return _Heap_Free_list_head(heap)->next;
1113dc: f8d8 5008 ldr.w r5, [r8, #8]
uintptr_t const page_size = heap->page_size;
1113e0: f8d8 2010 ldr.w r2, [r8, #16]
return (uintptr_t) block >= (uintptr_t) heap->first_block
1113e4: f8d8 3020 ldr.w r3, [r8, #32]
while ( free_block != free_list_tail ) {
1113e8: 45a8 cmp r8, r5
1113ea: f000 8184 beq.w 1116f6 <_Heap_Walk+0x3f6>
1113ee: 9409 str r4, [sp, #36] ; 0x24
1113f0: 4646 mov r6, r8
1113f2: 461f mov r7, r3
1113f4: 4614 mov r4, r2
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
1113f6: 42bd cmp r5, r7
1113f8: d23e bcs.n 111478 <_Heap_Walk+0x178>
(*printer)(
1113fa: f241 029c movw r2, #4252 ; 0x109c
1113fe: 462b mov r3, r5
111400: f2c0 0216 movt r2, #22
111404: 9c08 ldr r4, [sp, #32]
111406: 2101 movs r1, #1
111408: 4650 mov r0, sl
return false;
11140a: 2700 movs r7, #0
(*printer)(
11140c: 47a0 blx r4
return false;
11140e: e78e b.n 11132e <_Heap_Walk+0x2e>
(*printer)( source, true, "page size is zero\n" );
111410: f640 52a4 movw r2, #3492 ; 0xda4
111414: 4650 mov r0, sl
111416: 9b08 ldr r3, [sp, #32]
111418: 2101 movs r1, #1
11141a: f2c0 0216 movt r2, #22
return false;
11141e: 465f mov r7, fp
(*printer)( source, true, "page size is zero\n" );
111420: 4798 blx r3
}
111422: 4638 mov r0, r7
111424: b011 add sp, #68 ; 0x44
111426: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
(*printer)(
11142a: f640 6230 movw r2, #3632 ; 0xe30
11142e: 9b08 ldr r3, [sp, #32]
111430: 2101 movs r1, #1
111432: f2c0 0216 movt r2, #22
111436: 4650 mov r0, sl
111438: 4798 blx r3
return false;
11143a: e778 b.n 11132e <_Heap_Walk+0x2e>
(*printer)(
11143c: f640 52d8 movw r2, #3544 ; 0xdd8
111440: 9b0c ldr r3, [sp, #48] ; 0x30
111442: 9c08 ldr r4, [sp, #32]
111444: f2c0 0216 movt r2, #22
111448: 4650 mov r0, sl
11144a: 2101 movs r1, #1
return false;
11144c: 4637 mov r7, r6
(*printer)(
11144e: 47a0 blx r4
return false;
111450: e76d b.n 11132e <_Heap_Walk+0x2e>
(*printer)(
111452: f640 52fc movw r2, #3580 ; 0xdfc
111456: 9c08 ldr r4, [sp, #32]
111458: 462b mov r3, r5
11145a: f2c0 0216 movt r2, #22
11145e: 4650 mov r0, sl
111460: 2101 movs r1, #1
111462: 47a0 blx r4
return false;
111464: e763 b.n 11132e <_Heap_Walk+0x2e>
(*printer)(
111466: f640 6260 movw r2, #3680 ; 0xe60
11146a: 9b08 ldr r3, [sp, #32]
11146c: 2101 movs r1, #1
11146e: f2c0 0216 movt r2, #22
111472: 4650 mov r0, sl
111474: 4798 blx r3
return false;
111476: e75a b.n 11132e <_Heap_Walk+0x2e>
111478: 6a73 ldr r3, [r6, #36] ; 0x24
return (value % alignment) == 0;
11147a: f105 0008 add.w r0, r5, #8
11147e: 4621 mov r1, r4
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
111480: 42ab cmp r3, r5
111482: d3ba bcc.n 1113fa <_Heap_Walk+0xfa> <== ALWAYS TAKEN
return (value % alignment) == 0;
111484: f01f fcba bl 130dfc <__aeabi_uidivmod>
if (
111488: 2900 cmp r1, #0
11148a: f040 8122 bne.w 1116d2 <_Heap_Walk+0x3d2>
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
11148e: 686b ldr r3, [r5, #4]
111490: f023 0301 bic.w r3, r3, #1
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
111494: 442b add r3, r5
111496: 685b ldr r3, [r3, #4]
if ( _Heap_Is_used( free_block ) ) {
111498: f013 0301 ands.w r3, r3, #1
11149c: f040 810e bne.w 1116bc <_Heap_Walk+0x3bc>
if ( free_block->prev != prev_block ) {
1114a0: 68e9 ldr r1, [r5, #12]
1114a2: 4541 cmp r1, r8
1114a4: 46a8 mov r8, r5
1114a6: f040 811a bne.w 1116de <_Heap_Walk+0x3de>
free_block = free_block->next;
1114aa: 68ad ldr r5, [r5, #8]
while ( free_block != free_list_tail ) {
1114ac: 42ae cmp r6, r5
1114ae: d1a2 bne.n 1113f6 <_Heap_Walk+0xf6>
1114b0: 46b0 mov r8, r6
1114b2: 9c09 ldr r4, [sp, #36] ; 0x24
1114b4: 9e0b ldr r6, [sp, #44] ; 0x2c
1114b6: 463b mov r3, r7
(*printer)(
1114b8: f241 0274 movw r2, #4212 ; 0x1074
1114bc: f2c0 0216 movt r2, #22
1114c0: 920d str r2, [sp, #52] ; 0x34
(*printer)(
1114c2: f241 025c movw r2, #4188 ; 0x105c
1114c6: f2c0 0216 movt r2, #22
1114ca: 920e str r2, [sp, #56] ; 0x38
(*printer)(
1114cc: f640 72b8 movw r2, #4024 ; 0xfb8
1114d0: f2c0 0216 movt r2, #22
1114d4: 920f str r2, [sp, #60] ; 0x3c
1114d6: 461a mov r2, r3
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
1114d8: f024 0401 bic.w r4, r4, #1
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
1114dc: fa5f f989 uxtb.w r9, r9
return (Heap_Block *) ((uintptr_t) block + offset);
1114e0: 1935 adds r5, r6, r4
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
1114e2: 42aa cmp r2, r5
1114e4: d90b bls.n 1114fe <_Heap_Walk+0x1fe> <== NEVER TAKEN
(*printer)(
1114e6: f241 02e8 movw r2, #4328 ; 0x10e8
1114ea: 9c08 ldr r4, [sp, #32]
1114ec: 4633 mov r3, r6
1114ee: f2c0 0216 movt r2, #22
1114f2: 4650 mov r0, sl
1114f4: 2101 movs r1, #1
1114f6: 9500 str r5, [sp, #0]
return false;
1114f8: 2700 movs r7, #0
(*printer)(
1114fa: 47a0 blx r4
return false;
1114fc: e717 b.n 11132e <_Heap_Walk+0x2e>
1114fe: f8d8 2024 ldr.w r2, [r8, #36] ; 0x24
111502: 42aa cmp r2, r5
111504: d3ef bcc.n 1114e6 <_Heap_Walk+0x1e6>
return (value % alignment) == 0;
111506: 4659 mov r1, fp
111508: 4620 mov r0, r4
11150a: f01f fc77 bl 130dfc <__aeabi_uidivmod>
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
11150e: b1e9 cbz r1, 11154c <_Heap_Walk+0x24c>
111510: 9b0a ldr r3, [sp, #40] ; 0x28
111512: 429e cmp r6, r3
111514: f040 80c4 bne.w 1116a0 <_Heap_Walk+0x3a0>
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
111518: 686f ldr r7, [r5, #4]
if ( !_Heap_Is_prev_used( next_block ) ) {
11151a: f017 0301 ands.w r3, r7, #1
11151e: 9309 str r3, [sp, #36] ; 0x24
111520: d03f beq.n 1115a2 <_Heap_Walk+0x2a2>
} else if (prev_used) {
111522: f1b9 0f00 cmp.w r9, #0
111526: d032 beq.n 11158e <_Heap_Walk+0x28e>
(*printer)(
111528: 9400 str r4, [sp, #0]
11152a: 4633 mov r3, r6
11152c: 9a0e ldr r2, [sp, #56] ; 0x38
11152e: 2100 movs r1, #0
111530: 9c08 ldr r4, [sp, #32]
111532: 4650 mov r0, sl
111534: 47a0 blx r4
} while ( block != first_block );
111536: 9b0b ldr r3, [sp, #44] ; 0x2c
111538: 429d cmp r5, r3
11153a: f43f aef7 beq.w 11132c <_Heap_Walk+0x2c>
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
11153e: 686c ldr r4, [r5, #4]
111540: 462e mov r6, r5
return (uintptr_t) block >= (uintptr_t) heap->first_block
111542: f8d8 2020 ldr.w r2, [r8, #32]
111546: f004 0901 and.w r9, r4, #1
11154a: e7c5 b.n 1114d8 <_Heap_Walk+0x1d8>
bool const is_not_last_block = block != last_block;
11154c: 9b0a ldr r3, [sp, #40] ; 0x28
11154e: 1af2 subs r2, r6, r3
if ( block_size < min_block_size && is_not_last_block ) {
111550: 9b0c ldr r3, [sp, #48] ; 0x30
bool const is_not_last_block = block != last_block;
111552: bf18 it ne
111554: 2201 movne r2, #1
if ( block_size < min_block_size && is_not_last_block ) {
111556: 42a3 cmp r3, r4
111558: bf94 ite ls
11155a: 2300 movls r3, #0
11155c: f002 0301 andhi.w r3, r2, #1
111560: 9309 str r3, [sp, #36] ; 0x24
111562: 2b00 cmp r3, #0
111564: f040 808e bne.w 111684 <_Heap_Walk+0x384>
if ( next_block_begin <= block_begin && is_not_last_block ) {
111568: 42ae cmp r6, r5
11156a: bf34 ite cc
11156c: 2200 movcc r2, #0
11156e: f002 0201 andcs.w r2, r2, #1
111572: 2a00 cmp r2, #0
111574: d0d0 beq.n 111518 <_Heap_Walk+0x218>
(*printer)(
111576: f640 7284 movw r2, #3972 ; 0xf84
11157a: 9c08 ldr r4, [sp, #32]
11157c: 4633 mov r3, r6
11157e: 4650 mov r0, sl
111580: f2c0 0216 movt r2, #22
111584: 2101 movs r1, #1
111586: 9500 str r5, [sp, #0]
111588: 9f09 ldr r7, [sp, #36] ; 0x24
11158a: 47a0 blx r4
return false;
11158c: e6cf b.n 11132e <_Heap_Walk+0x2e>
(*printer)(
11158e: 6832 ldr r2, [r6, #0]
111590: 4649 mov r1, r9
111592: 4633 mov r3, r6
111594: 4650 mov r0, sl
111596: e9cd 4200 strd r4, r2, [sp]
11159a: 9a0d ldr r2, [sp, #52] ; 0x34
11159c: 9c08 ldr r4, [sp, #32]
11159e: 47a0 blx r4
1115a0: e7c9 b.n 111536 <_Heap_Walk+0x236>
(*printer)(
1115a2: 68f0 ldr r0, [r6, #12]
return _Heap_Free_list_tail(heap)->prev;
1115a4: e9d8 2102 ldrd r2, r1, [r8, #8]
1115a8: 4282 cmp r2, r0
1115aa: d058 beq.n 11165e <_Heap_Walk+0x35e>
: (block->prev == free_list_head ? " (= head)" : ""),
1115ac: f640 4ce8 movw ip, #3304 ; 0xce8
1115b0: f648 32ac movw r2, #35756 ; 0x8bac
1115b4: f2c0 0c16 movt ip, #22
1115b8: f2c0 0216 movt r2, #22
1115bc: 4580 cmp r8, r0
1115be: bf08 it eq
1115c0: 4662 moveq r2, ip
(*printer)(
1115c2: 68b3 ldr r3, [r6, #8]
1115c4: 4299 cmp r1, r3
1115c6: d045 beq.n 111654 <_Heap_Walk+0x354>
: (block->next == free_list_tail ? " (= tail)" : "")
1115c8: f640 5104 movw r1, #3332 ; 0xd04
1115cc: f648 3eac movw lr, #35756 ; 0x8bac
1115d0: f2c0 0116 movt r1, #22
1115d4: f2c0 0e16 movt lr, #22
1115d8: 4598 cmp r8, r3
1115da: bf18 it ne
1115dc: 4671 movne r1, lr
(*printer)(
1115de: e9cd 3103 strd r3, r1, [sp, #12]
1115e2: 4633 mov r3, r6
1115e4: e9cd 0201 strd r0, r2, [sp, #4]
1115e8: 2100 movs r1, #0
1115ea: 9a0f ldr r2, [sp, #60] ; 0x3c
1115ec: 4650 mov r0, sl
1115ee: 9f08 ldr r7, [sp, #32]
1115f0: 9400 str r4, [sp, #0]
1115f2: 47b8 blx r7
if ( block_size != next_block->prev_size ) {
1115f4: 682a ldr r2, [r5, #0]
1115f6: 4294 cmp r4, r2
1115f8: d010 beq.n 11161c <_Heap_Walk+0x31c>
(*printer)(
1115fa: 9f09 ldr r7, [sp, #36] ; 0x24
1115fc: 4650 mov r0, sl
1115fe: e9cd 2501 strd r2, r5, [sp, #4]
111602: f640 72f0 movw r2, #4080 ; 0xff0
111606: 9400 str r4, [sp, #0]
111608: 4633 mov r3, r6
11160a: 9c08 ldr r4, [sp, #32]
11160c: f2c0 0216 movt r2, #22
111610: 2101 movs r1, #1
111612: 47a0 blx r4
}
111614: 4638 mov r0, r7
111616: b011 add sp, #68 ; 0x44
111618: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if ( !prev_used ) {
11161c: f1b9 0f00 cmp.w r9, #0
111620: d022 beq.n 111668 <_Heap_Walk+0x368>
return _Heap_Free_list_head(heap)->next;
111622: f8d8 2008 ldr.w r2, [r8, #8]
while ( free_block != free_list_tail ) {
111626: 4590 cmp r8, r2
111628: d046 beq.n 1116b8 <_Heap_Walk+0x3b8> <== ALWAYS TAKEN
if ( free_block == block ) {
11162a: 4296 cmp r6, r2
11162c: bf18 it ne
11162e: 9f09 ldrne r7, [sp, #36] ; 0x24
111630: d103 bne.n 11163a <_Heap_Walk+0x33a>
111632: e780 b.n 111536 <_Heap_Walk+0x236>
111634: 4296 cmp r6, r2
111636: f43f af7e beq.w 111536 <_Heap_Walk+0x236>
free_block = free_block->next;
11163a: 6892 ldr r2, [r2, #8]
while ( free_block != free_list_tail ) {
11163c: 4590 cmp r8, r2
11163e: d1f9 bne.n 111634 <_Heap_Walk+0x334>
(*printer)(
111640: f241 02bc movw r2, #4284 ; 0x10bc
111644: 9c08 ldr r4, [sp, #32]
111646: 4633 mov r3, r6
111648: f2c0 0216 movt r2, #22
11164c: 4650 mov r0, sl
11164e: 2101 movs r1, #1
111650: 47a0 blx r4
return false;
111652: e66c b.n 11132e <_Heap_Walk+0x2e>
(*printer)(
111654: f640 41f4 movw r1, #3316 ; 0xcf4
111658: f2c0 0116 movt r1, #22
11165c: e7bf b.n 1115de <_Heap_Walk+0x2de>
11165e: f640 42d8 movw r2, #3288 ; 0xcd8
111662: f2c0 0216 movt r2, #22
111666: e7ac b.n 1115c2 <_Heap_Walk+0x2c2>
(*printer)(
111668: f241 022c movw r2, #4140 ; 0x102c
11166c: 4650 mov r0, sl
11166e: 9c08 ldr r4, [sp, #32]
111670: 4633 mov r3, r6
111672: f2c0 0216 movt r2, #22
return false;
111676: 464f mov r7, r9
(*printer)(
111678: 2101 movs r1, #1
11167a: 47a0 blx r4
}
11167c: 4638 mov r0, r7
11167e: b011 add sp, #68 ; 0x44
111680: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
(*printer)(
111684: 9b0c ldr r3, [sp, #48] ; 0x30
111686: f640 7258 movw r2, #3928 ; 0xf58
return false;
11168a: 460f mov r7, r1
(*printer)(
11168c: 9400 str r4, [sp, #0]
11168e: 4650 mov r0, sl
111690: 9c08 ldr r4, [sp, #32]
111692: 9301 str r3, [sp, #4]
111694: f2c0 0216 movt r2, #22
111698: 4633 mov r3, r6
11169a: 2101 movs r1, #1
11169c: 47a0 blx r4
return false;
11169e: e646 b.n 11132e <_Heap_Walk+0x2e>
(*printer)(
1116a0: f640 7228 movw r2, #3880 ; 0xf28
1116a4: 9400 str r4, [sp, #0]
1116a6: 4633 mov r3, r6
1116a8: 9c08 ldr r4, [sp, #32]
1116aa: f2c0 0216 movt r2, #22
1116ae: 4650 mov r0, sl
1116b0: 2101 movs r1, #1
return false;
1116b2: 2700 movs r7, #0
(*printer)(
1116b4: 47a0 blx r4
return false;
1116b6: e63a b.n 11132e <_Heap_Walk+0x2e>
1116b8: 9f09 ldr r7, [sp, #36] ; 0x24 <== NOT EXECUTED
1116ba: e7c1 b.n 111640 <_Heap_Walk+0x340> <== NOT EXECUTED
(*printer)(
1116bc: f640 62d8 movw r2, #3800 ; 0xed8
return false;
1116c0: 460f mov r7, r1
(*printer)(
1116c2: 9c08 ldr r4, [sp, #32]
1116c4: 462b mov r3, r5
1116c6: f2c0 0216 movt r2, #22
1116ca: 4650 mov r0, sl
1116cc: 2101 movs r1, #1
1116ce: 47a0 blx r4
return false;
1116d0: e62d b.n 11132e <_Heap_Walk+0x2e>
(*printer)(
1116d2: f640 62a8 movw r2, #3752 ; 0xea8
1116d6: 462b mov r3, r5
1116d8: f2c0 0216 movt r2, #22
1116dc: e692 b.n 111404 <_Heap_Walk+0x104>
(*printer)(
1116de: f640 62f4 movw r2, #3828 ; 0xef4
1116e2: 461f mov r7, r3
1116e4: 9100 str r1, [sp, #0]
1116e6: 462b mov r3, r5
1116e8: 9c08 ldr r4, [sp, #32]
1116ea: 4650 mov r0, sl
1116ec: f2c0 0216 movt r2, #22
1116f0: 2101 movs r1, #1
1116f2: 47a0 blx r4
return false;
1116f4: e61b b.n 11132e <_Heap_Walk+0x2e>
while ( free_block != free_list_tail ) {
1116f6: 9e0b ldr r6, [sp, #44] ; 0x2c
1116f8: e6de b.n 1114b8 <_Heap_Walk+0x1b8>
1116fa: bf00 nop
0010a6f8 <_IO_Base64>:
}
int
_IO_Base64(IO_Put_char put_char, void *arg, const void *src, size_t srclen,
const char *wordbreak, int wordlen)
{
10a6f8: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
10a6fc: b083 sub sp, #12
10a6fe: 4699 mov r9, r3
10a700: 9b0d ldr r3, [sp, #52] ; 0x34
10a702: 4606 mov r6, r0
10a704: 468b mov fp, r1
10a706: 4692 mov sl, r2
unsigned int loops = 0;
const unsigned char *in = src;
int out = 0;
if (wordlen < 4) {
10a708: 2b04 cmp r3, #4
10a70a: bfb8 it lt
10a70c: 2304 movlt r3, #4
wordlen = 4;
}
while (srclen > 2) {
10a70e: f1b9 0f02 cmp.w r9, #2
10a712: 9300 str r3, [sp, #0]
10a714: f240 8098 bls.w 10a848 <_IO_Base64+0x150>
10a718: 9b0c ldr r3, [sp, #48] ; 0x30
10a71a: 2700 movs r7, #0
10a71c: f247 183c movw r8, #28988 ; 0x713c
10a720: 1cd4 adds r4, r2, #3
10a722: f2c0 0811 movt r8, #17
10a726: 463d mov r5, r7
10a728: f1c3 0305 rsb r3, r3, #5
10a72c: 9301 str r3, [sp, #4]
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
10a72e: f814 3c03 ldrb.w r3, [r4, #-3]
(*put_char)(c, arg);
10a732: 4659 mov r1, fp
10a734: 46a2 mov sl, r4
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
10a736: 089b lsrs r3, r3, #2
(*put_char)(c, arg);
10a738: f818 0003 ldrb.w r0, [r8, r3]
10a73c: 47b0 blx r6
_IO_Put(base64[((in[0]<<4)&0x30)|
10a73e: f814 3c03 ldrb.w r3, [r4, #-3]
(*put_char)(c, arg);
10a742: 4659 mov r1, fp
((in[1]>>4)&0x0f)], arg, put_char);
10a744: f814 2c02 ldrb.w r2, [r4, #-2]
_IO_Put(base64[((in[0]<<4)&0x30)|
10a748: 011b lsls r3, r3, #4
10a74a: f003 0330 and.w r3, r3, #48 ; 0x30
10a74e: ea43 1312 orr.w r3, r3, r2, lsr #4
(*put_char)(c, arg);
10a752: f818 0003 ldrb.w r0, [r8, r3]
10a756: 47b0 blx r6
_IO_Put(base64[((in[1]<<2)&0x3c)|
10a758: f814 3c02 ldrb.w r3, [r4, #-2]
(*put_char)(c, arg);
10a75c: 4659 mov r1, fp
((in[2]>>6)&0x03)], arg, put_char);
10a75e: f814 2c01 ldrb.w r2, [r4, #-1]
_IO_Put(base64[((in[1]<<2)&0x3c)|
10a762: 009b lsls r3, r3, #2
10a764: f003 033c and.w r3, r3, #60 ; 0x3c
10a768: ea43 1392 orr.w r3, r3, r2, lsr #6
(*put_char)(c, arg);
10a76c: f818 0003 ldrb.w r0, [r8, r3]
10a770: 47b0 blx r6
_IO_Put(base64[in[2]&0x3f], arg, put_char);
10a772: f814 3c01 ldrb.w r3, [r4, #-1]
(*put_char)(c, arg);
10a776: 4659 mov r1, fp
_IO_Put(base64[in[2]&0x3f], arg, put_char);
10a778: f003 033f and.w r3, r3, #63 ; 0x3f
(*put_char)(c, arg);
10a77c: f818 0003 ldrb.w r0, [r8, r3]
10a780: 47b0 blx r6
in += 3;
srclen -= 3;
out += 4;
loops++;
if (srclen != 0 &&
10a782: f1b9 0903 subs.w r9, r9, #3
out += 4;
10a786: f107 0304 add.w r3, r7, #4
if (srclen != 0 &&
10a78a: d031 beq.n 10a7f0 <_IO_Base64+0xf8>
10a78c: 9900 ldr r1, [sp, #0]
(int)((loops + 1) * 4) >= wordlen)
10a78e: 1caa adds r2, r5, #2
if (srclen != 0 &&
10a790: ebb1 0f82 cmp.w r1, r2, lsl #2
loops++;
10a794: bfc4 itt gt
10a796: 3501 addgt r5, #1
out += 4;
10a798: 461f movgt r7, r3
if (srclen != 0 &&
10a79a: dd2d ble.n 10a7f8 <_IO_Base64+0x100>
while (srclen > 2) {
10a79c: f1b9 0f02 cmp.w r9, #2
10a7a0: f104 0403 add.w r4, r4, #3
10a7a4: d8c3 bhi.n 10a72e <_IO_Base64+0x36>
++w;
++out;
}
}
}
if (srclen == 2) {
10a7a6: f1b9 0f02 cmp.w r9, #2
10a7aa: d135 bne.n 10a818 <_IO_Base64+0x120>
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
10a7ac: f89a 3000 ldrb.w r3, [sl]
10a7b0: f247 143c movw r4, #28988 ; 0x713c
10a7b4: f2c0 0411 movt r4, #17
(*put_char)(c, arg);
10a7b8: 4659 mov r1, fp
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
10a7ba: 089b lsrs r3, r3, #2
(*put_char)(c, arg);
10a7bc: 5ce0 ldrb r0, [r4, r3]
10a7be: 47b0 blx r6
_IO_Put(base64[((in[0]<<4)&0x30)|
10a7c0: f89a 3000 ldrb.w r3, [sl]
(*put_char)(c, arg);
10a7c4: 4659 mov r1, fp
((in[1]>>4)&0x0f)], arg, put_char);
10a7c6: f89a 2001 ldrb.w r2, [sl, #1]
_IO_Put(base64[((in[0]<<4)&0x30)|
10a7ca: 011b lsls r3, r3, #4
10a7cc: f003 0330 and.w r3, r3, #48 ; 0x30
10a7d0: ea43 1312 orr.w r3, r3, r2, lsr #4
(*put_char)(c, arg);
10a7d4: 5ce0 ldrb r0, [r4, r3]
10a7d6: 47b0 blx r6
_IO_Put(base64[((in[1]<<2)&0x3c)], arg, put_char);
10a7d8: f89a 3001 ldrb.w r3, [sl, #1]
(*put_char)(c, arg);
10a7dc: 4659 mov r1, fp
_IO_Put(base64[((in[1]<<2)&0x3c)], arg, put_char);
10a7de: 009b lsls r3, r3, #2
10a7e0: f003 033c and.w r3, r3, #60 ; 0x3c
(*put_char)(c, arg);
10a7e4: 5ce0 ldrb r0, [r4, r3]
10a7e6: 47b0 blx r6
10a7e8: 4659 mov r1, fp
10a7ea: 203d movs r0, #61 ; 0x3d
10a7ec: 47b0 blx r6
} else if (srclen == 1) {
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
_IO_Put(base64[((in[0]<<4)&0x30)], arg, put_char);
_IO_Put('=', arg, put_char);
_IO_Put('=', arg, put_char);
out += 4;
10a7ee: 1d3b adds r3, r7, #4
}
return out;
}
10a7f0: 4618 mov r0, r3
10a7f2: b003 add sp, #12
10a7f4: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
while (*w != '\0') {
10a7f8: 9a0c ldr r2, [sp, #48] ; 0x30
10a7fa: 7810 ldrb r0, [r2, #0]
10a7fc: b148 cbz r0, 10a812 <_IO_Base64+0x11a>
10a7fe: 9b01 ldr r3, [sp, #4]
10a800: 4615 mov r5, r2
10a802: 441f add r7, r3
(*put_char)(c, arg);
10a804: 4659 mov r1, fp
10a806: 47b0 blx r6
++out;
10a808: 197b adds r3, r7, r5
while (*w != '\0') {
10a80a: f815 0f01 ldrb.w r0, [r5, #1]!
10a80e: 2800 cmp r0, #0
10a810: d1f8 bne.n 10a804 <_IO_Base64+0x10c> <== ALWAYS TAKEN
out += 4;
10a812: 461f mov r7, r3
loops = 0;
10a814: 4605 mov r5, r0
10a816: e7c1 b.n 10a79c <_IO_Base64+0xa4>
} else if (srclen == 1) {
10a818: f1b9 0f01 cmp.w r9, #1
10a81c: d11a bne.n 10a854 <_IO_Base64+0x15c>
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
10a81e: f89a 3000 ldrb.w r3, [sl]
10a822: f247 143c movw r4, #28988 ; 0x713c
10a826: f2c0 0411 movt r4, #17
(*put_char)(c, arg);
10a82a: 4659 mov r1, fp
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
10a82c: 089b lsrs r3, r3, #2
(*put_char)(c, arg);
10a82e: 5ce0 ldrb r0, [r4, r3]
10a830: 47b0 blx r6
_IO_Put(base64[((in[0]<<4)&0x30)], arg, put_char);
10a832: f89a 3000 ldrb.w r3, [sl]
(*put_char)(c, arg);
10a836: 4659 mov r1, fp
_IO_Put(base64[((in[0]<<4)&0x30)], arg, put_char);
10a838: 011b lsls r3, r3, #4
10a83a: f003 0330 and.w r3, r3, #48 ; 0x30
(*put_char)(c, arg);
10a83e: 5ce0 ldrb r0, [r4, r3]
10a840: 47b0 blx r6
10a842: 4659 mov r1, fp
10a844: 203d movs r0, #61 ; 0x3d
10a846: e7ce b.n 10a7e6 <_IO_Base64+0xee>
if (srclen == 2) {
10a848: f1b9 0f02 cmp.w r9, #2
while (srclen > 2) {
10a84c: f04f 0700 mov.w r7, #0
if (srclen == 2) {
10a850: d0ac beq.n 10a7ac <_IO_Base64+0xb4>
10a852: e7e1 b.n 10a818 <_IO_Base64+0x120>
10a854: 463b mov r3, r7
return out;
10a856: e7cb b.n 10a7f0 <_IO_Base64+0xf8>
00109154 <_IO_Vprintf>:
return (p);
}
int
_IO_Vprintf(IO_Put_char put_char, void *arg, char const *fmt, va_list ap)
{
109154: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
109158: b095 sub sp, #84 ; 0x54
10915a: 4681 mov r9, r0
10915c: 468b mov fp, r1
char padc;
int stop = 0, retval = 0;
num = 0;
if (fmt == NULL)
10915e: e9cd 2301 strd r2, r3, [sp, #4]
109162: 2a00 cmp r2, #0
109164: f000 8090 beq.w 109288 <_IO_Vprintf+0x134> <== ALWAYS TAKEN
fmt = "(fmt null)\n";
for (;;) {
padc = ' ';
width = 0;
while ((ch = (u_char)*fmt++) != '%' || stop) {
109168: 7812 ldrb r2, [r2, #0]
width -= n;
if (!ladjust && width > 0)
while (width--)
PCHAR(padc);
while (n--)
10916a: 2500 movs r5, #0
10916c: f248 1360 movw r3, #33120 ; 0x8160
109170: 46a8 mov r8, r5
109172: f2c0 0311 movt r3, #17
109176: 9303 str r3, [sp, #12]
109178: 9500 str r5, [sp, #0]
while ((ch = (u_char)*fmt++) != '%' || stop) {
10917a: 9e01 ldr r6, [sp, #4]
10917c: eba8 0506 sub.w r5, r8, r6
109180: f8dd 8000 ldr.w r8, [sp]
109184: e004 b.n 109190 <_IO_Vprintf+0x3c>
if (ch == '\0')
109186: 2a00 cmp r2, #0
109188: d07a beq.n 109280 <_IO_Vprintf+0x12c>
PCHAR(ch);
10918a: 47c8 blx r9
while ((ch = (u_char)*fmt++) != '%' || stop) {
10918c: 7822 ldrb r2, [r4, #0]
10918e: 4626 mov r6, r4
109190: 2a25 cmp r2, #37 ; 0x25
PCHAR(ch);
109192: 4610 mov r0, r2
109194: 4659 mov r1, fp
while ((ch = (u_char)*fmt++) != '%' || stop) {
109196: f106 0401 add.w r4, r6, #1
10919a: 4637 mov r7, r6
10919c: eb06 0a05 add.w sl, r6, r5
1091a0: d1f1 bne.n 109186 <_IO_Vprintf+0x32>
1091a2: f1b8 0f00 cmp.w r8, #0
1091a6: d1f0 bne.n 10918a <_IO_Vprintf+0x36> <== ALWAYS TAKEN
sign = 0; dot = 0; dwidth = 0; upper = 0;
1091a8: 9b00 ldr r3, [sp, #0]
reswitch: switch (ch = (u_char)*fmt++) {
1091aa: 7872 ldrb r2, [r6, #1]
sign = 0; dot = 0; dwidth = 0; upper = 0;
1091ac: 4698 mov r8, r3
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
1091ae: 469c mov ip, r3
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
1091b0: 469e mov lr, r3
sign = 0; dot = 0; dwidth = 0; upper = 0;
1091b2: 9309 str r3, [sp, #36] ; 0x24
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
1091b4: 9304 str r3, [sp, #16]
1091b6: e9cd 3307 strd r3, r3, [sp, #28]
width = 0;
1091ba: e9cd 3305 strd r3, r3, [sp, #20]
padc = ' ';
1091be: 2320 movs r3, #32
1091c0: 930a str r3, [sp, #40] ; 0x28
reswitch: switch (ch = (u_char)*fmt++) {
1091c2: f1a2 0323 sub.w r3, r2, #35 ; 0x23
1091c6: 1c61 adds r1, r4, #1
1091c8: 2b57 cmp r3, #87 ; 0x57
1091ca: d869 bhi.n 1092a0 <_IO_Vprintf+0x14c> <== ALWAYS TAKEN
1091cc: e8df f013 tbh [pc, r3, lsl #1]
1091d0: 00680272 .word 0x00680272
1091d4: 006801be .word 0x006801be
1091d8: 00680068 .word 0x00680068
1091dc: 01c50068 .word 0x01c50068
1091e0: 00680177 .word 0x00680177
1091e4: 026d021e .word 0x026d021e
1091e8: 01720068 .word 0x01720068
1091ec: 007c007c .word 0x007c007c
1091f0: 007c007c .word 0x007c007c
1091f4: 007c007c .word 0x007c007c
1091f8: 007c007c .word 0x007c007c
1091fc: 0068007c .word 0x0068007c
109200: 00680068 .word 0x00680068
109204: 00680068 .word 0x00680068
109208: 00680068 .word 0x00680068
10920c: 00680068 .word 0x00680068
109210: 01ee0068 .word 0x01ee0068
109214: 00680068 .word 0x00680068
109218: 00680068 .word 0x00680068
10921c: 00680068 .word 0x00680068
109220: 00680068 .word 0x00680068
109224: 00680068 .word 0x00680068
109228: 00680068 .word 0x00680068
10922c: 00680068 .word 0x00680068
109230: 00680068 .word 0x00680068
109234: 00680068 .word 0x00680068
109238: 02170068 .word 0x02170068
10923c: 00680068 .word 0x00680068
109240: 00680068 .word 0x00680068
109244: 00680068 .word 0x00680068
109248: 00680068 .word 0x00680068
10924c: 00680068 .word 0x00680068
109250: 009d01d4 .word 0x009d01d4
109254: 00680068 .word 0x00680068
109258: 017a0068 .word 0x017a0068
10925c: 0183009d .word 0x0183009d
109260: 01880068 .word 0x01880068
109264: 00680068 .word 0x00680068
109268: 01ab0191 .word 0x01ab0191
10926c: 00680068 .word 0x00680068
109270: 00630223 .word 0x00630223
109274: 00680277 .word 0x00680277
109278: 02840068 .word 0x02840068
10927c: 0063027e .word 0x0063027e
stop = 1;
break;
}
}
#undef PCHAR
}
109280: 4650 mov r0, sl
109282: b015 add sp, #84 ; 0x54
109284: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
fmt = "(fmt null)\n";
109288: f248 134c movw r3, #33100 ; 0x814c <== NOT EXECUTED
10928c: 2228 movs r2, #40 ; 0x28 <== NOT EXECUTED
10928e: f2c0 0311 movt r3, #17 <== NOT EXECUTED
109292: 9301 str r3, [sp, #4] <== NOT EXECUTED
109294: e769 b.n 10916a <_IO_Vprintf+0x16> <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
109296: 7862 ldrb r2, [r4, #1]
zflag = 1;
109298: f04f 0e01 mov.w lr, #1
reswitch: switch (ch = (u_char)*fmt++) {
10929c: 460c mov r4, r1
goto reswitch;
10929e: e790 b.n 1091c2 <_IO_Vprintf+0x6e>
while (percent < fmt)
1092a0: 428e cmp r6, r1
1092a2: 9101 str r1, [sp, #4]
1092a4: f080 8314 bcs.w 1098d0 <_IO_Vprintf+0x77c> <== ALWAYS TAKEN
1092a8: 1e4e subs r6, r1, #1
1092aa: 2025 movs r0, #37 ; 0x25
1092ac: e001 b.n 1092b2 <_IO_Vprintf+0x15e>
PCHAR(*percent++);
1092ae: f817 0f01 ldrb.w r0, [r7, #1]!
1092b2: 4659 mov r1, fp
1092b4: 47c8 blx r9
while (percent < fmt)
1092b6: 42b7 cmp r7, r6
1092b8: d1f9 bne.n 1092ae <_IO_Vprintf+0x15a>
PCHAR(*percent++);
1092ba: 9b01 ldr r3, [sp, #4]
1092bc: eb03 0805 add.w r8, r3, r5
stop = 1;
1092c0: 2301 movs r3, #1
1092c2: 9300 str r3, [sp, #0]
while ((ch = (u_char)*fmt++) != '%' || stop) {
1092c4: 7862 ldrb r2, [r4, #1]
1092c6: e758 b.n 10917a <_IO_Vprintf+0x26>
n = n * 10 + ch - '0';
1092c8: f1a2 0330 sub.w r3, r2, #48 ; 0x30
ch = *fmt;
1092cc: 7862 ldrb r2, [r4, #1]
if (ch < '0' || ch > '9')
1092ce: f1a2 0430 sub.w r4, r2, #48 ; 0x30
ch = *fmt;
1092d2: 4610 mov r0, r2
if (ch < '0' || ch > '9')
1092d4: 2c09 cmp r4, #9
1092d6: f200 8206 bhi.w 1096e6 <_IO_Vprintf+0x592>
reswitch: switch (ch = (u_char)*fmt++) {
1092da: 460c mov r4, r1
n = n * 10 + ch - '0';
1092dc: eb03 0383 add.w r3, r3, r3, lsl #2
1092e0: eb00 0343 add.w r3, r0, r3, lsl #1
ch = *fmt;
1092e4: f814 0f01 ldrb.w r0, [r4, #1]!
n = n * 10 + ch - '0';
1092e8: 3b30 subs r3, #48 ; 0x30
if (ch < '0' || ch > '9')
1092ea: f1a0 0130 sub.w r1, r0, #48 ; 0x30
ch = *fmt;
1092ee: 4602 mov r2, r0
if (ch < '0' || ch > '9')
1092f0: 2909 cmp r1, #9
1092f2: d9f3 bls.n 1092dc <_IO_Vprintf+0x188> <== ALWAYS TAKEN
if (dot)
1092f4: 9906 ldr r1, [sp, #24]
1092f6: f1b8 0f00 cmp.w r8, #0
1092fa: bf08 it eq
1092fc: 4619 moveq r1, r3
1092fe: 9106 str r1, [sp, #24]
109300: 9909 ldr r1, [sp, #36] ; 0x24
109302: bf18 it ne
109304: 4619 movne r1, r3
109306: 9109 str r1, [sp, #36] ; 0x24
109308: e75b b.n 1091c2 <_IO_Vprintf+0x6e>
reswitch: switch (ch = (u_char)*fmt++) {
10930a: f04f 080a mov.w r8, #10
10930e: 9101 str r1, [sp, #4]
base = 10;
109310: f8cd 802c str.w r8, [sp, #44] ; 0x2c
if (jflag)
109314: 9b04 ldr r3, [sp, #16]
if (sharpflag && num != 0) {
109316: f8cd c030 str.w ip, [sp, #48] ; 0x30
if (jflag)
10931a: 2b00 cmp r3, #0
10931c: f000 8231 beq.w 109782 <_IO_Vprintf+0x62e>
num = va_arg(ap, intmax_t);
109320: 9d02 ldr r5, [sp, #8]
109322: 3507 adds r5, #7
109324: f025 0507 bic.w r5, r5, #7
109328: 4629 mov r1, r5
10932a: 686b ldr r3, [r5, #4]
10932c: f851 2b08 ldr.w r2, [r1], #8
109330: 9102 str r1, [sp, #8]
109332: e9cd 2307 strd r2, r3, [sp, #28]
if (sign && (intmax_t)num < 0) {
109336: 2b00 cmp r3, #0
109338: f280 82ce bge.w 1098d8 <_IO_Vprintf+0x784>
num = -(intmax_t)num;
10933c: 4252 negs r2, r2
10933e: eb63 0343 sbc.w r3, r3, r3, lsl #1
109342: 9207 str r2, [sp, #28]
neg = 1;
109344: 2201 movs r2, #1
num = -(intmax_t)num;
109346: 9308 str r3, [sp, #32]
109348: 2300 movs r3, #0
neg = 1;
10934a: 9204 str r2, [sp, #16]
*++p = hex2ascii_data[upper][num % base];
10934c: 9a03 ldr r2, [sp, #12]
p = nbuf;
10934e: ad0e add r5, sp, #56 ; 0x38
*p = '\0';
109350: e9dd 7607 ldrd r7, r6, [sp, #28]
109354: 940d str r4, [sp, #52] ; 0x34
*++p = hex2ascii_data[upper][num % base];
109356: eb02 1203 add.w r2, r2, r3, lsl #4
*p = '\0';
10935a: 2300 movs r3, #0
10935c: f88d 3038 strb.w r3, [sp, #56] ; 0x38
109360: 4614 mov r4, r2
*++p = hex2ascii_data[upper][num % base];
109362: 4638 mov r0, r7
109364: 4631 mov r1, r6
109366: 4642 mov r2, r8
109368: 2300 movs r3, #0
10936a: f007 f813 bl 110394 <__aeabi_uldivmod>
10936e: 46bc mov ip, r7
109370: 4633 mov r3, r6
109372: 5ca2 ldrb r2, [r4, r2]
} while (num /= base);
109374: 45c4 cmp ip, r8
109376: f173 0300 sbcs.w r3, r3, #0
10937a: 4607 mov r7, r0
10937c: 460e mov r6, r1
*++p = hex2ascii_data[upper][num % base];
10937e: f805 2f01 strb.w r2, [r5, #1]!
} while (num /= base);
109382: d2ee bcs.n 109362 <_IO_Vprintf+0x20e>
if (sharpflag && num != 0) {
109384: e9dd 3107 ldrd r3, r1, [sp, #28]
109388: 9c0d ldr r4, [sp, #52] ; 0x34
10938a: 430b orrs r3, r1
*lenp = p - nbuf;
10938c: ab0e add r3, sp, #56 ; 0x38
10938e: eba5 0803 sub.w r8, r5, r3
if (sharpflag && num != 0) {
109392: 9b0c ldr r3, [sp, #48] ; 0x30
109394: f003 0701 and.w r7, r3, #1
109398: bf08 it eq
10939a: 2700 moveq r7, #0
10939c: 2f00 cmp r7, #0
10939e: f000 81b4 beq.w 10970a <_IO_Vprintf+0x5b6>
if (base == 8)
1093a2: 9b0b ldr r3, [sp, #44] ; 0x2c
1093a4: 2b08 cmp r3, #8
tmp++;
1093a6: bf08 it eq
1093a8: 2601 moveq r6, #1
if (base == 8)
1093aa: d003 beq.n 1093b4 <_IO_Vprintf+0x260> <== ALWAYS TAKEN
tmp = 0;
1093ac: 2b10 cmp r3, #16
1093ae: bf0c ite eq
1093b0: 2602 moveq r6, #2
1093b2: 2600 movne r6, #0
if (neg)
1093b4: 9b04 ldr r3, [sp, #16]
1093b6: b103 cbz r3, 1093ba <_IO_Vprintf+0x266>
tmp++;
1093b8: 3601 adds r6, #1
if (!ladjust && padc == '0')
1093ba: 9b05 ldr r3, [sp, #20]
1093bc: 990a ldr r1, [sp, #40] ; 0x28
1093be: f083 0301 eor.w r3, r3, #1
1093c2: 2930 cmp r1, #48 ; 0x30
1093c4: bf14 ite ne
1093c6: 2300 movne r3, #0
1093c8: f003 0301 andeq.w r3, r3, #1
1093cc: 2b00 cmp r3, #0
1093ce: f000 818e beq.w 1096ee <_IO_Vprintf+0x59a>
dwidth = width - tmp;
1093d2: 9906 ldr r1, [sp, #24]
1093d4: 1b8b subs r3, r1, r6
width -= tmp + imax(dwidth, n);
1093d6: 4543 cmp r3, r8
1093d8: bfac ite ge
1093da: 18f6 addge r6, r6, r3
1093dc: 4446 addlt r6, r8
dwidth -= n;
1093de: eba3 0808 sub.w r8, r3, r8
width -= tmp + imax(dwidth, n);
1093e2: 1b8e subs r6, r1, r6
while (width-- > 0)
1093e4: 2e00 cmp r6, #0
1093e6: f106 33ff add.w r3, r6, #4294967295 ; 0xffffffff
1093ea: 9306 str r3, [sp, #24]
1093ec: f340 826e ble.w 1098cc <_IO_Vprintf+0x778>
1093f0: 9407 str r4, [sp, #28]
1093f2: 461e mov r6, r3
1093f4: 465c mov r4, fp
1093f6: 46d3 mov fp, sl
1093f8: 46aa mov sl, r5
1093fa: 4615 mov r5, r2
1093fc: 3e01 subs r6, #1
PCHAR(' ');
1093fe: 4621 mov r1, r4
109400: 2020 movs r0, #32
109402: 47c8 blx r9
while (width-- > 0)
109404: 1c72 adds r2, r6, #1
109406: d1f9 bne.n 1093fc <_IO_Vprintf+0x2a8>
PCHAR(' ');
109408: 9b06 ldr r3, [sp, #24]
10940a: 462a mov r2, r5
10940c: 4655 mov r5, sl
10940e: 46da mov sl, fp
109410: 46a3 mov fp, r4
109412: 9c07 ldr r4, [sp, #28]
109414: f10a 0a01 add.w sl, sl, #1
109418: 449a add sl, r3
if (neg)
10941a: 9b04 ldr r3, [sp, #16]
10941c: b133 cbz r3, 10942c <_IO_Vprintf+0x2d8>
10941e: 9204 str r2, [sp, #16]
PCHAR('-');
109420: 4659 mov r1, fp
109422: 202d movs r0, #45 ; 0x2d
109424: f10a 0a01 add.w sl, sl, #1
109428: 47c8 blx r9
10942a: 9a04 ldr r2, [sp, #16]
if (sharpflag && num != 0) {
10942c: b187 cbz r7, 109450 <_IO_Vprintf+0x2fc>
if (base == 8) {
10942e: 9b0b ldr r3, [sp, #44] ; 0x2c
109430: 2b08 cmp r3, #8
109432: f000 8197 beq.w 109764 <_IO_Vprintf+0x610> <== ALWAYS TAKEN
} else if (base == 16) {
109436: 9b0b ldr r3, [sp, #44] ; 0x2c
109438: 2b10 cmp r3, #16
10943a: d109 bne.n 109450 <_IO_Vprintf+0x2fc> <== ALWAYS TAKEN
10943c: 9204 str r2, [sp, #16]
PCHAR('0');
10943e: 2030 movs r0, #48 ; 0x30
109440: 4659 mov r1, fp
PCHAR('x');
109442: f10a 0a02 add.w sl, sl, #2
PCHAR('0');
109446: 47c8 blx r9
PCHAR('x');
109448: 4659 mov r1, fp
10944a: 2078 movs r0, #120 ; 0x78
10944c: 47c8 blx r9
10944e: 9a04 ldr r2, [sp, #16]
while (dwidth-- > 0)
109450: f1b8 0f00 cmp.w r8, #0
109454: f108 37ff add.w r7, r8, #4294967295 ; 0xffffffff
109458: dd17 ble.n 10948a <_IO_Vprintf+0x336>
10945a: 46b8 mov r8, r7
10945c: 9404 str r4, [sp, #16]
10945e: 465c mov r4, fp
109460: 46d3 mov fp, sl
109462: 46ba mov sl, r7
109464: 462f mov r7, r5
109466: 4615 mov r5, r2
109468: f108 38ff add.w r8, r8, #4294967295 ; 0xffffffff
PCHAR('0');
10946c: 4621 mov r1, r4
10946e: 2030 movs r0, #48 ; 0x30
109470: 47c8 blx r9
while (dwidth-- > 0)
109472: f1b8 3fff cmp.w r8, #4294967295 ; 0xffffffff
109476: d1f7 bne.n 109468 <_IO_Vprintf+0x314>
109478: 462a mov r2, r5
10947a: 463d mov r5, r7
10947c: 4657 mov r7, sl
10947e: 46da mov sl, fp
109480: 46a3 mov fp, r4
109482: 9c04 ldr r4, [sp, #16]
109484: f10a 0a01 add.w sl, sl, #1
PCHAR('0');
109488: 44ba add sl, r7
while (*p)
10948a: 2a00 cmp r2, #0
10948c: f000 8188 beq.w 1097a0 <_IO_Vprintf+0x64c> <== ALWAYS TAKEN
109490: 1c6b adds r3, r5, #1
109492: 4610 mov r0, r2
109494: 449a add sl, r3
PCHAR(*p--);
109496: 4659 mov r1, fp
109498: ebaa 0805 sub.w r8, sl, r5
10949c: 47c8 blx r9
while (*p)
10949e: f815 0d01 ldrb.w r0, [r5, #-1]!
1094a2: 2800 cmp r0, #0
1094a4: d1f7 bne.n 109496 <_IO_Vprintf+0x342>
if (ladjust)
1094a6: 9b05 ldr r3, [sp, #20]
1094a8: 2b00 cmp r3, #0
1094aa: f040 814e bne.w 10974a <_IO_Vprintf+0x5f6>
1094ae: 9b05 ldr r3, [sp, #20]
1094b0: 9300 str r3, [sp, #0]
1094b2: e707 b.n 1092c4 <_IO_Vprintf+0x170>
if (!dot) {
1094b4: f1b8 0f00 cmp.w r8, #0
1094b8: f040 8199 bne.w 1097ee <_IO_Vprintf+0x69a> <== ALWAYS TAKEN
padc = '0';
1094bc: 920a str r2, [sp, #40] ; 0x28
reswitch: switch (ch = (u_char)*fmt++) {
1094be: 7862 ldrb r2, [r4, #1]
1094c0: 460c mov r4, r1
1094c2: e67e b.n 1091c2 <_IO_Vprintf+0x6e>
if (hflag) {
1094c4: 9b07 ldr r3, [sp, #28]
reswitch: switch (ch = (u_char)*fmt++) {
1094c6: 7862 ldrb r2, [r4, #1]
if (hflag) {
1094c8: 2b00 cmp r3, #0
1094ca: f040 8172 bne.w 1097b2 <_IO_Vprintf+0x65e>
hflag = 1;
1094ce: 2301 movs r3, #1
reswitch: switch (ch = (u_char)*fmt++) {
1094d0: 460c mov r4, r1
hflag = 1;
1094d2: 9307 str r3, [sp, #28]
1094d4: e675 b.n 1091c2 <_IO_Vprintf+0x6e>
jflag = 1;
1094d6: 2301 movs r3, #1
reswitch: switch (ch = (u_char)*fmt++) {
1094d8: 7862 ldrb r2, [r4, #1]
jflag = 1;
1094da: 9304 str r3, [sp, #16]
reswitch: switch (ch = (u_char)*fmt++) {
1094dc: 460c mov r4, r1
goto reswitch;
1094de: e670 b.n 1091c2 <_IO_Vprintf+0x6e>
if (lflag) {
1094e0: f1be 0f00 cmp.w lr, #0
1094e4: f43f aed7 beq.w 109296 <_IO_Vprintf+0x142>
reswitch: switch (ch = (u_char)*fmt++) {
1094e8: 7862 ldrb r2, [r4, #1]
1094ea: 460c mov r4, r1
jflag = 1;
1094ec: f8cd e010 str.w lr, [sp, #16]
1094f0: e667 b.n 1091c2 <_IO_Vprintf+0x6e>
sign = 0; dot = 0; dwidth = 0; upper = 0;
1094f2: 2300 movs r3, #0
reswitch: switch (ch = (u_char)*fmt++) {
1094f4: f04f 0808 mov.w r8, #8
1094f8: 9101 str r1, [sp, #4]
base = 8;
1094fa: f8cd 802c str.w r8, [sp, #44] ; 0x2c
if (jflag)
1094fe: 9a04 ldr r2, [sp, #16]
if (sharpflag && num != 0) {
109500: f8cd c030 str.w ip, [sp, #48] ; 0x30
if (jflag)
109504: 2a00 cmp r2, #0
109506: f000 8111 beq.w 10972c <_IO_Vprintf+0x5d8>
num = va_arg(ap, uintmax_t);
10950a: 9d02 ldr r5, [sp, #8]
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
10950c: 2200 movs r2, #0
10950e: 9204 str r2, [sp, #16]
num = va_arg(ap, uintmax_t);
109510: 3507 adds r5, #7
109512: f025 0507 bic.w r5, r5, #7
109516: 6869 ldr r1, [r5, #4]
109518: 462a mov r2, r5
10951a: 9108 str r1, [sp, #32]
10951c: f852 1b08 ldr.w r1, [r2], #8
109520: 9107 str r1, [sp, #28]
109522: 9202 str r2, [sp, #8]
109524: e712 b.n 10934c <_IO_Vprintf+0x1f8>
num = (uintptr_t)va_arg(ap, void *);
109526: 9d02 ldr r5, [sp, #8]
109528: 2300 movs r3, #0
goto number;
10952a: f04f 0810 mov.w r8, #16
num = (uintptr_t)va_arg(ap, void *);
10952e: 9101 str r1, [sp, #4]
109530: 9308 str r3, [sp, #32]
109532: f855 2b04 ldr.w r2, [r5], #4
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
109536: 9304 str r3, [sp, #16]
base = 16;
109538: f8cd 802c str.w r8, [sp, #44] ; 0x2c
num = (uintptr_t)va_arg(ap, void *);
10953c: 9207 str r2, [sp, #28]
sharpflag = (width == 0);
10953e: 9a06 ldr r2, [sp, #24]
num = (uintptr_t)va_arg(ap, void *);
109540: 9502 str r5, [sp, #8]
sharpflag = (width == 0);
109542: fab2 f282 clz r2, r2
109546: 0952 lsrs r2, r2, #5
109548: 920c str r2, [sp, #48] ; 0x30
goto number;
10954a: e6ff b.n 10934c <_IO_Vprintf+0x1f8>
PCHAR(ch);
10954c: 9101 str r1, [sp, #4]
10954e: 2025 movs r0, #37 ; 0x25
109550: 4659 mov r1, fp
109552: f10a 0801 add.w r8, sl, #1
109556: 47c8 blx r9
break;
109558: e6b4 b.n 1092c4 <_IO_Vprintf+0x170>
width = va_arg(ap, int);
10955a: 9a02 ldr r2, [sp, #8]
10955c: 1d13 adds r3, r2, #4
if (!dot) {
10955e: f1b8 0f00 cmp.w r8, #0
109562: f040 8136 bne.w 1097d2 <_IO_Vprintf+0x67e> <== NEVER TAKEN
width = va_arg(ap, int);
109566: 6812 ldr r2, [r2, #0] <== NOT EXECUTED
if (width < 0) {
109568: 2a00 cmp r2, #0 <== NOT EXECUTED
width = va_arg(ap, int);
10956a: 9206 str r2, [sp, #24] <== NOT EXECUTED
if (width < 0) {
10956c: f2c0 81a3 blt.w 1098b6 <_IO_Vprintf+0x762> <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
109570: 7862 ldrb r2, [r4, #1]
109572: 460c mov r4, r1
dwidth = va_arg(ap, int);
109574: 9302 str r3, [sp, #8]
109576: e624 b.n 1091c2 <_IO_Vprintf+0x6e>
if (!ladjust && width > 0)
109578: 9b06 ldr r3, [sp, #24]
width = va_arg(ap, int);
10957a: 9a02 ldr r2, [sp, #8]
if (!ladjust && width > 0)
10957c: 9101 str r1, [sp, #4]
10957e: 2b01 cmp r3, #1
109580: 9b05 ldr r3, [sp, #20]
109582: bfd4 ite le
109584: 2600 movle r6, #0
109586: 2601 movgt r6, #1
width = va_arg(ap, int);
109588: 1d15 adds r5, r2, #4
if (!ladjust && width > 0)
10958a: f083 0301 eor.w r3, r3, #1
10958e: 4233 tst r3, r6
109590: f040 817c bne.w 10988c <_IO_Vprintf+0x738> <== ALWAYS TAKEN
PCHAR(va_arg(ap, int));
109594: 9b02 ldr r3, [sp, #8]
109596: 4659 mov r1, fp
PCHAR(ch);
109598: f10a 0801 add.w r8, sl, #1
PCHAR(va_arg(ap, int));
10959c: 6818 ldr r0, [r3, #0]
10959e: 47c8 blx r9
if (ladjust && width > 0)
1095a0: 9b05 ldr r3, [sp, #20]
1095a2: 4233 tst r3, r6
1095a4: f040 812b bne.w 1097fe <_IO_Vprintf+0x6aa> <== ALWAYS TAKEN
PCHAR(va_arg(ap, int));
1095a8: 9502 str r5, [sp, #8]
1095aa: e68b b.n 1092c4 <_IO_Vprintf+0x170>
up = va_arg(ap, u_char *);
1095ac: 9b02 ldr r3, [sp, #8] <== NOT EXECUTED
1095ae: 9101 str r1, [sp, #4] <== NOT EXECUTED
p = va_arg(ap, char *);
1095b0: 685a ldr r2, [r3, #4] <== NOT EXECUTED
up = va_arg(ap, u_char *);
1095b2: f853 6b08 ldr.w r6, [r3], #8 <== NOT EXECUTED
p = va_arg(ap, char *);
1095b6: 9204 str r2, [sp, #16] <== NOT EXECUTED
up = va_arg(ap, u_char *);
1095b8: 9302 str r3, [sp, #8] <== NOT EXECUTED
if (!width)
1095ba: 9b06 ldr r3, [sp, #24] <== NOT EXECUTED
while(width--) {
1095bc: 1e5f subs r7, r3, #1 <== NOT EXECUTED
if (!width)
1095be: b903 cbnz r3, 1095c2 <_IO_Vprintf+0x46e> <== NOT EXECUTED
while(width--) {
1095c0: 270f movs r7, #15 <== NOT EXECUTED
1095c2: 4437 add r7, r6 <== NOT EXECUTED
1095c4: 9b04 ldr r3, [sp, #16] <== NOT EXECUTED
1095c6: 4655 mov r5, sl <== NOT EXECUTED
1095c8: 46ba mov sl, r7 <== NOT EXECUTED
1095ca: 9f03 ldr r7, [sp, #12] <== NOT EXECUTED
1095cc: 46d8 mov r8, fp <== NOT EXECUTED
1095ce: 46a3 mov fp, r4 <== NOT EXECUTED
1095d0: f1c3 0303 rsb r3, r3, #3 <== NOT EXECUTED
1095d4: 9305 str r3, [sp, #20] <== NOT EXECUTED
PCHAR(hex2ascii(*up >> 4));
1095d6: 7833 ldrb r3, [r6, #0] <== NOT EXECUTED
1095d8: 4641 mov r1, r8 <== NOT EXECUTED
1095da: 091b lsrs r3, r3, #4 <== NOT EXECUTED
1095dc: 5cf8 ldrb r0, [r7, r3] <== NOT EXECUTED
1095de: 47c8 blx r9 <== NOT EXECUTED
PCHAR(hex2ascii(*up & 0x0f));
1095e0: 7833 ldrb r3, [r6, #0] <== NOT EXECUTED
1095e2: 4641 mov r1, r8 <== NOT EXECUTED
1095e4: f003 030f and.w r3, r3, #15 <== NOT EXECUTED
1095e8: 5cf8 ldrb r0, [r7, r3] <== NOT EXECUTED
1095ea: 47c8 blx r9 <== NOT EXECUTED
if (width)
1095ec: 4556 cmp r6, sl <== NOT EXECUTED
PCHAR(hex2ascii(*up & 0x0f));
1095ee: f105 0202 add.w r2, r5, #2 <== NOT EXECUTED
if (width)
1095f2: f040 808c bne.w 10970e <_IO_Vprintf+0x5ba> <== NOT EXECUTED
p = va_arg(ap, char *);
1095f6: 465c mov r4, fp <== NOT EXECUTED
1095f8: 46c3 mov fp, r8 <== NOT EXECUTED
1095fa: 4690 mov r8, r2 <== NOT EXECUTED
1095fc: e662 b.n 1092c4 <_IO_Vprintf+0x170> <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
1095fe: f04f 0810 mov.w r8, #16
upper = 1;
109602: 2301 movs r3, #1
reswitch: switch (ch = (u_char)*fmt++) {
109604: 9101 str r1, [sp, #4]
base = 16;
109606: f8cd 802c str.w r8, [sp, #44] ; 0x2c
10960a: e778 b.n 1094fe <_IO_Vprintf+0x3aa>
ladjust = 1;
10960c: 2301 movs r3, #1
reswitch: switch (ch = (u_char)*fmt++) {
10960e: 7862 ldrb r2, [r4, #1]
ladjust = 1;
109610: 9305 str r3, [sp, #20]
reswitch: switch (ch = (u_char)*fmt++) {
109612: 460c mov r4, r1
goto reswitch;
109614: e5d5 b.n 1091c2 <_IO_Vprintf+0x6e>
p = va_arg(ap, char *);
109616: 9b02 ldr r3, [sp, #8]
109618: 9101 str r1, [sp, #4]
10961a: 461a mov r2, r3
p = "(null)";
10961c: f248 1358 movw r3, #33112 ; 0x8158
p = va_arg(ap, char *);
109620: f852 6b04 ldr.w r6, [r2], #4
p = "(null)";
109624: f2c0 0311 movt r3, #17
109628: 2e00 cmp r6, #0
10962a: bf08 it eq
10962c: 461e moveq r6, r3
if (!ladjust && width > 0)
10962e: 9b05 ldr r3, [sp, #20]
p = va_arg(ap, char *);
109630: 9202 str r2, [sp, #8]
if (!ladjust && width > 0)
109632: f083 0301 eor.w r3, r3, #1
109636: f003 0301 and.w r3, r3, #1
10963a: 9304 str r3, [sp, #16]
if (!dot)
10963c: f1b8 0f00 cmp.w r8, #0
109640: f040 810f bne.w 109862 <_IO_Vprintf+0x70e>
n = strlen (p);
109644: 4630 mov r0, r6
109646: f008 f81b bl 111680 <strlen>
10964a: 4602 mov r2, r0
width -= n;
10964c: 9b06 ldr r3, [sp, #24]
while (n--)
10964e: 1e57 subs r7, r2, #1
width -= n;
109650: 1a9b subs r3, r3, r2
if (!ladjust && width > 0)
109652: 2b00 cmp r3, #0
width -= n;
109654: 9306 str r3, [sp, #24]
if (!ladjust && width > 0)
109656: 9b04 ldr r3, [sp, #16]
109658: bfd4 ite le
10965a: 2500 movle r5, #0
10965c: 2501 movgt r5, #1
10965e: 421d tst r5, r3
109660: f040 80df bne.w 109822 <_IO_Vprintf+0x6ce>
if (ladjust && width > 0)
109664: 9b05 ldr r3, [sp, #20]
109666: 402b ands r3, r5
109668: 461d mov r5, r3
while (n--)
10966a: 2a00 cmp r2, #0
10966c: d03d beq.n 1096ea <_IO_Vprintf+0x596>
if (ladjust && width > 0)
10966e: 46b0 mov r8, r6
PCHAR(*p++);
109670: f818 0b01 ldrb.w r0, [r8], #1
109674: 4659 mov r1, fp
109676: 47c8 blx r9
while (n--)
109678: f1c8 0301 rsb r3, r8, #1
10967c: 4433 add r3, r6
10967e: 42fb cmn r3, r7
109680: d1f6 bne.n 109670 <_IO_Vprintf+0x51c>
109682: f10a 0301 add.w r3, sl, #1
PCHAR(*p++);
109686: eb07 0803 add.w r8, r7, r3
if (ladjust && width > 0)
10968a: 2d00 cmp r5, #0
10968c: f43f ae1a beq.w 1092c4 <_IO_Vprintf+0x170>
while (width--)
109690: 9e06 ldr r6, [sp, #24]
109692: 9f0a ldr r7, [sp, #40] ; 0x28
109694: 1e75 subs r5, r6, #1
PCHAR(padc);
109696: 4659 mov r1, fp
109698: 4638 mov r0, r7
10969a: 47c8 blx r9
while (width--)
10969c: 3e01 subs r6, #1
10969e: d1fa bne.n 109696 <_IO_Vprintf+0x542>
1096a0: f108 0301 add.w r3, r8, #1
PCHAR(padc);
1096a4: eb05 0803 add.w r8, r5, r3
1096a8: e60c b.n 1092c4 <_IO_Vprintf+0x170>
reswitch: switch (ch = (u_char)*fmt++) {
1096aa: 7862 ldrb r2, [r4, #1]
dot = 1;
1096ac: f04f 0801 mov.w r8, #1
reswitch: switch (ch = (u_char)*fmt++) {
1096b0: 460c mov r4, r1
1096b2: e586 b.n 1091c2 <_IO_Vprintf+0x6e>
1096b4: 7862 ldrb r2, [r4, #1] <== NOT EXECUTED
sharpflag = 1;
1096b6: f04f 0c01 mov.w ip, #1 <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
1096ba: 460c mov r4, r1 <== NOT EXECUTED
goto reswitch;
1096bc: e581 b.n 1091c2 <_IO_Vprintf+0x6e> <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
1096be: f04f 080a mov.w r8, #10
sign = 0; dot = 0; dwidth = 0; upper = 0;
1096c2: 2300 movs r3, #0
reswitch: switch (ch = (u_char)*fmt++) {
1096c4: 9101 str r1, [sp, #4]
base = 10;
1096c6: f8cd 802c str.w r8, [sp, #44] ; 0x2c
1096ca: e718 b.n 1094fe <_IO_Vprintf+0x3aa>
reswitch: switch (ch = (u_char)*fmt++) {
1096cc: f04f 0810 mov.w r8, #16 <== NOT EXECUTED
1096d0: 9101 str r1, [sp, #4] <== NOT EXECUTED
1096d2: f8cd 802c str.w r8, [sp, #44] ; 0x2c <== NOT EXECUTED
1096d6: e61d b.n 109314 <_IO_Vprintf+0x1c0> <== NOT EXECUTED
1096d8: f04f 0810 mov.w r8, #16
1096dc: 2300 movs r3, #0
1096de: 9101 str r1, [sp, #4]
1096e0: f8cd 802c str.w r8, [sp, #44] ; 0x2c
1096e4: e70b b.n 1094fe <_IO_Vprintf+0x3aa>
1096e6: 460c mov r4, r1
1096e8: e604 b.n 1092f4 <_IO_Vprintf+0x1a0>
while (n--)
1096ea: 46d0 mov r8, sl
1096ec: e7cd b.n 10968a <_IO_Vprintf+0x536>
width -= tmp + imax(dwidth, n);
1096ee: 9b09 ldr r3, [sp, #36] ; 0x24
1096f0: 4543 cmp r3, r8
1096f2: bfac ite ge
1096f4: 18f6 addge r6, r6, r3
1096f6: 4446 addlt r6, r8
dwidth -= n;
1096f8: eba3 0808 sub.w r8, r3, r8
width -= tmp + imax(dwidth, n);
1096fc: 9b06 ldr r3, [sp, #24]
1096fe: 1b9e subs r6, r3, r6
if (!ladjust)
109700: 9b05 ldr r3, [sp, #20]
109702: 2b00 cmp r3, #0
109704: f47f ae89 bne.w 10941a <_IO_Vprintf+0x2c6>
109708: e66c b.n 1093e4 <_IO_Vprintf+0x290>
tmp = 0;
10970a: 463e mov r6, r7
10970c: e652 b.n 1093b4 <_IO_Vprintf+0x260>
for (q=p;*q;q++)
10970e: 9c04 ldr r4, [sp, #16] <== NOT EXECUTED
109710: 7820 ldrb r0, [r4, #0] <== NOT EXECUTED
109712: b140 cbz r0, 109726 <_IO_Vprintf+0x5d2> <== NOT EXECUTED
109714: 9b05 ldr r3, [sp, #20] <== NOT EXECUTED
109716: 441d add r5, r3 <== NOT EXECUTED
PCHAR(*q);
109718: 4641 mov r1, r8 <== NOT EXECUTED
10971a: 47c8 blx r9 <== NOT EXECUTED
10971c: 1962 adds r2, r4, r5 <== NOT EXECUTED
for (q=p;*q;q++)
10971e: f814 0f01 ldrb.w r0, [r4, #1]! <== NOT EXECUTED
109722: 2800 cmp r0, #0 <== NOT EXECUTED
109724: d1f8 bne.n 109718 <_IO_Vprintf+0x5c4> <== NOT EXECUTED
up++;
109726: 3601 adds r6, #1 <== NOT EXECUTED
109728: 4615 mov r5, r2 <== NOT EXECUTED
10972a: e754 b.n 1095d6 <_IO_Vprintf+0x482> <== NOT EXECUTED
width = va_arg(ap, int);
10972c: 9902 ldr r1, [sp, #8]
10972e: 1d0a adds r2, r1, #4
else if (lflag)
109730: f1be 0f00 cmp.w lr, #0
109734: d11f bne.n 109776 <_IO_Vprintf+0x622>
else if (hflag)
109736: 9907 ldr r1, [sp, #28]
109738: 2900 cmp r1, #0
10973a: d040 beq.n 1097be <_IO_Vprintf+0x66a>
num = (u_short)va_arg(ap, int);
10973c: 9902 ldr r1, [sp, #8]
10973e: 9202 str r2, [sp, #8]
109740: 9a04 ldr r2, [sp, #16]
109742: 8809 ldrh r1, [r1, #0]
109744: 9208 str r2, [sp, #32]
109746: 9107 str r1, [sp, #28]
109748: e600 b.n 10934c <_IO_Vprintf+0x1f8>
while (width-- > 0)
10974a: 2e00 cmp r6, #0
10974c: f106 35ff add.w r5, r6, #4294967295 ; 0xffffffff
109750: f77f adb8 ble.w 1092c4 <_IO_Vprintf+0x170>
109754: 462e mov r6, r5
109756: 3e01 subs r6, #1
PCHAR(' ');
109758: 4659 mov r1, fp
10975a: 2020 movs r0, #32
10975c: 47c8 blx r9
while (width-- > 0)
10975e: 1c73 adds r3, r6, #1
109760: d1f9 bne.n 109756 <_IO_Vprintf+0x602>
109762: e79d b.n 1096a0 <_IO_Vprintf+0x54c>
109764: 9204 str r2, [sp, #16] <== NOT EXECUTED
PCHAR('0');
109766: 4659 mov r1, fp <== NOT EXECUTED
109768: 2030 movs r0, #48 ; 0x30 <== NOT EXECUTED
10976a: f10a 0a01 add.w sl, sl, #1 <== NOT EXECUTED
10976e: 47c8 blx r9 <== NOT EXECUTED
109770: 9a04 ldr r2, [sp, #16] <== NOT EXECUTED
109772: e66d b.n 109450 <_IO_Vprintf+0x2fc> <== NOT EXECUTED
num = va_arg(ap, u_int);
109774: 9902 ldr r1, [sp, #8]
109776: 6809 ldr r1, [r1, #0]
109778: 9202 str r2, [sp, #8]
10977a: 9a04 ldr r2, [sp, #16]
10977c: 9107 str r1, [sp, #28]
10977e: 9208 str r2, [sp, #32]
109780: e5e4 b.n 10934c <_IO_Vprintf+0x1f8>
width = va_arg(ap, int);
109782: 9a02 ldr r2, [sp, #8]
109784: 1d13 adds r3, r2, #4
else if (tflag)
109786: f1be 0f00 cmp.w lr, #0
10978a: d10c bne.n 1097a6 <_IO_Vprintf+0x652>
else if (hflag)
10978c: 9a07 ldr r2, [sp, #28]
10978e: b322 cbz r2, 1097da <_IO_Vprintf+0x686>
num = (short)va_arg(ap, int);
109790: 9a02 ldr r2, [sp, #8] <== NOT EXECUTED
109792: 9302 str r3, [sp, #8] <== NOT EXECUTED
109794: f9b2 2000 ldrsh.w r2, [r2] <== NOT EXECUTED
109798: 9207 str r2, [sp, #28] <== NOT EXECUTED
10979a: 17d3 asrs r3, r2, #31 <== NOT EXECUTED
10979c: 9308 str r3, [sp, #32] <== NOT EXECUTED
10979e: e5ca b.n 109336 <_IO_Vprintf+0x1e2> <== NOT EXECUTED
while (*p)
1097a0: 46d0 mov r8, sl <== NOT EXECUTED
1097a2: e680 b.n 1094a6 <_IO_Vprintf+0x352> <== NOT EXECUTED
num = va_arg(ap, int);
1097a4: 9a02 ldr r2, [sp, #8]
1097a6: 6812 ldr r2, [r2, #0]
1097a8: 9302 str r3, [sp, #8]
1097aa: 9207 str r2, [sp, #28]
1097ac: 17d3 asrs r3, r2, #31
1097ae: 9308 str r3, [sp, #32]
1097b0: e5c1 b.n 109336 <_IO_Vprintf+0x1e2>
cflag = 1;
1097b2: 9b07 ldr r3, [sp, #28]
reswitch: switch (ch = (u_char)*fmt++) {
1097b4: 460c mov r4, r1
cflag = 1;
1097b6: 9308 str r3, [sp, #32]
hflag = 0;
1097b8: 2300 movs r3, #0
1097ba: 9307 str r3, [sp, #28]
1097bc: e501 b.n 1091c2 <_IO_Vprintf+0x6e>
else if (cflag)
1097be: 9908 ldr r1, [sp, #32]
1097c0: 2900 cmp r1, #0
1097c2: d0d7 beq.n 109774 <_IO_Vprintf+0x620>
num = (u_char)va_arg(ap, int);
1097c4: 9902 ldr r1, [sp, #8]
1097c6: 9202 str r2, [sp, #8]
1097c8: 9a04 ldr r2, [sp, #16]
1097ca: 7809 ldrb r1, [r1, #0]
1097cc: 9208 str r2, [sp, #32]
1097ce: 9107 str r1, [sp, #28]
1097d0: e5bc b.n 10934c <_IO_Vprintf+0x1f8>
dwidth = va_arg(ap, int);
1097d2: 9a02 ldr r2, [sp, #8]
1097d4: 6812 ldr r2, [r2, #0]
1097d6: 9209 str r2, [sp, #36] ; 0x24
1097d8: e6ca b.n 109570 <_IO_Vprintf+0x41c>
else if (cflag)
1097da: 9a08 ldr r2, [sp, #32]
1097dc: 2a00 cmp r2, #0
1097de: d0e1 beq.n 1097a4 <_IO_Vprintf+0x650> <== NEVER TAKEN
num = (char)va_arg(ap, int);
1097e0: 9a02 ldr r2, [sp, #8] <== NOT EXECUTED
1097e2: 9302 str r3, [sp, #8] <== NOT EXECUTED
1097e4: 9b04 ldr r3, [sp, #16] <== NOT EXECUTED
1097e6: 7812 ldrb r2, [r2, #0] <== NOT EXECUTED
1097e8: 9308 str r3, [sp, #32] <== NOT EXECUTED
1097ea: 9207 str r2, [sp, #28] <== NOT EXECUTED
if (sign && (intmax_t)num < 0) {
1097ec: e5ae b.n 10934c <_IO_Vprintf+0x1f8> <== NOT EXECUTED
ch = *fmt;
1097ee: 7860 ldrb r0, [r4, #1] <== NOT EXECUTED
if (ch < '0' || ch > '9')
1097f0: f1a0 0330 sub.w r3, r0, #48 ; 0x30 <== NOT EXECUTED
ch = *fmt;
1097f4: 4602 mov r2, r0 <== NOT EXECUTED
if (ch < '0' || ch > '9')
1097f6: 2b09 cmp r3, #9 <== NOT EXECUTED
1097f8: d871 bhi.n 1098de <_IO_Vprintf+0x78a> <== NOT EXECUTED
n = n * 10 + ch - '0';
1097fa: 2300 movs r3, #0 <== NOT EXECUTED
1097fc: e56d b.n 1092da <_IO_Vprintf+0x186> <== NOT EXECUTED
while (width--)
1097fe: 9b06 ldr r3, [sp, #24] <== NOT EXECUTED
109800: 9e0a ldr r6, [sp, #40] ; 0x28 <== NOT EXECUTED
109802: f1a3 0802 sub.w r8, r3, #2 <== NOT EXECUTED
109806: 4647 mov r7, r8 <== NOT EXECUTED
PCHAR(padc);
109808: 4659 mov r1, fp <== NOT EXECUTED
while (width--)
10980a: 3f01 subs r7, #1 <== NOT EXECUTED
PCHAR(padc);
10980c: 4630 mov r0, r6 <== NOT EXECUTED
10980e: 47c8 blx r9 <== NOT EXECUTED
while (width--)
109810: 1c79 adds r1, r7, #1 <== NOT EXECUTED
109812: d1f9 bne.n 109808 <_IO_Vprintf+0x6b4> <== NOT EXECUTED
PCHAR(padc);
109814: f10a 0302 add.w r3, sl, #2 <== NOT EXECUTED
109818: 4498 add r8, r3 <== NOT EXECUTED
10981a: e6c5 b.n 1095a8 <_IO_Vprintf+0x454> <== NOT EXECUTED
for (n = 0; n < dwidth && p[n]; n++)
10981c: 2200 movs r2, #0 <== NOT EXECUTED
if (!ladjust && width > 0)
10981e: f04f 37ff mov.w r7, #4294967295 ; 0xffffffff <== NOT EXECUTED
while (width--)
109822: 9d06 ldr r5, [sp, #24]
109824: 465b mov r3, fp
109826: e9cd 2404 strd r2, r4, [sp, #16]
10982a: 46d3 mov fp, sl
10982c: 9c0a ldr r4, [sp, #40] ; 0x28
10982e: 46ba mov sl, r7
109830: f105 38ff add.w r8, r5, #4294967295 ; 0xffffffff
109834: 4637 mov r7, r6
109836: 461e mov r6, r3
PCHAR(padc);
109838: 4631 mov r1, r6
10983a: 4620 mov r0, r4
10983c: 47c8 blx r9
while (width--)
10983e: 3d01 subs r5, #1
109840: d1fa bne.n 109838 <_IO_Vprintf+0x6e4>
109842: e9dd 2404 ldrd r2, r4, [sp, #16]
109846: 4633 mov r3, r6
109848: 463e mov r6, r7
10984a: 4657 mov r7, sl
10984c: 46da mov sl, fp
10984e: 469b mov fp, r3
PCHAR(padc);
109850: f10a 0a01 add.w sl, sl, #1
109854: 44c2 add sl, r8
while (n--)
109856: 2a00 cmp r2, #0
109858: d045 beq.n 1098e6 <_IO_Vprintf+0x792> <== ALWAYS TAKEN
10985a: f04f 33ff mov.w r3, #4294967295 ; 0xffffffff
10985e: 9306 str r3, [sp, #24]
109860: e705 b.n 10966e <_IO_Vprintf+0x51a>
for (n = 0; n < dwidth && p[n]; n++)
109862: 9b09 ldr r3, [sp, #36] ; 0x24
109864: 2b00 cmp r3, #0
109866: dd51 ble.n 10990c <_IO_Vprintf+0x7b8> <== ALWAYS TAKEN
109868: 1e73 subs r3, r6, #1
10986a: 2200 movs r2, #0
10986c: f813 1f01 ldrb.w r1, [r3, #1]!
109870: 2900 cmp r1, #0
109872: f43f aeeb beq.w 10964c <_IO_Vprintf+0x4f8> <== ALWAYS TAKEN
109876: 9809 ldr r0, [sp, #36] ; 0x24
109878: 1c51 adds r1, r2, #1
10987a: 4281 cmp r1, r0
10987c: d036 beq.n 1098ec <_IO_Vprintf+0x798>
10987e: 460a mov r2, r1
109880: f813 1f01 ldrb.w r1, [r3, #1]!
109884: 2900 cmp r1, #0
109886: f43f aee1 beq.w 10964c <_IO_Vprintf+0x4f8>
10988a: e7f4 b.n 109876 <_IO_Vprintf+0x722>
while (width--)
10988c: 9b06 ldr r3, [sp, #24] <== NOT EXECUTED
10988e: f8dd 8028 ldr.w r8, [sp, #40] ; 0x28 <== NOT EXECUTED
109892: 1e9e subs r6, r3, #2 <== NOT EXECUTED
109894: 4637 mov r7, r6 <== NOT EXECUTED
PCHAR(padc);
109896: 4640 mov r0, r8 <== NOT EXECUTED
while (width--)
109898: 3f01 subs r7, #1 <== NOT EXECUTED
PCHAR(padc);
10989a: 4659 mov r1, fp <== NOT EXECUTED
10989c: 47c8 blx r9 <== NOT EXECUTED
while (width--)
10989e: 1c78 adds r0, r7, #1 <== NOT EXECUTED
1098a0: d1f9 bne.n 109896 <_IO_Vprintf+0x742> <== NOT EXECUTED
PCHAR(va_arg(ap, int));
1098a2: 9a02 ldr r2, [sp, #8] <== NOT EXECUTED
1098a4: eb06 030a add.w r3, r6, sl <== NOT EXECUTED
1098a8: 4659 mov r1, fp <== NOT EXECUTED
1098aa: 9502 str r5, [sp, #8] <== NOT EXECUTED
1098ac: f103 0802 add.w r8, r3, #2 <== NOT EXECUTED
1098b0: 6810 ldr r0, [r2, #0] <== NOT EXECUTED
1098b2: 47c8 blx r9 <== NOT EXECUTED
if (ladjust && width > 0)
1098b4: e506 b.n 1092c4 <_IO_Vprintf+0x170> <== NOT EXECUTED
ladjust = !ladjust;
1098b6: 9805 ldr r0, [sp, #20] <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
1098b8: 7862 ldrb r2, [r4, #1] <== NOT EXECUTED
1098ba: 460c mov r4, r1 <== NOT EXECUTED
width = va_arg(ap, int);
1098bc: 9302 str r3, [sp, #8] <== NOT EXECUTED
1098be: f080 0001 eor.w r0, r0, #1 <== NOT EXECUTED
1098c2: 9005 str r0, [sp, #20] <== NOT EXECUTED
width = -width;
1098c4: 9806 ldr r0, [sp, #24] <== NOT EXECUTED
1098c6: 4240 negs r0, r0 <== NOT EXECUTED
1098c8: 9006 str r0, [sp, #24] <== NOT EXECUTED
1098ca: e47a b.n 1091c2 <_IO_Vprintf+0x6e> <== NOT EXECUTED
while (width-- > 0)
1098cc: 9e06 ldr r6, [sp, #24]
1098ce: e5a4 b.n 10941a <_IO_Vprintf+0x2c6>
stop = 1;
1098d0: 2301 movs r3, #1 <== NOT EXECUTED
while (percent < fmt)
1098d2: 46d0 mov r8, sl <== NOT EXECUTED
stop = 1;
1098d4: 9300 str r3, [sp, #0] <== NOT EXECUTED
1098d6: e4f5 b.n 1092c4 <_IO_Vprintf+0x170> <== NOT EXECUTED
1098d8: 2300 movs r3, #0
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
1098da: 9304 str r3, [sp, #16]
1098dc: e536 b.n 10934c <_IO_Vprintf+0x1f8>
n = n * 10 + ch - '0';
1098de: 2300 movs r3, #0 <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
1098e0: 460c mov r4, r1 <== NOT EXECUTED
n = n * 10 + ch - '0';
1098e2: 9309 str r3, [sp, #36] ; 0x24 <== NOT EXECUTED
1098e4: e46d b.n 1091c2 <_IO_Vprintf+0x6e> <== NOT EXECUTED
PCHAR(padc);
1098e6: 46d0 mov r8, sl <== NOT EXECUTED
while (n--)
1098e8: 9200 str r2, [sp, #0] <== NOT EXECUTED
1098ea: e4eb b.n 1092c4 <_IO_Vprintf+0x170> <== NOT EXECUTED
width -= n;
1098ec: 9b06 ldr r3, [sp, #24]
1098ee: 9909 ldr r1, [sp, #36] ; 0x24
1098f0: 1a5b subs r3, r3, r1
if (!ladjust && width > 0)
1098f2: 2b00 cmp r3, #0
width -= n;
1098f4: 9306 str r3, [sp, #24]
if (!ladjust && width > 0)
1098f6: bfd4 ite le
1098f8: 2500 movle r5, #0
1098fa: 2501 movgt r5, #1
1098fc: b10d cbz r5, 109902 <_IO_Vprintf+0x7ae>
1098fe: 9b04 ldr r3, [sp, #16] <== NOT EXECUTED
109900: b99b cbnz r3, 10992a <_IO_Vprintf+0x7d6> <== NOT EXECUTED
if (ladjust && width > 0)
109902: 9b05 ldr r3, [sp, #20]
109904: 4617 mov r7, r2
109906: 402b ands r3, r5
109908: 461d mov r5, r3
10990a: e6b0 b.n 10966e <_IO_Vprintf+0x51a>
if (!ladjust && width > 0)
10990c: 9b06 ldr r3, [sp, #24] <== NOT EXECUTED
10990e: 2b00 cmp r3, #0 <== NOT EXECUTED
109910: bfd4 ite le <== NOT EXECUTED
109912: 2500 movle r5, #0 <== NOT EXECUTED
109914: 2501 movgt r5, #1 <== NOT EXECUTED
109916: b11d cbz r5, 109920 <_IO_Vprintf+0x7cc> <== NOT EXECUTED
109918: 9b04 ldr r3, [sp, #16] <== NOT EXECUTED
10991a: 2b00 cmp r3, #0 <== NOT EXECUTED
10991c: f47f af7e bne.w 10981c <_IO_Vprintf+0x6c8> <== NOT EXECUTED
if (ladjust && width > 0)
109920: 9b05 ldr r3, [sp, #20] <== NOT EXECUTED
109922: 46d0 mov r8, sl <== NOT EXECUTED
109924: 402b ands r3, r5 <== NOT EXECUTED
109926: 461d mov r5, r3 <== NOT EXECUTED
109928: e6af b.n 10968a <_IO_Vprintf+0x536> <== NOT EXECUTED
if (!ladjust && width > 0)
10992a: 4617 mov r7, r2 <== NOT EXECUTED
10992c: 9a09 ldr r2, [sp, #36] ; 0x24 <== NOT EXECUTED
10992e: e778 b.n 109822 <_IO_Vprintf+0x6ce> <== NOT EXECUTED
0010d49c <_Memory_Allocate>:
void *_Memory_Allocate(
const Memory_Information *information,
uintptr_t size,
uintptr_t alignment
)
{
10d49c: b530 push {r4, r5, lr}
Memory_Area *area;
const Memory_Area *end;
uintptr_t alignment_mask;
area = &information->areas[ 0 ];
10d49e: e9d0 4300 ldrd r4, r3, [r0]
end = &information->areas[ information->count ];
10d4a2: eb04 0444 add.w r4, r4, r4, lsl #1
10d4a6: eb03 0c84 add.w ip, r3, r4, lsl #2
alignment_mask = alignment - 1;
while ( area != end ) {
10d4aa: 4563 cmp r3, ip
10d4ac: d010 beq.n 10d4d0 <_Memory_Allocate+0x34> <== ALWAYS TAKEN
10d4ae: f102 3eff add.w lr, r2, #4294967295 ; 0xffffffff
10d4b2: 4254 negs r4, r2
10d4b4: e002 b.n 10d4bc <_Memory_Allocate+0x20>
area->free = (void *) alloc_end;
return (void *) alloc_begin;
}
++area;
10d4b6: 330c adds r3, #12 <== NOT EXECUTED
while ( area != end ) {
10d4b8: 459c cmp ip, r3 <== NOT EXECUTED
10d4ba: d009 beq.n 10d4d0 <_Memory_Allocate+0x34> <== NOT EXECUTED
alloc_begin = (uintptr_t) area->free;
10d4bc: 6858 ldr r0, [r3, #4]
alloc_begin += alignment_mask;
10d4be: 4470 add r0, lr
alloc_begin &= ~alignment_mask;
10d4c0: 4020 ands r0, r4
alloc_end = alloc_begin + size;
10d4c2: 1842 adds r2, r0, r1
10d4c4: d2f7 bcs.n 10d4b6 <_Memory_Allocate+0x1a> <== ALWAYS TAKEN
if ( alloc_begin <= alloc_end && alloc_end <= (uintptr_t) area->end ) {
10d4c6: 689d ldr r5, [r3, #8]
10d4c8: 4295 cmp r5, r2
10d4ca: d3f4 bcc.n 10d4b6 <_Memory_Allocate+0x1a> <== ALWAYS TAKEN
area->free = (void *) alloc_end;
10d4cc: 605a str r2, [r3, #4]
}
return NULL;
}
10d4ce: bd30 pop {r4, r5, pc}
return NULL;
10d4d0: 2000 movs r0, #0 <== NOT EXECUTED
}
10d4d2: bd30 pop {r4, r5, pc} <== NOT EXECUTED
00106980 <_Memory_Fill>:
#include <rtems/score/memory.h>
#include <string.h>
void _Memory_Fill( const Memory_Information *information, int c )
{
106980: b570 push {r4, r5, r6, lr}
Memory_Area *area;
const Memory_Area *end;
area = &information->areas[ 0 ];
106982: e9d0 5400 ldrd r5, r4, [r0]
end = &information->areas[ information->count ];
106986: eb05 0545 add.w r5, r5, r5, lsl #1
10698a: eb04 0585 add.w r5, r4, r5, lsl #2
while ( area != end ) {
10698e: 42ac cmp r4, r5
106990: d009 beq.n 1069a6 <_Memory_Fill+0x26> <== ALWAYS TAKEN
106992: 460e mov r6, r1
*
* @return The free memory area size in bytes of the memory area.
*/
RTEMS_INLINE_ROUTINE uintptr_t _Memory_Get_free_size( const Memory_Area *area )
{
return (uintptr_t) area->end - (uintptr_t) area->free;
106994: e9d4 0201 ldrd r0, r2, [r4, #4]
memset( _Memory_Get_free_begin( area ), c, _Memory_Get_free_size( area ) );
106998: 4631 mov r1, r6
++area;
10699a: 340c adds r4, #12
memset( _Memory_Get_free_begin( area ), c, _Memory_Get_free_size( area ) );
10699c: 1a12 subs r2, r2, r0
10699e: f005 fabf bl 10bf20 <memset>
while ( area != end ) {
1069a2: 42a5 cmp r5, r4
1069a4: d1f6 bne.n 106994 <_Memory_Fill+0x14> <== ALWAYS TAKEN
}
}
1069a6: bd70 pop {r4, r5, r6, pc}
00109b24 <_Objects_Extend_information>:
#include <string.h> /* for memcpy() */
Objects_Maximum _Objects_Extend_information(
Objects_Information *information
)
{
109b24: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
109b28: 4680 mov r8, r0
*/
RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Get_maximum_index(
const Objects_Information *information
)
{
return _Objects_Get_index( information->maximum_id );
109b2a: f8d0 9000 ldr.w r9, [r0]
109b2e: b089 sub sp, #36 ; 0x24
return information->objects_per_block;
109b30: f8b0 b012 ldrh.w fp, [r0, #18]
*/
do_extend = true;
index_base = extend_count;
block = 1;
if ( information->object_blocks == NULL ) {
109b34: f8d8 5028 ldr.w r5, [r8, #40] ; 0x28
109b38: fa1f f389 uxth.w r3, r9
RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Get_index(
Objects_Id id
)
{
return
(Objects_Maximum)((id >> OBJECTS_INDEX_START_BIT) &
109b3c: 4618 mov r0, r3
109b3e: 9303 str r3, [sp, #12]
109b40: 9302 str r3, [sp, #8]
new_maximum = (uint32_t) old_maximum + extend_count;
109b42: 445b add r3, fp
109b44: ea4f 044b mov.w r4, fp, lsl #1
109b48: 9301 str r3, [sp, #4]
if ( information->object_blocks == NULL ) {
109b4a: 2d00 cmp r5, #0
109b4c: d05b beq.n 109c06 <_Objects_Extend_information+0xe2>
block_count = 1;
} else {
block_count = old_maximum / extend_count;
109b4e: 4659 mov r1, fp
109b50: f00a fa9e bl 114090 <__udivsi3>
109b54: fa1f fa80 uxth.w sl, r0
for ( ; block < block_count; block++ ) {
109b58: f1ba 0f01 cmp.w sl, #1
109b5c: f240 80ba bls.w 109cd4 <_Objects_Extend_information+0x1b0> <== ALWAYS TAKEN
109b60: 462a mov r2, r5
index_base = extend_count;
109b62: 465c mov r4, fp
block = 1;
109b64: 2601 movs r6, #1
109b66: e002 b.n 109b6e <_Objects_Extend_information+0x4a>
for ( ; block < block_count; block++ ) {
109b68: 3601 adds r6, #1
109b6a: 45b2 cmp sl, r6
109b6c: d047 beq.n 109bfe <_Objects_Extend_information+0xda>
if ( information->object_blocks[ block ] == NULL ) {
109b6e: f852 0f04 ldr.w r0, [r2, #4]!
109b72: 4627 mov r7, r4
do_extend = false;
break;
} else
index_base += extend_count;
109b74: 445c add r4, fp
if ( information->object_blocks[ block ] == NULL ) {
109b76: 2800 cmp r0, #0
109b78: d1f6 bne.n 109b68 <_Objects_Extend_information+0x44>
do_extend = false;
109b7a: 4602 mov r2, r0
/*
* 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 ( new_maximum > OBJECTS_ID_FINAL_INDEX ) {
109b7c: 9b01 ldr r3, [sp, #4]
109b7e: f5b3 3f80 cmp.w r3, #65536 ; 0x10000
109b82: d238 bcs.n 109bf6 <_Objects_Extend_information+0xd2>
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
object_block_size = extend_count * information->object_size;
109b84: f8b8 0014 ldrh.w r0, [r8, #20]
109b88: 9204 str r2, [sp, #16]
new_object_block = _Workspace_Allocate( object_block_size );
109b8a: fb0b f000 mul.w r0, fp, r0
109b8e: f001 fec3 bl 10b918 <_Workspace_Allocate>
if ( new_object_block == NULL ) {
109b92: 4605 mov r5, r0
109b94: b378 cbz r0, 109bf6 <_Objects_Extend_information+0xd2>
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
109b96: 9a04 ldr r2, [sp, #16]
api_class_and_node = information->maximum_id & ~OBJECTS_INDEX_MASK;
109b98: ea4f 4319 mov.w r3, r9, lsr #16
109b9c: 041b lsls r3, r3, #16
if ( do_extend ) {
109b9e: bbba cbnz r2, 109c10 <_Objects_Extend_information+0xec>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
109ba0: f8d8 2028 ldr.w r2, [r8, #40] ; 0x28
/*
* Append to inactive chain.
*/
the_object = new_object_block;
for ( index = index_base ; index < index_end ; ++index ) {
109ba4: 42a7 cmp r7, r4
information->inactive_per_block[ block ] = information->objects_per_block;
109ba6: f8b8 1012 ldrh.w r1, [r8, #18]
return &the_chain->Tail.Node;
109baa: bf38 it cc
109bac: f108 001c addcc.w r0, r8, #28
information->object_blocks[ block ] = new_object_block;
109bb0: f842 5026 str.w r5, [r2, r6, lsl #2]
information->inactive_per_block[ block ] = information->objects_per_block;
109bb4: f8d8 2024 ldr.w r2, [r8, #36] ; 0x24
109bb8: f822 1016 strh.w r1, [r2, r6, lsl #1]
information->inactive += information->objects_per_block;
109bbc: f8b8 2010 ldrh.w r2, [r8, #16]
109bc0: f8b8 1012 ldrh.w r1, [r8, #18]
| ( ( index + OBJECTS_INDEX_MINIMUM ) << OBJECTS_INDEX_START_BIT );
_Chain_Initialize_node( &the_object->Node );
_Chain_Append_unprotected( &information->Inactive, &the_object->Node );
the_object = _Addresses_Add_offset( the_object, information->object_size );
109bc4: bf38 it cc
109bc6: f8b8 c014 ldrhcc.w ip, [r8, #20]
information->inactive += information->objects_per_block;
109bca: 440a add r2, r1
109bcc: f8a8 2010 strh.w r2, [r8, #16]
for ( index = index_base ; index < index_end ; ++index ) {
109bd0: d20d bcs.n 109bee <_Objects_Extend_information+0xca> <== ALWAYS TAKEN
old_last = tail->previous;
109bd2: f8d8 2020 ldr.w r2, [r8, #32]
| ( ( index + OBJECTS_INDEX_MINIMUM ) << OBJECTS_INDEX_START_BIT );
109bd6: 3701 adds r7, #1
for ( index = index_base ; index < index_end ; ++index ) {
109bd8: 42a7 cmp r7, r4
| ( ( index + OBJECTS_INDEX_MINIMUM ) << OBJECTS_INDEX_START_BIT );
109bda: ea47 0103 orr.w r1, r7, r3
the_node->next = tail;
109bde: 6028 str r0, [r5, #0]
the_object->id = api_class_and_node
109be0: 60a9 str r1, [r5, #8]
tail->previous = the_node;
109be2: f8c8 5020 str.w r5, [r8, #32]
old_last->next = the_node;
109be6: 6015 str r5, [r2, #0]
the_node->previous = old_last;
109be8: 606a str r2, [r5, #4]
109bea: 4465 add r5, ip
for ( index = index_base ; index < index_end ; ++index ) {
109bec: d1f1 bne.n 109bd2 <_Objects_Extend_information+0xae>
}
return block;
109bee: b2b0 uxth r0, r6
}
109bf0: b009 add sp, #36 ; 0x24
109bf2: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return 0;
109bf6: 2000 movs r0, #0
}
109bf8: b009 add sp, #36 ; 0x24
109bfa: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
index_base += extend_count;
109bfe: 4627 mov r7, r4
do_extend = true;
109c00: 2201 movs r2, #1
index_end = index_base + extend_count;
109c02: 445c add r4, fp
109c04: e7ba b.n 109b7c <_Objects_Extend_information+0x58>
do_extend = true;
109c06: 2201 movs r2, #1
index_base = extend_count;
109c08: 465f mov r7, fp
block = 1;
109c0a: 4616 mov r6, r2
block_count = 1;
109c0c: 4692 mov sl, r2
109c0e: e7b5 b.n 109b7c <_Objects_Extend_information+0x58>
block_count++;
109c10: 9307 str r3, [sp, #28]
109c12: f10a 0c01 add.w ip, sl, #1
local_table_size = new_maximum * sizeof( *local_table );
109c16: 9b01 ldr r3, [sp, #4]
table_size = object_blocks_size
109c18: eb0c 004c add.w r0, ip, ip, lsl #1
local_table_size = new_maximum * sizeof( *local_table );
109c1c: 009a lsls r2, r3, #2
object_blocks_size = block_count * sizeof( *object_blocks );
109c1e: ea4f 038c mov.w r3, ip, lsl #2
object_blocks = _Workspace_Allocate( table_size );
109c22: eb02 0040 add.w r0, r2, r0, lsl #1
object_blocks_size = block_count * sizeof( *object_blocks );
109c26: 9305 str r3, [sp, #20]
object_blocks = _Workspace_Allocate( table_size );
109c28: 9206 str r2, [sp, #24]
109c2a: f001 fe75 bl 10b918 <_Workspace_Allocate>
if ( object_blocks == NULL ) {
109c2e: e9dd 2306 ldrd r2, r3, [sp, #24]
109c32: 9004 str r0, [sp, #16]
109c34: 2800 cmp r0, #0
109c36: d051 beq.n 109cdc <_Objects_Extend_information+0x1b8> <== ALWAYS TAKEN
109c38: 9904 ldr r1, [sp, #16]
109c3a: 468c mov ip, r1
109c3c: 9905 ldr r1, [sp, #20]
109c3e: eb0c 0901 add.w r9, ip, r1
109c42: 444a add r2, r9
109c44: 9206 str r2, [sp, #24]
if ( old_maximum > extend_count ) {
109c46: 9a02 ldr r2, [sp, #8]
109c48: 4593 cmp fp, r2
109c4a: d334 bcc.n 109cb6 <_Objects_Extend_information+0x192>
object_blocks[ 0 ] = NULL;
109c4c: 9904 ldr r1, [sp, #16]
109c4e: 2200 movs r2, #0
109c50: 600a str r2, [r1, #0]
inactive_per_block[ 0 ] = 0;
109c52: 9901 ldr r1, [sp, #4]
109c54: f829 2021 strh.w r2, [r9, r1, lsl #2]
memcpy(
109c58: 9302 str r3, [sp, #8]
109c5a: 4648 mov r0, r9
109c5c: 9b03 ldr r3, [sp, #12]
109c5e: f8d8 1004 ldr.w r1, [r8, #4]
109c62: 009a lsls r2, r3, #2
109c64: f00b e98c blx 114f80 <memcpy>
for ( index = index_base ; index < index_end ; ++index ) {
109c68: 42a7 cmp r7, r4
109c6a: 9b02 ldr r3, [sp, #8]
109c6c: d208 bcs.n 109c80 <_Objects_Extend_information+0x15c> <== ALWAYS TAKEN
local_table[ index ] = NULL;
109c6e: 1be2 subs r2, r4, r7
109c70: eb09 0087 add.w r0, r9, r7, lsl #2
109c74: 0092 lsls r2, r2, #2
109c76: 2100 movs r1, #0
109c78: 9302 str r3, [sp, #8]
109c7a: f00b fbf1 bl 115460 <memset>
109c7e: 9b02 ldr r3, [sp, #8]
__asm__ volatile (
109c80: f3ef 8200 mrs r2, CPSR
109c84: f042 0180 orr.w r1, r2, #128 ; 0x80
109c88: f381 8900 msr CPSR_fc, r1
information->inactive_per_block = inactive_per_block;
109c8c: 9906 ldr r1, [sp, #24]
old_tables = information->object_blocks;
109c8e: f8d8 0028 ldr.w r0, [r8, #40] ; 0x28
information->local_table = local_table;
109c92: f8c8 9004 str.w r9, [r8, #4]
information->inactive_per_block = inactive_per_block;
109c96: f8c8 1024 str.w r1, [r8, #36] ; 0x24
| (new_maximum << OBJECTS_INDEX_START_BIT);
109c9a: 9901 ldr r1, [sp, #4]
109c9c: 9301 str r3, [sp, #4]
109c9e: 4319 orrs r1, r3
information->object_blocks = object_blocks;
109ca0: 9b04 ldr r3, [sp, #16]
information->maximum_id = api_class_and_node
109ca2: f8c8 1000 str.w r1, [r8]
information->object_blocks = object_blocks;
109ca6: f8c8 3028 str.w r3, [r8, #40] ; 0x28
__asm__ volatile (
109caa: f382 8900 msr CPSR_fc, r2
_Workspace_Free( old_tables );
109cae: f001 fe3d bl 10b92c <_Workspace_Free>
block_count++;
109cb2: 9b01 ldr r3, [sp, #4]
109cb4: e774 b.n 109ba0 <_Objects_Extend_information+0x7c>
memcpy(
109cb6: 1f0a subs r2, r1, #4
109cb8: f8d8 1028 ldr.w r1, [r8, #40] ; 0x28
109cbc: 9302 str r3, [sp, #8]
109cbe: f00b e960 blx 114f80 <memcpy>
memcpy(
109cc2: f8d8 1024 ldr.w r1, [r8, #36] ; 0x24
109cc6: ea4f 024a mov.w r2, sl, lsl #1
109cca: 9806 ldr r0, [sp, #24]
109ccc: f00b e958 blx 114f80 <memcpy>
109cd0: 9b02 ldr r3, [sp, #8]
109cd2: e7c1 b.n 109c58 <_Objects_Extend_information+0x134>
do_extend = true;
109cd4: 2201 movs r2, #1 <== NOT EXECUTED
index_base = extend_count;
109cd6: 465f mov r7, fp <== NOT EXECUTED
block = 1;
109cd8: 4616 mov r6, r2 <== NOT EXECUTED
109cda: e74f b.n 109b7c <_Objects_Extend_information+0x58> <== NOT EXECUTED
_Workspace_Free( new_object_block );
109cdc: 4628 mov r0, r5 <== NOT EXECUTED
109cde: f001 fe25 bl 10b92c <_Workspace_Free> <== NOT EXECUTED
return 0;
109ce2: 9804 ldr r0, [sp, #16] <== NOT EXECUTED
109ce4: e784 b.n 109bf0 <_Objects_Extend_information+0xcc> <== NOT EXECUTED
109ce6: bf00 nop
00109d48 <_Objects_Free_objects_block>:
void _Objects_Free_objects_block(
Objects_Information *information,
Objects_Maximum block
)
{
109d48: b5f8 push {r3, r4, r5, r6, r7, lr}
return &the_chain->Tail.Node;
109d4a: f100 0e1c add.w lr, r0, #28
Objects_Maximum index_base;
Objects_Maximum index_end;
Chain_Node *node;
const Chain_Node *tail;
objects_per_block = information->objects_per_block;
109d4e: 8a47 ldrh r7, [r0, #18]
{
109d50: 4604 mov r4, r0
109d52: 460e mov r6, r1
return _Chain_Immutable_head( the_chain )->next;
109d54: 6983 ldr r3, [r0, #24]
_Assert( block >= 1 );
_Assert(
block < _Objects_Get_maximum_index( information ) / objects_per_block
);
index_base = block * objects_per_block;
109d56: fb17 fc01 smulbb ip, r7, r1
index_end = index_base + objects_per_block;
node = _Chain_First( &information->Inactive );
tail = _Chain_Immutable_tail( &information->Inactive );
while ( node != tail ) {
109d5a: 4573 cmp r3, lr
index_base = block * objects_per_block;
109d5c: fa1f fc8c uxth.w ip, ip
index_end = index_base + objects_per_block;
109d60: eb07 050c add.w r5, r7, ip
while ( node != tail ) {
109d64: bf18 it ne
109d66: b2ad uxthne r5, r5
109d68: d00c beq.n 109d84 <_Objects_Free_objects_block+0x3c> <== ALWAYS TAKEN
Objects_Control *object;
uint32_t index;
object = (Objects_Control *) node;
index = _Objects_Get_index( object->id ) - OBJECTS_INDEX_MINIMUM;
109d6a: 891a ldrh r2, [r3, #8]
109d6c: 4618 mov r0, r3
return the_node->next;
109d6e: 681b ldr r3, [r3, #0]
109d70: 3a01 subs r2, #1
/*
* Get the next node before the node is extracted
*/
node = _Chain_Next( node );
if ( index >= index_base && index < index_end ) {
109d72: 4562 cmp r2, ip
109d74: d304 bcc.n 109d80 <_Objects_Free_objects_block+0x38>
109d76: 4295 cmp r5, r2
previous = the_node->previous;
109d78: bf82 ittt hi
109d7a: 6842 ldrhi r2, [r0, #4]
next->previous = previous;
109d7c: 605a strhi r2, [r3, #4]
previous->next = next;
109d7e: 6013 strhi r3, [r2, #0]
while ( node != tail ) {
109d80: 4573 cmp r3, lr
109d82: d1f2 bne.n 109d6a <_Objects_Free_objects_block+0x22>
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
109d84: 6aa3 ldr r3, [r4, #40] ; 0x28
109d86: f853 0026 ldr.w r0, [r3, r6, lsl #2]
109d8a: f001 fdcf bl 10b92c <_Workspace_Free>
information->object_blocks[ block ] = NULL;
109d8e: 6aa2 ldr r2, [r4, #40] ; 0x28
109d90: 2300 movs r3, #0
109d92: f842 3026 str.w r3, [r2, r6, lsl #2]
information->inactive_per_block[ block ] = 0;
109d96: 6a62 ldr r2, [r4, #36] ; 0x24
109d98: f822 3016 strh.w r3, [r2, r6, lsl #1]
information->inactive -= objects_per_block;
109d9c: 8a23 ldrh r3, [r4, #16]
109d9e: 1bdf subs r7, r3, r7
109da0: 8227 strh r7, [r4, #16]
}
109da2: bdf8 pop {r3, r4, r5, r6, r7, pc}
00109a1c <_Objects_Get_name_as_string>:
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
109a1c: 2a00 cmp r2, #0
109a1e: bf18 it ne
109a20: 2900 cmpne r1, #0
109a22: d02e beq.n 109a82 <_Objects_Get_name_as_string+0x66>
{
109a24: b5f0 push {r4, r5, r6, r7, lr}
109a26: 4605 mov r5, r0
109a28: b083 sub sp, #12
109a2a: 460e mov r6, r1
109a2c: 4614 mov r4, r2
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id;
109a2e: b1c8 cbz r0, 109a64 <_Objects_Get_name_as_string+0x48>
information = _Objects_Get_information_id( tmpId );
109a30: 4628 mov r0, r5
109a32: f003 fd57 bl 10d4e4 <_Objects_Get_information_id>
if ( !information )
109a36: 4607 mov r7, r0
109a38: b300 cbz r0, 109a7c <_Objects_Get_name_as_string+0x60>
return NULL;
the_object = _Objects_Get( tmpId, &lock_context, information );
109a3a: 4602 mov r2, r0
109a3c: a901 add r1, sp, #4
109a3e: 4628 mov r0, r5
109a40: f7ff ff9c bl 10997c <_Objects_Get>
if ( the_object == NULL ) {
109a44: b1d0 cbz r0, 109a7c <_Objects_Get_name_as_string+0x60>
return information->name_length > 0;
109a46: 8af9 ldrh r1, [r7, #22]
return NULL;
}
_Objects_Name_to_string(
109a48: 4633 mov r3, r6
109a4a: 4622 mov r2, r4
109a4c: 68c0 ldr r0, [r0, #12]
109a4e: 3900 subs r1, #0
109a50: bf18 it ne
109a52: 2101 movne r1, #1
109a54: f7ff ffb0 bl 1099b8 <_Objects_Name_to_string>
__asm__ volatile (
109a58: 9b01 ldr r3, [sp, #4]
109a5a: f383 8900 msr CPSR_fc, r3
name,
length
);
_ISR_lock_ISR_enable( &lock_context );
return name;
109a5e: 4620 mov r0, r4
}
109a60: b003 add sp, #12
109a62: bdf0 pop {r4, r5, r6, r7, pc}
109a64: f243 1340 movw r3, #12608 ; 0x3140
109a68: f2c0 0320 movt r3, #32
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id;
109a6c: 699b ldr r3, [r3, #24]
109a6e: 689d ldr r5, [r3, #8]
information = _Objects_Get_information_id( tmpId );
109a70: 4628 mov r0, r5
109a72: f003 fd37 bl 10d4e4 <_Objects_Get_information_id>
if ( !information )
109a76: 4607 mov r7, r0
109a78: 2800 cmp r0, #0
109a7a: d1de bne.n 109a3a <_Objects_Get_name_as_string+0x1e> <== NEVER TAKEN
return NULL;
109a7c: 2000 movs r0, #0
}
109a7e: b003 add sp, #12
109a80: bdf0 pop {r4, r5, r6, r7, pc}
return NULL;
109a82: 2000 movs r0, #0
}
109a84: 4770 bx lr
109a86: bf00 nop
001106bc <_Objects_Name_to_string>:
Objects_Name name,
bool is_string,
char *buffer,
size_t buffer_size
)
{
1106bc: b510 push {r4, lr}
1106be: b082 sub sp, #8
char lname[ 5 ];
const char *s;
char *d;
size_t i;
if ( is_string ) {
1106c0: b1f1 cbz r1, 110700 <_Objects_Name_to_string+0x44>
}
d = buffer;
i = 1;
if ( s != NULL ) {
1106c2: b928 cbnz r0, 1106d0 <_Objects_Name_to_string+0x14> <== NOT EXECUTED
while ( *s != '\0' ) {
if ( i < buffer_size ) {
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
1106c4: 2000 movs r0, #0
++s;
++i;
}
}
if ( buffer_size > 0 ) {
1106c6: b10b cbz r3, 1106cc <_Objects_Name_to_string+0x10>
*d = '\0';
1106c8: 2300 movs r3, #0
1106ca: 7013 strb r3, [r2, #0]
}
return i - 1;
}
1106cc: b002 add sp, #8
1106ce: bd10 pop {r4, pc}
while ( *s != '\0' ) {
1106d0: 7804 ldrb r4, [r0, #0] <== NOT EXECUTED
s = name.name_p;
1106d2: 4684 mov ip, r0 <== NOT EXECUTED
while ( *s != '\0' ) {
1106d4: 2c00 cmp r4, #0
1106d6: d0f5 beq.n 1106c4 <_Objects_Name_to_string+0x8>
1106d8: 2001 movs r0, #1
1106da: e000 b.n 1106de <_Objects_Name_to_string+0x22>
++i;
1106dc: 4670 mov r0, lr
if ( i < buffer_size ) {
1106de: 4283 cmp r3, r0
return uc >= ' ' && uc <= '~';
1106e0: f1a4 0120 sub.w r1, r4, #32
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
1106e4: b2c9 uxtb r1, r1
++i;
1106e6: f100 0e01 add.w lr, r0, #1
if ( i < buffer_size ) {
1106ea: d904 bls.n 1106f6 <_Objects_Name_to_string+0x3a>
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
1106ec: 295f cmp r1, #95 ; 0x5f
1106ee: bf28 it cs
1106f0: 242a movcs r4, #42 ; 0x2a
1106f2: f802 4b01 strb.w r4, [r2], #1
while ( *s != '\0' ) {
1106f6: f81c 4f01 ldrb.w r4, [ip, #1]!
1106fa: 2c00 cmp r4, #0
1106fc: d1ee bne.n 1106dc <_Objects_Name_to_string+0x20>
1106fe: e7e2 b.n 1106c6 <_Objects_Name_to_string+0xa>
lname[ 0 ] = (name.name_u32 >> 24) & 0xff;
110700: 0e04 lsrs r4, r0, #24
lname[ 4 ] = '\0';
110702: f88d 1004 strb.w r1, [sp, #4]
lname[ 3 ] = (name.name_u32 >> 0) & 0xff;
110706: f88d 0003 strb.w r0, [sp, #3]
lname[ 1 ] = (name.name_u32 >> 16) & 0xff;
11070a: 0c01 lsrs r1, r0, #16
lname[ 2 ] = (name.name_u32 >> 8) & 0xff;
11070c: 0a00 lsrs r0, r0, #8
s = lname;
11070e: 46ec mov ip, sp
lname[ 0 ] = (name.name_u32 >> 24) & 0xff;
110710: f88d 4000 strb.w r4, [sp]
lname[ 1 ] = (name.name_u32 >> 16) & 0xff;
110714: f88d 1001 strb.w r1, [sp, #1]
lname[ 2 ] = (name.name_u32 >> 8) & 0xff;
110718: f88d 0002 strb.w r0, [sp, #2]
if ( s != NULL ) {
11071c: e7da b.n 1106d4 <_Objects_Name_to_string+0x18>
11071e: bf00 nop
00106ec0 <_Objects_Set_name>:
106ec0: 8ac3 ldrh r3, [r0, #22]
Status_Control _Objects_Set_name(
const Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
106ec2: b530 push {r4, r5, lr}
106ec4: 460d mov r5, r1
106ec6: b083 sub sp, #12
106ec8: 4614 mov r4, r2
if ( _Objects_Has_string_name( information ) ) {
106eca: b193 cbz r3, 106ef2 <_Objects_Set_name+0x32>
size_t length;
char *dup;
length = strnlen( name, information->name_length );
106ecc: 4619 mov r1, r3
106ece: 4610 mov r0, r2
106ed0: f006 fd04 bl 10d8dc <strnlen>
106ed4: 4601 mov r1, r0
dup = _Workspace_String_duplicate( name, length );
106ed6: 4620 mov r0, r4
106ed8: f001 fbf6 bl 1086c8 <_Workspace_String_duplicate>
if ( dup == NULL ) {
106edc: 4604 mov r4, r0
return STATUS_NO_MEMORY;
106ede: f241 601a movw r0, #5658 ; 0x161a
if ( dup == NULL ) {
106ee2: b124 cbz r4, 106eee <_Objects_Set_name+0x2e>
}
_Workspace_Free( RTEMS_DECONST( char *, the_object->name.name_p ) );
106ee4: 68e8 ldr r0, [r5, #12] <== NOT EXECUTED
106ee6: f001 fbe7 bl 1086b8 <_Workspace_Free> <== NOT EXECUTED
the_object->name.name_u32 =
_Objects_Build_name( c[ 0 ], c[ 1 ], c[ 2 ], c[ 3 ] );
}
return STATUS_SUCCESSFUL;
106eea: 2000 movs r0, #0 <== NOT EXECUTED
the_object->name.name_p = dup;
106eec: 60ec str r4, [r5, #12] <== NOT EXECUTED
}
106eee: b003 add sp, #12
106ef0: bd30 pop {r4, r5, pc}
memset( c, ' ', sizeof( c ) );
106ef2: a901 add r1, sp, #4
106ef4: 3403 adds r4, #3
106ef6: 1e53 subs r3, r2, #1
106ef8: f04f 3220 mov.w r2, #538976288 ; 0x20202020
106efc: 9201 str r2, [sp, #4]
if ( name[ i ] == '\0') {
106efe: f813 2f01 ldrb.w r2, [r3, #1]!
106f02: b11a cbz r2, 106f0c <_Objects_Set_name+0x4c>
for ( i = 0; i < 4; ++i ) {
106f04: 42a3 cmp r3, r4
c[ i ] = name[ i ];
106f06: f801 2b01 strb.w r2, [r1], #1
for ( i = 0; i < 4; ++i ) {
106f0a: d1f8 bne.n 106efe <_Objects_Set_name+0x3e>
the_object->name.name_u32 =
106f0c: 9b01 ldr r3, [sp, #4]
return STATUS_SUCCESSFUL;
106f0e: 2000 movs r0, #0
106f10: ba1b rev r3, r3
the_object->name.name_u32 =
106f12: 60eb str r3, [r5, #12]
}
106f14: b003 add sp, #12
106f16: bd30 pop {r4, r5, pc}
00109da4 <_Objects_Shrink_information>:
void _Objects_Shrink_information(
Objects_Information *information
)
{
109da4: b570 push {r4, r5, r6, lr}
109da6: 4606 mov r6, r0
/*
* Search the list to find block or chunk with all objects inactive.
*/
objects_per_block = information->objects_per_block;
109da8: 8a45 ldrh r5, [r0, #18]
block_count = _Objects_Get_maximum_index( information ) / objects_per_block;
109daa: 8800 ldrh r0, [r0, #0]
109dac: 4629 mov r1, r5
109dae: f00a f96f bl 114090 <__udivsi3>
109db2: b284 uxth r4, r0
for ( block = 1; block < block_count; block++ ) {
109db4: 2c01 cmp r4, #1
109db6: d910 bls.n 109dda <_Objects_Shrink_information+0x36> <== ALWAYS TAKEN
if ( information->inactive_per_block[ block ] == objects_per_block ) {
109db8: 2301 movs r3, #1
109dba: 6a72 ldr r2, [r6, #36] ; 0x24
109dbc: 4619 mov r1, r3
109dbe: e002 b.n 109dc6 <_Objects_Shrink_information+0x22>
for ( block = 1; block < block_count; block++ ) {
109dc0: b299 uxth r1, r3
109dc2: 428c cmp r4, r1
109dc4: d909 bls.n 109dda <_Objects_Shrink_information+0x36> <== ALWAYS TAKEN
if ( information->inactive_per_block[ block ] == objects_per_block ) {
109dc6: f832 ef02 ldrh.w lr, [r2, #2]!
for ( block = 1; block < block_count; block++ ) {
109dca: 3301 adds r3, #1
if ( information->inactive_per_block[ block ] == objects_per_block ) {
109dcc: 45ae cmp lr, r5
109dce: d1f7 bne.n 109dc0 <_Objects_Shrink_information+0x1c>
_Objects_Free_objects_block( information, block );
109dd0: 4630 mov r0, r6
return;
}
}
}
109dd2: e8bd 4070 ldmia.w sp!, {r4, r5, r6, lr}
_Objects_Free_objects_block( information, block );
109dd6: f7ff bfb7 b.w 109d48 <_Objects_Free_objects_block>
}
109dda: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
0010e8b4 <_Once>:
.Mutex = RTEMS_MUTEX_INITIALIZER( "_Once" ),
.State = RTEMS_CONDITION_VARIABLE_INITIALIZER( "_Once" )
};
int _Once( unsigned char *once_state, void ( *init_routine )( void ) )
{
10e8b4: b5f8 push {r3, r4, r5, r6, r7, lr}
_Atomic_Fence( ATOMIC_ORDER_ACQUIRE );
if ( RTEMS_PREDICT_FALSE( *once_state != ONCE_STATE_COMPLETE ) ) {
10e8b6: 7803 ldrb r3, [r0, #0]
10e8b8: 2b02 cmp r3, #2
10e8ba: d101 bne.n 10e8c0 <_Once+0xc>
_Once_Unlock( thread_life_state );
}
return 0;
}
10e8bc: 2000 movs r0, #0
10e8be: bdf8 pop {r3, r4, r5, r6, r7, pc}
Thread_Life_state _Once_Lock( void )
{
Thread_Life_state thread_life_state;
thread_life_state = _Thread_Set_life_protection( THREAD_LIFE_PROTECTED );
10e8c0: 4604 mov r4, r0
10e8c2: 2001 movs r0, #1
10e8c4: 460d mov r5, r1
10e8c6: f7fc fe39 bl 10b53c <_Thread_Set_life_protection>
10e8ca: 4606 mov r6, r0
_Mutex_Acquire( mutex );
10e8cc: f240 3004 movw r0, #772 ; 0x304
10e8d0: f2c0 0020 movt r0, #32
10e8d4: f7fb fad2 bl 109e7c <_Mutex_Acquire>
if ( *once_state == ONCE_STATE_INIT ) {
10e8d8: 7823 ldrb r3, [r4, #0]
10e8da: b1bb cbz r3, 10e90c <_Once+0x58>
while ( *once_state != ONCE_STATE_COMPLETE ) {
10e8dc: 2b02 cmp r3, #2 <== NOT EXECUTED
10e8de: d00a beq.n 10e8f6 <_Once+0x42> <== NOT EXECUTED
_Condition_Wait( condition_variable, mutex );
10e8e0: f240 3504 movw r5, #772 ; 0x304 <== NOT EXECUTED
10e8e4: f2c0 0520 movt r5, #32 <== NOT EXECUTED
10e8e8: 4816 ldr r0, [pc, #88] ; (10e944 <_Once+0x90>) <== NOT EXECUTED
10e8ea: 4629 mov r1, r5 <== NOT EXECUTED
10e8ec: f7ff fd9a bl 10e424 <_Condition_Wait> <== NOT EXECUTED
10e8f0: 7823 ldrb r3, [r4, #0] <== NOT EXECUTED
10e8f2: 2b02 cmp r3, #2 <== NOT EXECUTED
10e8f4: d1f8 bne.n 10e8e8 <_Once+0x34> <== NOT EXECUTED
_Mutex_Release( mutex );
10e8f6: f240 3004 movw r0, #772 ; 0x304
10e8fa: f2c0 0020 movt r0, #32
10e8fe: f7fb fae9 bl 109ed4 <_Mutex_Release>
}
void _Once_Unlock( Thread_Life_state thread_life_state )
{
rtems_mutex_unlock( &_Once_Information.Mutex );
_Thread_Set_life_protection( thread_life_state );
10e902: 4630 mov r0, r6
10e904: f7fc fe1a bl 10b53c <_Thread_Set_life_protection>
}
10e908: 2000 movs r0, #0
10e90a: bdf8 pop {r3, r4, r5, r6, r7, pc}
*once_state = ONCE_STATE_RUNNING;
10e90c: 2701 movs r7, #1
10e90e: f240 3004 movw r0, #772 ; 0x304
10e912: f2c0 0020 movt r0, #32
10e916: 7027 strb r7, [r4, #0]
10e918: f7fb fadc bl 109ed4 <_Mutex_Release>
_Thread_Set_life_protection( thread_life_state );
10e91c: 4638 mov r0, r7
10e91e: f7fc fe0d bl 10b53c <_Thread_Set_life_protection>
( *init_routine )();
10e922: 47a8 blx r5
thread_life_state = _Thread_Set_life_protection( THREAD_LIFE_PROTECTED );
10e924: 4638 mov r0, r7
10e926: f7fc fe09 bl 10b53c <_Thread_Set_life_protection>
_Mutex_Acquire( mutex );
10e92a: f240 3004 movw r0, #772 ; 0x304
10e92e: f2c0 0020 movt r0, #32
10e932: f7fb faa3 bl 109e7c <_Mutex_Acquire>
*once_state = ONCE_STATE_COMPLETE;
10e936: 2302 movs r3, #2
_Condition_Broadcast( condition_variable );
10e938: 4802 ldr r0, [pc, #8] ; (10e944 <_Once+0x90>)
10e93a: 7023 strb r3, [r4, #0]
10e93c: f7ff fd96 bl 10e46c <_Condition_Broadcast>
}
10e940: e7d9 b.n 10e8f6 <_Once+0x42>
10e942: bf00 nop
10e944: 00200318 .word 0x00200318
0010be94 <_Processor_mask_Copy>:
long *dst,
size_t dst_size,
const long *src,
size_t src_size
)
{
10be94: b570 push {r4, r5, r6, lr}
long inclusive = 0;
long exclusive = 0;
if ( ( dst_size | src_size ) % sizeof( long ) != 0 ) {
10be96: ea41 0403 orr.w r4, r1, r3
{
10be9a: 4684 mov ip, r0
if ( ( dst_size | src_size ) % sizeof( long ) != 0 ) {
10be9c: f014 0003 ands.w r0, r4, #3
return PROCESSOR_MASK_COPY_INVALID_SIZE;
10bea0: bf18 it ne
10bea2: 2003 movne r0, #3
if ( ( dst_size | src_size ) % sizeof( long ) != 0 ) {
10bea4: d12b bne.n 10befe <_Processor_mask_Copy+0x6a>
}
while ( dst_size > 0 && src_size > 0 ) {
10bea6: 2b00 cmp r3, #0
10bea8: bf18 it ne
10beaa: 2900 cmpne r1, #0
10beac: d02a beq.n 10bf04 <_Processor_mask_Copy+0x70>
10beae: 4696 mov lr, r2
long inclusive = 0;
10beb0: 4606 mov r6, r0
while ( dst_size > 0 && src_size > 0 ) {
10beb2: 3904 subs r1, #4
long bits = *src;
10beb4: f85e 5b04 ldr.w r5, [lr], #4
while ( dst_size > 0 && src_size > 0 ) {
10beb8: bf14 ite ne
10beba: 2401 movne r4, #1
10bebc: 2400 moveq r4, #0
10bebe: 3b04 subs r3, #4
10bec0: f004 0401 and.w r4, r4, #1
10bec4: bf08 it eq
10bec6: 2400 moveq r4, #0
inclusive |= bits;
10bec8: 432e orrs r6, r5
*dst = bits;
++dst;
++src;
10beca: 4672 mov r2, lr
*dst = bits;
10becc: f84c 5b04 str.w r5, [ip], #4
while ( dst_size > 0 && src_size > 0 ) {
10bed0: 2c00 cmp r4, #0
10bed2: d1ee bne.n 10beb2 <_Processor_mask_Copy+0x1e> <== ALWAYS TAKEN
dst_size -= sizeof( long );
src_size -= sizeof( long );
}
while ( dst_size > 0 ) {
10bed4: b129 cbz r1, 10bee2 <_Processor_mask_Copy+0x4e>
10bed6: 4461 add r1, ip
*dst = 0;
10bed8: 2400 movs r4, #0
10beda: f84c 4b04 str.w r4, [ip], #4
while ( dst_size > 0 ) {
10bede: 458c cmp ip, r1
10bee0: d1fb bne.n 10beda <_Processor_mask_Copy+0x46> <== ALWAYS TAKEN
++dst;
dst_size -= sizeof( long );
}
while ( src_size > 0 ) {
10bee2: b16b cbz r3, 10bf00 <_Processor_mask_Copy+0x6c>
long exclusive = 0;
10bee4: 2100 movs r1, #0
10bee6: 4413 add r3, r2
exclusive |= *src;
10bee8: f852 4b04 ldr.w r4, [r2], #4
while ( src_size > 0 ) {
10beec: 429a cmp r2, r3
exclusive |= *src;
10beee: ea41 0104 orr.w r1, r1, r4
while ( src_size > 0 ) {
10bef2: d1f9 bne.n 10bee8 <_Processor_mask_Copy+0x54> <== ALWAYS TAKEN
++src;
src_size -= sizeof( long );
}
if ( exclusive != 0 ) {
10bef4: b119 cbz r1, 10befe <_Processor_mask_Copy+0x6a>
if ( inclusive != 0 ) {
return PROCESSOR_MASK_COPY_PARTIAL_LOSS;
} else {
return PROCESSOR_MASK_COPY_COMPLETE_LOSS;
10bef6: 2e00 cmp r6, #0
10bef8: bf14 ite ne
10befa: 2001 movne r0, #1
10befc: 2002 moveq r0, #2
}
}
return PROCESSOR_MASK_COPY_LOSSLESS;
}
10befe: bd70 pop {r4, r5, r6, pc}
return PROCESSOR_MASK_COPY_LOSSLESS;
10bf00: 4618 mov r0, r3
}
10bf02: bd70 pop {r4, r5, r6, pc}
long inclusive = 0;
10bf04: 4606 mov r6, r0
10bf06: e7e5 b.n 10bed4 <_Processor_mask_Copy+0x40>
0010e948 <_RBTree_Extract>:
void _RBTree_Extract(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
10e948: b5f0 push {r4, r5, r6, r7, lr}
10e94a: 468c mov ip, r1
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
10e94c: e9d1 3400 ldrd r3, r4, [r1]
{
10e950: 4686 mov lr, r0
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
10e952: 2b00 cmp r3, #0
10e954: f000 80b9 beq.w 10eaca <_RBTree_Extract+0x182>
10e958: 2c00 cmp r4, #0
10e95a: d030 beq.n 10e9be <_RBTree_Extract+0x76>
10e95c: 4626 mov r6, r4
10e95e: 6824 ldr r4, [r4, #0]
10e960: 2c00 cmp r4, #0
10e962: d1fb bne.n 10e95c <_RBTree_Extract+0x14>
10e964: e9d6 4501 ldrd r4, r5, [r6, #4]
10e968: 68f7 ldr r7, [r6, #12]
10e96a: 462b mov r3, r5
10e96c: b10c cbz r4, 10e972 <_RBTree_Extract+0x2a>
10e96e: 60a5 str r5, [r4, #8]
10e970: 68b3 ldr r3, [r6, #8]
10e972: 2d00 cmp r5, #0
10e974: f000 80bb beq.w 10eaee <_RBTree_Extract+0x1a6> <== ALWAYS TAKEN
10e978: 682a ldr r2, [r5, #0]
10e97a: 4296 cmp r6, r2
10e97c: bf0c ite eq
10e97e: 602c streq r4, [r5, #0]
10e980: 606c strne r4, [r5, #4]
10e982: 459c cmp ip, r3
10e984: bf08 it eq
10e986: 4635 moveq r5, r6
10e988: e89c 000f ldmia.w ip, {r0, r1, r2, r3}
10e98c: e886 000f stmia.w r6, {r0, r1, r2, r3}
10e990: f8dc 3008 ldr.w r3, [ip, #8]
10e994: 2b00 cmp r3, #0
10e996: f000 80a7 beq.w 10eae8 <_RBTree_Extract+0x1a0>
10e99a: 681a ldr r2, [r3, #0]
10e99c: 4594 cmp ip, r2
10e99e: bf0c ite eq
10e9a0: 601e streq r6, [r3, #0]
10e9a2: 605e strne r6, [r3, #4]
10e9a4: e9dc 2300 ldrd r2, r3, [ip]
10e9a8: 6096 str r6, [r2, #8]
10e9aa: b103 cbz r3, 10e9ae <_RBTree_Extract+0x66>
10e9ac: 609e str r6, [r3, #8]
10e9ae: b195 cbz r5, 10e9d6 <_RBTree_Extract+0x8e>
10e9b0: 462b mov r3, r5
10e9b2: 689b ldr r3, [r3, #8]
10e9b4: 2b00 cmp r3, #0
10e9b6: d1fc bne.n 10e9b2 <_RBTree_Extract+0x6a>
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
10e9b8: 2001 movs r0, #1
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
10e9ba: b17f cbz r7, 10e9dc <_RBTree_Extract+0x94>
_Assert( _RBTree_Find_root( the_node ) == _RBTree_Root( the_rbtree ) );
RB_REMOVE( RBTree_Control, the_rbtree, the_node );
_RBTree_Initialize_node( the_node );
}
10e9bc: bdf0 pop {r4, r5, r6, r7, pc}
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
10e9be: e9d1 5702 ldrd r5, r7, [r1, #8]
10e9c2: 461c mov r4, r3
10e9c4: 60a5 str r5, [r4, #8]
10e9c6: 2d00 cmp r5, #0
10e9c8: f000 8087 beq.w 10eada <_RBTree_Extract+0x192>
10e9cc: 682b ldr r3, [r5, #0]
10e9ce: 459c cmp ip, r3
10e9d0: bf0c ite eq
10e9d2: 602c streq r4, [r5, #0]
10e9d4: 606c strne r4, [r5, #4]
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
10e9d6: 2001 movs r0, #1
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
10e9d8: 2f00 cmp r7, #0
10e9da: d1ef bne.n 10e9bc <_RBTree_Extract+0x74>
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
10e9dc: b11c cbz r4, 10e9e6 <_RBTree_Extract+0x9e>
10e9de: 68e3 ldr r3, [r4, #12]
10e9e0: 2b00 cmp r3, #0
10e9e2: f040 8087 bne.w 10eaf4 <_RBTree_Extract+0x1ac>
10e9e6: f8de 3000 ldr.w r3, [lr]
10e9ea: 429c cmp r4, r3
10e9ec: d03d beq.n 10ea6a <_RBTree_Extract+0x122>
10e9ee: 682b ldr r3, [r5, #0]
10e9f0: 42a3 cmp r3, r4
10e9f2: d011 beq.n 10ea18 <_RBTree_Extract+0xd0>
10e9f4: 68da ldr r2, [r3, #12]
10e9f6: 2a01 cmp r2, #1
10e9f8: d051 beq.n 10ea9e <_RBTree_Extract+0x156>
10e9fa: 681a ldr r2, [r3, #0]
10e9fc: b112 cbz r2, 10ea04 <_RBTree_Extract+0xbc>
10e9fe: 68d1 ldr r1, [r2, #12]
10ea00: 2900 cmp r1, #0
10ea02: d17c bne.n 10eafe <_RBTree_Extract+0x1b6>
10ea04: 6859 ldr r1, [r3, #4]
10ea06: b111 cbz r1, 10ea0e <_RBTree_Extract+0xc6>
10ea08: 68cc ldr r4, [r1, #12]
10ea0a: 2c00 cmp r4, #0
10ea0c: d174 bne.n 10eaf8 <_RBTree_Extract+0x1b0>
10ea0e: 68aa ldr r2, [r5, #8]
10ea10: 462c mov r4, r5
10ea12: 60d8 str r0, [r3, #12]
10ea14: 4615 mov r5, r2
10ea16: e7e1 b.n 10e9dc <_RBTree_Extract+0x94>
10ea18: 686b ldr r3, [r5, #4]
10ea1a: 68d9 ldr r1, [r3, #12]
10ea1c: 681a ldr r2, [r3, #0]
10ea1e: 2901 cmp r1, #1
10ea20: d028 beq.n 10ea74 <_RBTree_Extract+0x12c>
10ea22: b11a cbz r2, 10ea2c <_RBTree_Extract+0xe4>
10ea24: 68d1 ldr r1, [r2, #12]
10ea26: 2900 cmp r1, #0
10ea28: f040 80a7 bne.w 10eb7a <_RBTree_Extract+0x232>
10ea2c: 6859 ldr r1, [r3, #4]
10ea2e: 2900 cmp r1, #0
10ea30: d0ed beq.n 10ea0e <_RBTree_Extract+0xc6>
10ea32: 68ca ldr r2, [r1, #12]
10ea34: 2a00 cmp r2, #0
10ea36: d0ea beq.n 10ea0e <_RBTree_Extract+0xc6>
10ea38: 68ea ldr r2, [r5, #12]
10ea3a: 6868 ldr r0, [r5, #4]
10ea3c: 60da str r2, [r3, #12]
10ea3e: 2300 movs r3, #0
10ea40: 60eb str r3, [r5, #12]
10ea42: 2300 movs r3, #0
10ea44: 60cb str r3, [r1, #12]
10ea46: 6803 ldr r3, [r0, #0]
10ea48: 606b str r3, [r5, #4]
10ea4a: b103 cbz r3, 10ea4e <_RBTree_Extract+0x106>
10ea4c: 609d str r5, [r3, #8]
10ea4e: 68aa ldr r2, [r5, #8]
10ea50: 6082 str r2, [r0, #8]
10ea52: 2a00 cmp r2, #0
10ea54: f000 80b3 beq.w 10ebbe <_RBTree_Extract+0x276>
10ea58: 6813 ldr r3, [r2, #0]
10ea5a: 429d cmp r5, r3
10ea5c: f8de 3000 ldr.w r3, [lr]
10ea60: bf0c ite eq
10ea62: 6010 streq r0, [r2, #0]
10ea64: 6050 strne r0, [r2, #4]
10ea66: 6005 str r5, [r0, #0]
10ea68: 60a8 str r0, [r5, #8]
10ea6a: 2b00 cmp r3, #0
10ea6c: d0a6 beq.n 10e9bc <_RBTree_Extract+0x74>
10ea6e: 2200 movs r2, #0
10ea70: 60da str r2, [r3, #12]
}
10ea72: bdf0 pop {r4, r5, r6, r7, pc}
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
10ea74: 60df str r7, [r3, #12]
10ea76: 60e9 str r1, [r5, #12]
10ea78: 606a str r2, [r5, #4]
10ea7a: b102 cbz r2, 10ea7e <_RBTree_Extract+0x136>
10ea7c: 6095 str r5, [r2, #8]
10ea7e: 68a9 ldr r1, [r5, #8]
10ea80: 6099 str r1, [r3, #8]
10ea82: 2900 cmp r1, #0
10ea84: d02c beq.n 10eae0 <_RBTree_Extract+0x198>
10ea86: 680c ldr r4, [r1, #0]
10ea88: 42a5 cmp r5, r4
10ea8a: bf19 ittee ne
10ea8c: 604b strne r3, [r1, #4]
10ea8e: 6869 ldrne r1, [r5, #4]
10ea90: 600b streq r3, [r1, #0]
10ea92: 4611 moveq r1, r2
10ea94: 601d str r5, [r3, #0]
10ea96: 60ab str r3, [r5, #8]
10ea98: 460b mov r3, r1
10ea9a: 680a ldr r2, [r1, #0]
10ea9c: e7c1 b.n 10ea22 <_RBTree_Extract+0xda>
10ea9e: 6859 ldr r1, [r3, #4]
10eaa0: 60df str r7, [r3, #12]
10eaa2: 60ea str r2, [r5, #12]
10eaa4: 6029 str r1, [r5, #0]
10eaa6: b101 cbz r1, 10eaaa <_RBTree_Extract+0x162>
10eaa8: 608d str r5, [r1, #8]
10eaaa: 68aa ldr r2, [r5, #8]
10eaac: 609a str r2, [r3, #8]
10eaae: b14a cbz r2, 10eac4 <_RBTree_Extract+0x17c>
10eab0: 6814 ldr r4, [r2, #0]
10eab2: 42a5 cmp r5, r4
10eab4: bf06 itte eq
10eab6: 6013 streq r3, [r2, #0]
10eab8: 6829 ldreq r1, [r5, #0]
10eaba: 6053 strne r3, [r2, #4]
10eabc: 605d str r5, [r3, #4]
10eabe: 60ab str r3, [r5, #8]
10eac0: 460b mov r3, r1
10eac2: e79a b.n 10e9fa <_RBTree_Extract+0xb2>
10eac4: f8ce 3000 str.w r3, [lr]
10eac8: e7f8 b.n 10eabc <_RBTree_Extract+0x174>
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
10eaca: e9d1 5702 ldrd r5, r7, [r1, #8]
10eace: 2c00 cmp r4, #0
10ead0: f47f af78 bne.w 10e9c4 <_RBTree_Extract+0x7c>
10ead4: 2d00 cmp r5, #0
10ead6: f47f af79 bne.w 10e9cc <_RBTree_Extract+0x84>
10eada: f8ce 4000 str.w r4, [lr]
10eade: e77a b.n 10e9d6 <_RBTree_Extract+0x8e>
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
10eae0: 4611 mov r1, r2
10eae2: f8ce 3000 str.w r3, [lr]
10eae6: e7d5 b.n 10ea94 <_RBTree_Extract+0x14c>
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
10eae8: f8ce 6000 str.w r6, [lr]
10eaec: e75a b.n 10e9a4 <_RBTree_Extract+0x5c>
10eaee: f8ce 4000 str.w r4, [lr] <== NOT EXECUTED
10eaf2: e746 b.n 10e982 <_RBTree_Extract+0x3a> <== NOT EXECUTED
10eaf4: 4623 mov r3, r4
10eaf6: e7ba b.n 10ea6e <_RBTree_Extract+0x126>
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
10eaf8: b1ea cbz r2, 10eb36 <_RBTree_Extract+0x1ee>
10eafa: 68d0 ldr r0, [r2, #12]
10eafc: b1d8 cbz r0, 10eb36 <_RBTree_Extract+0x1ee>
10eafe: 68e9 ldr r1, [r5, #12]
10eb00: 6828 ldr r0, [r5, #0]
10eb02: 60d9 str r1, [r3, #12]
10eb04: 2300 movs r3, #0
10eb06: 60eb str r3, [r5, #12]
10eb08: 2300 movs r3, #0
10eb0a: 60d3 str r3, [r2, #12]
10eb0c: 6843 ldr r3, [r0, #4]
10eb0e: 602b str r3, [r5, #0]
10eb10: b103 cbz r3, 10eb14 <_RBTree_Extract+0x1cc>
10eb12: 609d str r5, [r3, #8]
10eb14: 68aa ldr r2, [r5, #8]
10eb16: 6082 str r2, [r0, #8]
10eb18: 2a00 cmp r2, #0
10eb1a: d02a beq.n 10eb72 <_RBTree_Extract+0x22a>
10eb1c: 68ab ldr r3, [r5, #8]
10eb1e: 681b ldr r3, [r3, #0]
10eb20: 429d cmp r5, r3
10eb22: f8de 3000 ldr.w r3, [lr]
10eb26: bf0c ite eq
10eb28: 6010 streq r0, [r2, #0]
10eb2a: 6050 strne r0, [r2, #4]
10eb2c: 6045 str r5, [r0, #4]
10eb2e: 60a8 str r0, [r5, #8]
10eb30: 2b00 cmp r3, #0
10eb32: d19c bne.n 10ea6e <_RBTree_Extract+0x126> <== NEVER TAKEN
10eb34: e742 b.n 10e9bc <_RBTree_Extract+0x74> <== NOT EXECUTED
10eb36: 2200 movs r2, #0
10eb38: 60ca str r2, [r1, #12]
10eb3a: 2201 movs r2, #1
10eb3c: 60da str r2, [r3, #12]
10eb3e: 680a ldr r2, [r1, #0]
10eb40: 605a str r2, [r3, #4]
10eb42: b102 cbz r2, 10eb46 <_RBTree_Extract+0x1fe>
10eb44: 6093 str r3, [r2, #8]
10eb46: 689a ldr r2, [r3, #8]
10eb48: 608a str r2, [r1, #8]
10eb4a: b17a cbz r2, 10eb6c <_RBTree_Extract+0x224>
10eb4c: 6810 ldr r0, [r2, #0]
10eb4e: 4283 cmp r3, r0
10eb50: bf0c ite eq
10eb52: 6011 streq r1, [r2, #0]
10eb54: 6051 strne r1, [r2, #4]
10eb56: 600b str r3, [r1, #0]
10eb58: 6828 ldr r0, [r5, #0]
10eb5a: 6099 str r1, [r3, #8]
10eb5c: 2300 movs r3, #0
10eb5e: 68e9 ldr r1, [r5, #12]
10eb60: 6802 ldr r2, [r0, #0]
10eb62: 60c1 str r1, [r0, #12]
10eb64: 60eb str r3, [r5, #12]
10eb66: 2a00 cmp r2, #0
10eb68: d0d0 beq.n 10eb0c <_RBTree_Extract+0x1c4> <== ALWAYS TAKEN
10eb6a: e7cd b.n 10eb08 <_RBTree_Extract+0x1c0>
10eb6c: f8ce 1000 str.w r1, [lr] <== NOT EXECUTED
10eb70: e7f1 b.n 10eb56 <_RBTree_Extract+0x20e> <== NOT EXECUTED
10eb72: 4603 mov r3, r0
10eb74: f8ce 0000 str.w r0, [lr]
10eb78: e7d8 b.n 10eb2c <_RBTree_Extract+0x1e4>
10eb7a: 6859 ldr r1, [r3, #4]
10eb7c: b119 cbz r1, 10eb86 <_RBTree_Extract+0x23e>
10eb7e: 68c8 ldr r0, [r1, #12]
10eb80: 2800 cmp r0, #0
10eb82: f47f af59 bne.w 10ea38 <_RBTree_Extract+0xf0>
10eb86: 2100 movs r1, #0
10eb88: 60d1 str r1, [r2, #12]
10eb8a: 2101 movs r1, #1
10eb8c: 60d9 str r1, [r3, #12]
10eb8e: 6851 ldr r1, [r2, #4]
10eb90: 6019 str r1, [r3, #0]
10eb92: b101 cbz r1, 10eb96 <_RBTree_Extract+0x24e>
10eb94: 608b str r3, [r1, #8]
10eb96: 6899 ldr r1, [r3, #8]
10eb98: 6091 str r1, [r2, #8]
10eb9a: b1a1 cbz r1, 10ebc6 <_RBTree_Extract+0x27e>
10eb9c: 6808 ldr r0, [r1, #0]
10eb9e: 4283 cmp r3, r0
10eba0: bf0c ite eq
10eba2: 600a streq r2, [r1, #0]
10eba4: 604a strne r2, [r1, #4]
10eba6: 6053 str r3, [r2, #4]
10eba8: 6868 ldr r0, [r5, #4]
10ebaa: 609a str r2, [r3, #8]
10ebac: 2300 movs r3, #0
10ebae: 68ea ldr r2, [r5, #12]
10ebb0: 6841 ldr r1, [r0, #4]
10ebb2: 60c2 str r2, [r0, #12]
10ebb4: 60eb str r3, [r5, #12]
10ebb6: 2900 cmp r1, #0
10ebb8: f43f af45 beq.w 10ea46 <_RBTree_Extract+0xfe> <== ALWAYS TAKEN
10ebbc: e741 b.n 10ea42 <_RBTree_Extract+0xfa>
10ebbe: 4603 mov r3, r0
10ebc0: f8ce 0000 str.w r0, [lr]
10ebc4: e74f b.n 10ea66 <_RBTree_Extract+0x11e>
10ebc6: f8ce 2000 str.w r2, [lr] <== NOT EXECUTED
10ebca: e7ec b.n 10eba6 <_RBTree_Extract+0x25e> <== NOT EXECUTED
0010ebcc <_RBTree_Insert_color>:
#include "config.h"
#endif
#include <rtems/score/rbtreeimpl.h>
RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline )
10ebcc: 688b ldr r3, [r1, #8]
10ebce: 2b00 cmp r3, #0
10ebd0: f000 8083 beq.w 10ecda <_RBTree_Insert_color+0x10e>
void _RBTree_Insert_color(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
10ebd4: b4f0 push {r4, r5, r6, r7}
RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline )
10ebd6: 2500 movs r5, #0
10ebd8: 2601 movs r6, #1
10ebda: e01a b.n 10ec12 <_RBTree_Insert_color+0x46>
10ebdc: b114 cbz r4, 10ebe4 <_RBTree_Insert_color+0x18>
10ebde: 68e7 ldr r7, [r4, #12]
10ebe0: 2f01 cmp r7, #1
10ebe2: d055 beq.n 10ec90 <_RBTree_Insert_color+0xc4>
10ebe4: 681c ldr r4, [r3, #0]
10ebe6: 428c cmp r4, r1
10ebe8: d03d beq.n 10ec66 <_RBTree_Insert_color+0x9a>
10ebea: 6854 ldr r4, [r2, #4]
10ebec: 60dd str r5, [r3, #12]
10ebee: 60d6 str r6, [r2, #12]
10ebf0: 6823 ldr r3, [r4, #0]
10ebf2: 6053 str r3, [r2, #4]
10ebf4: b103 cbz r3, 10ebf8 <_RBTree_Insert_color+0x2c>
10ebf6: 609a str r2, [r3, #8]
10ebf8: 6893 ldr r3, [r2, #8]
10ebfa: 60a3 str r3, [r4, #8]
10ebfc: 2b00 cmp r3, #0
10ebfe: d045 beq.n 10ec8c <_RBTree_Insert_color+0xc0>
10ec00: 681f ldr r7, [r3, #0]
10ec02: 42ba cmp r2, r7
10ec04: bf0c ite eq
10ec06: 601c streq r4, [r3, #0]
10ec08: 605c strne r4, [r3, #4]
10ec0a: 6022 str r2, [r4, #0]
10ec0c: 6094 str r4, [r2, #8]
10ec0e: 688b ldr r3, [r1, #8]
10ec10: b323 cbz r3, 10ec5c <_RBTree_Insert_color+0x90>
10ec12: 68da ldr r2, [r3, #12]
10ec14: 2a01 cmp r2, #1
10ec16: d121 bne.n 10ec5c <_RBTree_Insert_color+0x90>
10ec18: 689a ldr r2, [r3, #8]
10ec1a: 6814 ldr r4, [r2, #0]
10ec1c: 429c cmp r4, r3
10ec1e: d1dd bne.n 10ebdc <_RBTree_Insert_color+0x10>
10ec20: 6854 ldr r4, [r2, #4]
10ec22: b114 cbz r4, 10ec2a <_RBTree_Insert_color+0x5e>
10ec24: 68e7 ldr r7, [r4, #12]
10ec26: 2f01 cmp r7, #1
10ec28: d032 beq.n 10ec90 <_RBTree_Insert_color+0xc4>
10ec2a: 685c ldr r4, [r3, #4]
10ec2c: 428c cmp r4, r1
10ec2e: bf18 it ne
10ec30: 461c movne r4, r3
10ec32: d032 beq.n 10ec9a <_RBTree_Insert_color+0xce>
10ec34: 6867 ldr r7, [r4, #4]
10ec36: 60dd str r5, [r3, #12]
10ec38: 60d6 str r6, [r2, #12]
10ec3a: 6017 str r7, [r2, #0]
10ec3c: b107 cbz r7, 10ec40 <_RBTree_Insert_color+0x74>
10ec3e: 60ba str r2, [r7, #8]
10ec40: 6893 ldr r3, [r2, #8]
10ec42: 60a3 str r3, [r4, #8]
10ec44: 2b00 cmp r3, #0
10ec46: d03b beq.n 10ecc0 <_RBTree_Insert_color+0xf4>
10ec48: 681f ldr r7, [r3, #0]
10ec4a: 42ba cmp r2, r7
10ec4c: bf0c ite eq
10ec4e: 601c streq r4, [r3, #0]
10ec50: 605c strne r4, [r3, #4]
10ec52: 6062 str r2, [r4, #4]
10ec54: 6094 str r4, [r2, #8]
10ec56: 688b ldr r3, [r1, #8]
10ec58: 2b00 cmp r3, #0
10ec5a: d1da bne.n 10ec12 <_RBTree_Insert_color+0x46> <== NEVER TAKEN
10ec5c: 6803 ldr r3, [r0, #0]
10ec5e: 2200 movs r2, #0
RBTree_Control_RB_INSERT_COLOR( the_rbtree, the_node );
}
10ec60: bcf0 pop {r4, r5, r6, r7}
RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline )
10ec62: 60da str r2, [r3, #12]
}
10ec64: 4770 bx lr
RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline )
10ec66: 684c ldr r4, [r1, #4]
10ec68: 601c str r4, [r3, #0]
10ec6a: 2c00 cmp r4, #0
10ec6c: d02c beq.n 10ecc8 <_RBTree_Insert_color+0xfc>
10ec6e: 60a3 str r3, [r4, #8]
10ec70: 689c ldr r4, [r3, #8]
10ec72: 608c str r4, [r1, #8]
10ec74: b334 cbz r4, 10ecc4 <_RBTree_Insert_color+0xf8>
10ec76: 6827 ldr r7, [r4, #0]
10ec78: 429f cmp r7, r3
10ec7a: bf0c ite eq
10ec7c: 6021 streq r1, [r4, #0]
10ec7e: 6061 strne r1, [r4, #4]
10ec80: 460c mov r4, r1
10ec82: 604b str r3, [r1, #4]
10ec84: 6099 str r1, [r3, #8]
10ec86: 4619 mov r1, r3
10ec88: 4623 mov r3, r4
10ec8a: e7ae b.n 10ebea <_RBTree_Insert_color+0x1e>
10ec8c: 6004 str r4, [r0, #0]
10ec8e: e7bc b.n 10ec0a <_RBTree_Insert_color+0x3e>
10ec90: 60e5 str r5, [r4, #12]
10ec92: 4611 mov r1, r2
10ec94: 60dd str r5, [r3, #12]
10ec96: 60d7 str r7, [r2, #12]
10ec98: e7b9 b.n 10ec0e <_RBTree_Insert_color+0x42>
10ec9a: 680c ldr r4, [r1, #0]
10ec9c: 605c str r4, [r3, #4]
10ec9e: b1b4 cbz r4, 10ecce <_RBTree_Insert_color+0x102>
10eca0: 60a3 str r3, [r4, #8]
10eca2: 689c ldr r4, [r3, #8]
10eca4: 608c str r4, [r1, #8]
10eca6: b1b4 cbz r4, 10ecd6 <_RBTree_Insert_color+0x10a>
10eca8: 6827 ldr r7, [r4, #0]
10ecaa: 429f cmp r7, r3
10ecac: bf18 it ne
10ecae: 6061 strne r1, [r4, #4]
10ecb0: d00f beq.n 10ecd2 <_RBTree_Insert_color+0x106> <== NEVER TAKEN
10ecb2: 460c mov r4, r1
10ecb4: 600b str r3, [r1, #0]
10ecb6: 6099 str r1, [r3, #8]
10ecb8: 4619 mov r1, r3
10ecba: 4623 mov r3, r4
10ecbc: 6814 ldr r4, [r2, #0]
10ecbe: e7b9 b.n 10ec34 <_RBTree_Insert_color+0x68>
10ecc0: 6004 str r4, [r0, #0]
10ecc2: e7c6 b.n 10ec52 <_RBTree_Insert_color+0x86>
10ecc4: 6001 str r1, [r0, #0] <== NOT EXECUTED
10ecc6: e7db b.n 10ec80 <_RBTree_Insert_color+0xb4> <== NOT EXECUTED
10ecc8: 4614 mov r4, r2
10ecca: 608a str r2, [r1, #8]
10eccc: e7d3 b.n 10ec76 <_RBTree_Insert_color+0xaa>
10ecce: 4614 mov r4, r2
10ecd0: 608a str r2, [r1, #8]
10ecd2: 6021 str r1, [r4, #0]
10ecd4: e7ed b.n 10ecb2 <_RBTree_Insert_color+0xe6>
10ecd6: 6001 str r1, [r0, #0] <== NOT EXECUTED
10ecd8: e7eb b.n 10ecb2 <_RBTree_Insert_color+0xe6> <== NOT EXECUTED
10ecda: 6803 ldr r3, [r0, #0]
10ecdc: 2200 movs r2, #0
10ecde: 60da str r2, [r3, #12]
10ece0: 4770 bx lr
10ece2: bf00 nop
0010cd50 <_SMP_barrier_Wait>:
bool _SMP_barrier_Wait(
SMP_barrier_Control *control,
SMP_barrier_State *state,
unsigned int count
)
{
10cd50: b410 push {r4}
10cd52: 4684 mov ip, r0
unsigned int sense = ~state->sense;
10cd54: 680c ldr r4, [r1, #0]
10cd56: 43e4 mvns r4, r4
unsigned int previous_value;
bool performed_release;
state->sense = sense;
10cd58: 600c str r4, [r1, #0]
__asm__ volatile (
10cd5a: f3ef 8100 mrs r1, CPSR
10cd5e: f041 0380 orr.w r3, r1, #128 ; 0x80
10cd62: f383 8900 msr CPSR_fc, r3
*obj = val + arg;
10cd66: 6803 ldr r3, [r0, #0]
10cd68: 3301 adds r3, #1
10cd6a: 6003 str r3, [r0, #0]
__asm__ volatile (
10cd6c: f381 8900 msr CPSR_fc, r1
&control->value,
1U,
ATOMIC_ORDER_RELAXED
);
if ( previous_value + 1U == count ) {
10cd70: 429a cmp r2, r3
10cd72: d007 beq.n 10cd84 <_SMP_barrier_Wait+0x34> <== NEVER TAKEN
val = *obj;
10cd74: f8dc 3004 ldr.w r3, [ip, #4] <== NOT EXECUTED
_Atomic_Store_uint( &control->value, 0U, ATOMIC_ORDER_RELAXED );
_Atomic_Store_uint( &control->sense, sense, ATOMIC_ORDER_RELEASE );
performed_release = true;
} else {
while (
10cd78: 429c cmp r4, r3 <== NOT EXECUTED
10cd7a: d1fb bne.n 10cd74 <_SMP_barrier_Wait+0x24> <== NOT EXECUTED
_Atomic_Load_uint( &control->sense, ATOMIC_ORDER_ACQUIRE ) != sense
) {
/* Wait */
}
performed_release = false;
10cd7c: 2000 movs r0, #0 <== NOT EXECUTED
}
return performed_release;
}
10cd7e: f85d 4b04 ldr.w r4, [sp], #4 <== NOT EXECUTED
10cd82: 4770 bx lr <== NOT EXECUTED
*obj = desired;
10cd84: 2300 movs r3, #0
10cd86: 6003 str r3, [r0, #0]
performed_release = true;
10cd88: 2001 movs r0, #1
10cd8a: f8cc 4004 str.w r4, [ip, #4]
}
10cd8e: f85d 4b04 ldr.w r4, [sp], #4
10cd92: 4770 bx lr
00107dd0 <_Scheduler_CBS_Attach_thread>:
Scheduler_CBS_Server *server;
ISR_lock_Context lock_context;
Thread_Control *the_thread;
Scheduler_CBS_Node *node;
if ( server_id >= _Scheduler_CBS_Maximum_servers ) {
107dd0: f24f 5304 movw r3, #62724 ; 0xf504
107dd4: f2c0 0310 movt r3, #16
107dd8: 681b ldr r3, [r3, #0]
107dda: 4283 cmp r3, r0
107ddc: d936 bls.n 107e4c <_Scheduler_CBS_Attach_thread+0x7c>
{
107dde: b5f0 push {r4, r5, r6, r7, lr}
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
}
server = &_Scheduler_CBS_Server_list[ server_id ];
107de0: 0144 lsls r4, r0, #5
107de2: f641 15b0 movw r5, #6576 ; 0x19b0
107de6: f2c0 0520 movt r5, #32
{
107dea: b083 sub sp, #12
server = &_Scheduler_CBS_Server_list[ server_id ];
107dec: 1967 adds r7, r4, r5
if ( !server->initialized ) {
107dee: 7f3b ldrb r3, [r7, #28]
107df0: b34b cbz r3, 107e46 <_Scheduler_CBS_Attach_thread+0x76>
return SCHEDULER_CBS_ERROR_NOSERVER;
}
if ( server->task_id != -1 ) {
107df2: 5963 ldr r3, [r4, r5]
107df4: 3301 adds r3, #1
107df6: d11a bne.n 107e2e <_Scheduler_CBS_Attach_thread+0x5e>
return SCHEDULER_CBS_ERROR_FULL;
}
the_thread = _Thread_Get( task_id, &lock_context );
107df8: 460e mov r6, r1
107dfa: a901 add r1, sp, #4
107dfc: 4630 mov r0, r6
107dfe: f000 fe81 bl 108b04 <_Thread_Get>
if ( the_thread == NULL ) {
107e02: b1e8 cbz r0, 107e40 <_Scheduler_CBS_Attach_thread+0x70>
return the_thread->Scheduler.nodes;
107e04: 6b82 ldr r2, [r0, #56] ; 0x38
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
}
node = _Scheduler_CBS_Thread_get_node( the_thread );
if ( node->cbs_server != NULL ) {
107e06: 6d13 ldr r3, [r2, #80] ; 0x50
107e08: b9a3 cbnz r3, 107e34 <_Scheduler_CBS_Attach_thread+0x64>
_ISR_lock_ISR_enable( &lock_context );
return SCHEDULER_CBS_ERROR_FULL;
}
node->cbs_server = server;
107e0a: 6517 str r7, [r2, #80] ; 0x50
server->task_id = task_id;
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
107e0c: f647 6255 movw r2, #32341 ; 0x7e55
server->task_id = task_id;
107e10: 5166 str r6, [r4, r5]
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
107e12: f2c0 0210 movt r2, #16
the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
107e16: 2403 movs r4, #3
the_thread->is_preemptible = true;
107e18: 2101 movs r1, #1
the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
107e1a: e9c0 4224 strd r4, r2, [r0, #144] ; 0x90
the_thread->is_preemptible = true;
107e1e: f880 1089 strb.w r1, [r0, #137] ; 0x89
__asm__ volatile (
107e22: 9a01 ldr r2, [sp, #4]
107e24: f382 8900 msr CPSR_fc, r2
_ISR_lock_ISR_enable( &lock_context );
return SCHEDULER_CBS_OK;
107e28: 4618 mov r0, r3
}
107e2a: b003 add sp, #12
107e2c: bdf0 pop {r4, r5, r6, r7, pc}
return SCHEDULER_CBS_ERROR_FULL;
107e2e: f06f 0019 mvn.w r0, #25
107e32: e7fa b.n 107e2a <_Scheduler_CBS_Attach_thread+0x5a>
107e34: 9b01 ldr r3, [sp, #4] <== NOT EXECUTED
107e36: f383 8900 msr CPSR_fc, r3 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_FULL;
107e3a: f06f 0019 mvn.w r0, #25 <== NOT EXECUTED
107e3e: e7f4 b.n 107e2a <_Scheduler_CBS_Attach_thread+0x5a> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
107e40: f06f 0011 mvn.w r0, #17
107e44: e7f1 b.n 107e2a <_Scheduler_CBS_Attach_thread+0x5a>
return SCHEDULER_CBS_ERROR_NOSERVER;
107e46: f06f 0018 mvn.w r0, #24
107e4a: e7ee b.n 107e2a <_Scheduler_CBS_Attach_thread+0x5a>
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
107e4c: f06f 0011 mvn.w r0, #17
}
107e50: 4770 bx lr
107e52: bf00 nop
00107e8c <_Scheduler_CBS_Cleanup>:
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
107e8c: f24f 5304 movw r3, #62724 ; 0xf504
{
107e90: b570 push {r4, r5, r6, lr}
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
107e92: f2c0 0310 movt r3, #16
107e96: 681e ldr r6, [r3, #0]
107e98: b196 cbz r6, 107ec0 <_Scheduler_CBS_Cleanup+0x34>
107e9a: f641 15b0 movw r5, #6576 ; 0x19b0
107e9e: 2400 movs r4, #0
107ea0: f2c0 0520 movt r5, #32
107ea4: e002 b.n 107eac <_Scheduler_CBS_Cleanup+0x20>
107ea6: 3401 adds r4, #1
107ea8: 42b4 cmp r4, r6
107eaa: d009 beq.n 107ec0 <_Scheduler_CBS_Cleanup+0x34>
if ( _Scheduler_CBS_Server_list[ i ].initialized )
107eac: 7f2b ldrb r3, [r5, #28]
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
107eae: 3520 adds r5, #32
if ( _Scheduler_CBS_Server_list[ i ].initialized )
107eb0: 2b00 cmp r3, #0
107eb2: d0f8 beq.n 107ea6 <_Scheduler_CBS_Cleanup+0x1a>
_Scheduler_CBS_Destroy_server( i );
107eb4: 4620 mov r0, r4
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
107eb6: 3401 adds r4, #1
_Scheduler_CBS_Destroy_server( i );
107eb8: f000 f84c bl 107f54 <_Scheduler_CBS_Destroy_server>
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
107ebc: 42b4 cmp r4, r6
107ebe: d1f5 bne.n 107eac <_Scheduler_CBS_Cleanup+0x20> <== NEVER TAKEN
}
return SCHEDULER_CBS_OK;
}
107ec0: 2000 movs r0, #0
107ec2: bd70 pop {r4, r5, r6, pc}
0010784c <_Scheduler_CBS_Unblock>:
void _Scheduler_CBS_Unblock(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
10784c: e92d 43f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, lr}
107850: 4614 mov r4, r2
Scheduler_CBS_Node *the_node;
Scheduler_CBS_Server *serv_info;
Priority_Control priority;
the_node = _Scheduler_CBS_Node_downcast( node );
serv_info = the_node->cbs_server;
107852: 6d17 ldr r7, [r2, #80] ; 0x50
{
107854: b08b sub sp, #44 ; 0x2c
107856: 4606 mov r6, r0
107858: 460d mov r5, r1
priority = _Scheduler_Node_get_priority( &the_node->Base.Base );
priority = SCHEDULER_PRIORITY_PURIFY( priority );
10785a: e9d2 230c ldrd r2, r3, [r2, #48] ; 0x30
* Late unblock rule for deadline-driven tasks. The remaining time to
* deadline must be sufficient to serve the remaining computation time
* without increased utilization of this task. It might cause a deadline
* miss of another task.
*/
if ( serv_info != NULL && ( priority & SCHEDULER_EDF_PRIO_MSB ) == 0 ) {
10785e: f1b7 0c00 subs.w ip, r7, #0
107862: bf18 it ne
107864: f04f 0c01 movne.w ip, #1
107868: 2b00 cmp r3, #0
10786a: bfb8 it lt
10786c: f04f 0c00 movlt.w ip, #0
107870: f1bc 0f00 cmp.w ip, #0
107874: d024 beq.n 1078c0 <_Scheduler_CBS_Unblock+0x74>
time_t deadline = serv_info->parameters.deadline;
time_t budget = serv_info->parameters.budget;
uint32_t deadline_left = the_thread->cpu_time_budget;
Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot;
107876: f641 6c58 movw ip, #7768 ; 0x1e58
10787a: f022 0201 bic.w r2, r2, #1
10787e: f2c0 0c20 movt ip, #32
if ( deadline * budget_left > budget * deadline_left ) {
107882: f8d7 e008 ldr.w lr, [r7, #8]
Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot;
107886: f8dc c000 ldr.w ip, [ip]
if ( deadline * budget_left > budget * deadline_left ) {
10788a: f8d1 808c ldr.w r8, [r1, #140] ; 0x8c
10788e: f8d7 9010 ldr.w r9, [r7, #16]
Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot;
107892: ebb2 020c subs.w r2, r2, ip
107896: f163 0c00 sbc.w ip, r3, #0
if ( deadline * budget_left > budget * deadline_left ) {
10789a: 68fb ldr r3, [r7, #12]
10789c: 697f ldr r7, [r7, #20]
10789e: fb02 f303 mul.w r3, r2, r3
1078a2: fb0c 330e mla r3, ip, lr, r3
1078a6: fba9 9c08 umull r9, ip, r9, r8
1078aa: fbae 2e02 umull r2, lr, lr, r2
1078ae: fb08 c807 mla r8, r8, r7, ip
1078b2: 4473 add r3, lr
1078b4: 4591 cmp r9, r2
Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot;
1078b6: f04f 0700 mov.w r7, #0
if ( deadline * budget_left > budget * deadline_left ) {
1078ba: eb78 0303 sbcs.w r3, r8, r3
1078be: d307 bcc.n 1078d0 <_Scheduler_CBS_Unblock+0x84> <== NEVER TAKEN
&queue_context
);
}
}
_Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base );
1078c0: 4622 mov r2, r4
1078c2: 4629 mov r1, r5
1078c4: 4630 mov r0, r6
}
1078c6: b00b add sp, #44 ; 0x2c
1078c8: e8bd 43f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, lr}
_Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base );
1078cc: f000 b94e b.w 107b6c <_Scheduler_EDF_Unblock>
_Scheduler_CBS_Cancel_job(
1078d0: 6d62 ldr r2, [r4, #84] ; 0x54
1078d2: ab01 add r3, sp, #4
*/
RTEMS_INLINE_ROUTINE void _Thread_queue_Context_clear_priority_updates(
Thread_queue_Context *queue_context
)
{
queue_context->Priority.update_count = 0;
1078d4: 9706 str r7, [sp, #24]
1078d6: f7ff ffad bl 107834 <_Scheduler_CBS_Cancel_job>
1078da: e7f1 b.n 1078c0 <_Scheduler_CBS_Unblock+0x74>
00107954 <_Scheduler_EDF_Block>:
void _Scheduler_EDF_Block(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
107954: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
107958: f641 6400 movw r4, #7680 ; 0x1e00
10795c: 460d mov r5, r1
10795e: 4606 mov r6, r0
RTEMS_INLINE_ROUTINE void _Scheduler_EDF_Extract(
Scheduler_EDF_Context *context,
Scheduler_EDF_Node *node
)
{
_RBTree_Extract( &context->Ready, &node->Node );
107960: f102 0138 add.w r1, r2, #56 ; 0x38
107964: f2c0 0420 movt r4, #32
107968: 6800 ldr r0, [r0, #0]
10796a: f002 fd4d bl 10a408 <_RBTree_Extract>
{
( *extract )( scheduler, the_thread, node );
/* TODO: flash critical section? */
if ( _Thread_Is_executing( the_thread ) || _Thread_Is_heir( the_thread ) ) {
10796e: 69a3 ldr r3, [r4, #24]
107970: 429d cmp r5, r3
107972: d004 beq.n 10797e <_Scheduler_EDF_Block+0x2a>
107974: 69e3 ldr r3, [r4, #28]
107976: 429d cmp r5, r3
107978: d001 beq.n 10797e <_Scheduler_EDF_Block+0x2a> <== ALWAYS TAKEN
the_thread,
node,
_Scheduler_EDF_Extract_body,
_Scheduler_EDF_Schedule_body
);
}
10797a: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
Scheduler_EDF_Node *node;
(void) the_thread;
context = _Scheduler_EDF_Get_context( scheduler );
first = _RBTree_Minimum( &context->Ready );
10797e: 6830 ldr r0, [r6, #0]
107980: f002 ff10 bl 10a7a4 <_RBTree_Minimum>
RTEMS_INLINE_ROUTINE void _Scheduler_Update_heir(
Thread_Control *new_heir,
bool force_dispatch
)
{
Thread_Control *heir = _Thread_Heir;
107984: 69e5 ldr r5, [r4, #28]
node = RTEMS_CONTAINER_OF( first, Scheduler_EDF_Node, Node );
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
107986: f850 6c38 ldr.w r6, [r0, #-56]
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
10798a: 42ae cmp r6, r5
10798c: d0f5 beq.n 10797a <_Scheduler_EDF_Block+0x26> <== ALWAYS TAKEN
last = cpu->cpu_usage_timestamp;
10798e: e9d4 7808 ldrd r7, r8, [r4, #32]
*time = _Timecounter_Sbinuptime();
107992: f7ff fd19 bl 1073c8 <_Timecounter_Sbinuptime>
107996: 6220 str r0, [r4, #32]
107998: 6261 str r1, [r4, #36] ; 0x24
const Timestamp_Control *_start,
const Timestamp_Control *_end,
Timestamp_Control *_result
)
{
*_result = *_end - *_start;
10799a: 1bc0 subs r0, r0, r7
*_time += *_add;
10799c: f8d5 3098 ldr.w r3, [r5, #152] ; 0x98
*_result = *_end - *_start;
1079a0: eb61 0108 sbc.w r1, r1, r8
*_time += *_add;
1079a4: f8d5 209c ldr.w r2, [r5, #156] ; 0x9c
1079a8: 1818 adds r0, r3, r0
heir->Scheduler.state = THREAD_SCHEDULER_BLOCKED;
new_heir->Scheduler.state = THREAD_SCHEDULER_SCHEDULED;
#endif
_Thread_Update_CPU_time_used( heir, _Thread_Get_CPU( heir ) );
_Thread_Heir = new_heir;
_Thread_Dispatch_necessary = true;
1079aa: f04f 0301 mov.w r3, #1
1079ae: eb41 0102 adc.w r1, r1, r2
1079b2: f8c5 0098 str.w r0, [r5, #152] ; 0x98
1079b6: f8c5 109c str.w r1, [r5, #156] ; 0x9c
_Thread_Heir = new_heir;
1079ba: 61e6 str r6, [r4, #28]
_Thread_Dispatch_necessary = true;
1079bc: 7523 strb r3, [r4, #20]
1079be: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
1079c2: bf00 nop
00107b10 <_Scheduler_EDF_Schedule>:
void _Scheduler_EDF_Schedule(
const Scheduler_Control *scheduler,
Thread_Control *the_thread
)
{
107b10: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
Thread_Control *heir = _Thread_Heir;
107b14: f641 6400 movw r4, #7680 ; 0x1e00
first = _RBTree_Minimum( &context->Ready );
107b18: 6800 ldr r0, [r0, #0]
107b1a: f2c0 0420 movt r4, #32
107b1e: f002 fe41 bl 10a7a4 <_RBTree_Minimum>
107b22: 69e5 ldr r5, [r4, #28]
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
107b24: f850 6c38 ldr.w r6, [r0, #-56]
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
107b28: 42ae cmp r6, r5
107b2a: d002 beq.n 107b32 <_Scheduler_EDF_Schedule+0x22> <== NEVER TAKEN
107b2c: f895 3089 ldrb.w r3, [r5, #137] ; 0x89 <== NOT EXECUTED
107b30: b90b cbnz r3, 107b36 <_Scheduler_EDF_Schedule+0x26> <== NOT EXECUTED
_Scheduler_EDF_Schedule_body( scheduler, the_thread, false );
}
107b32: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
107b36: e9d4 7808 ldrd r7, r8, [r4, #32] <== NOT EXECUTED
107b3a: f7ff fc45 bl 1073c8 <_Timecounter_Sbinuptime> <== NOT EXECUTED
107b3e: 6220 str r0, [r4, #32] <== NOT EXECUTED
107b40: 6261 str r1, [r4, #36] ; 0x24 <== NOT EXECUTED
*_result = *_end - *_start;
107b42: 1bc0 subs r0, r0, r7 <== NOT EXECUTED
*_time += *_add;
107b44: f8d5 3098 ldr.w r3, [r5, #152] ; 0x98 <== NOT EXECUTED
*_result = *_end - *_start;
107b48: eb61 0108 sbc.w r1, r1, r8 <== NOT EXECUTED
*_time += *_add;
107b4c: f8d5 209c ldr.w r2, [r5, #156] ; 0x9c <== NOT EXECUTED
107b50: 1818 adds r0, r3, r0 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
107b52: f04f 0301 mov.w r3, #1 <== NOT EXECUTED
107b56: eb41 0102 adc.w r1, r1, r2 <== NOT EXECUTED
107b5a: f8c5 0098 str.w r0, [r5, #152] ; 0x98 <== NOT EXECUTED
107b5e: f8c5 109c str.w r1, [r5, #156] ; 0x9c <== NOT EXECUTED
_Thread_Heir = new_heir;
107b62: 61e6 str r6, [r4, #28] <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
107b64: 7523 strb r3, [r4, #20] <== NOT EXECUTED
107b66: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
107b6a: bf00 nop
00107b6c <_Scheduler_EDF_Unblock>:
return scheduler->context;
107b6c: 6800 ldr r0, [r0, #0]
void _Scheduler_EDF_Unblock(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
107b6e: e92d 43f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, lr}
107b72: 4689 mov r9, r1
Priority_Control insert_priority;
context = _Scheduler_EDF_Get_context( scheduler );
the_node = _Scheduler_EDF_Node_downcast( node );
priority = _Scheduler_Node_get_priority( &the_node->Base );
priority = SCHEDULER_PRIORITY_PURIFY( priority );
107b74: e9d2 460c ldrd r4, r6, [r2, #48] ; 0x30
{
107b78: b083 sub sp, #12
_RBTree_Insert_inline(
107b7a: f102 0138 add.w r1, r2, #56 ; 0x38
while ( *link != NULL ) {
107b7e: 6803 ldr r3, [r0, #0]
priority = SCHEDULER_PRIORITY_PURIFY( priority );
107b80: f024 0701 bic.w r7, r4, #1
107b84: f044 0e01 orr.w lr, r4, #1
insert_priority = SCHEDULER_PRIORITY_APPEND( priority );
the_node->priority = priority;
107b88: 64d6 str r6, [r2, #76] ; 0x4c
107b8a: 6497 str r7, [r2, #72] ; 0x48
107b8c: b90b cbnz r3, 107b92 <_Scheduler_EDF_Unblock+0x26>
107b8e: e04f b.n 107c30 <_Scheduler_EDF_Unblock+0xc4>
107b90: 4623 mov r3, r4
if ( ( *less )( key, parent ) ) {
107b92: 691d ldr r5, [r3, #16]
return &RB_RIGHT( the_node, Node );
107b94: f103 0c04 add.w ip, r3, #4
if ( ( *less )( key, parent ) ) {
107b98: 695c ldr r4, [r3, #20]
107b9a: 4575 cmp r5, lr
107b9c: 41b4 sbcs r4, r6
return &RB_LEFT( the_node, Node );
107b9e: bf28 it cs
107ba0: 469c movcs ip, r3
while ( *link != NULL ) {
107ba2: f8dc 4000 ldr.w r4, [ip]
107ba6: 2c00 cmp r4, #0
107ba8: d1f2 bne.n 107b90 <_Scheduler_EDF_Unblock+0x24>
RB_SET( child, parent, Node );
107baa: 6413 str r3, [r2, #64] ; 0x40
107bac: f04f 0801 mov.w r8, #1
107bb0: 2300 movs r3, #0
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
107bb2: f641 6400 movw r4, #7680 ; 0x1e00
107bb6: e9c2 330e strd r3, r3, [r2, #56] ; 0x38
107bba: f2c0 0420 movt r4, #32
107bbe: f8c2 8044 str.w r8, [r2, #68] ; 0x44
*link = child;
107bc2: f8cc 1000 str.w r1, [ip]
_RBTree_Insert_color( the_rbtree, the_node );
107bc6: f002 fd61 bl 10a68c <_RBTree_Insert_color>
107bca: 69e2 ldr r2, [r4, #28]
*/
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_priority(
const Priority_Aggregation *aggregation
)
{
return aggregation->Node.priority;
107bcc: 6b93 ldr r3, [r2, #56] ; 0x38
107bce: e9d3 1306 ldrd r1, r3, [r3, #24]
107bd2: 428f cmp r7, r1
107bd4: eb76 0303 sbcs.w r3, r6, r3
107bd8: d302 bcc.n 107be0 <_Scheduler_EDF_Unblock+0x74>
_Scheduler_Update_heir(
the_thread,
priority == ( SCHEDULER_EDF_PRIO_MSB | PRIORITY_PSEUDO_ISR )
);
}
}
107bda: b003 add sp, #12
107bdc: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
107be0: 454a cmp r2, r9
107be2: d0fa beq.n 107bda <_Scheduler_EDF_Unblock+0x6e> <== ALWAYS TAKEN
_Scheduler_Update_heir(
107be4: f106 4600 add.w r6, r6, #2147483648 ; 0x80000000
107be8: ea57 0306 orrs.w r3, r7, r6
107bec: f892 3089 ldrb.w r3, [r2, #137] ; 0x89
107bf0: bf08 it eq
107bf2: f043 0301 orreq.w r3, r3, #1
107bf6: 2b00 cmp r3, #0
107bf8: d0ef beq.n 107bda <_Scheduler_EDF_Unblock+0x6e>
107bfa: e9d4 7608 ldrd r7, r6, [r4, #32]
107bfe: 9201 str r2, [sp, #4]
107c00: f7ff fbe2 bl 1073c8 <_Timecounter_Sbinuptime>
107c04: 9a01 ldr r2, [sp, #4]
107c06: 6220 str r0, [r4, #32]
*_result = *_end - *_start;
107c08: 1bc0 subs r0, r0, r7
107c0a: 6261 str r1, [r4, #36] ; 0x24
107c0c: eb61 0306 sbc.w r3, r1, r6
*_time += *_add;
107c10: f8d2 1098 ldr.w r1, [r2, #152] ; 0x98
107c14: 1808 adds r0, r1, r0
107c16: f8d2 109c ldr.w r1, [r2, #156] ; 0x9c
107c1a: f8c2 0098 str.w r0, [r2, #152] ; 0x98
107c1e: eb43 0301 adc.w r3, r3, r1
107c22: f8c2 309c str.w r3, [r2, #156] ; 0x9c
_Thread_Heir = new_heir;
107c26: f8c4 901c str.w r9, [r4, #28]
_Thread_Dispatch_necessary = true;
107c2a: f884 8014 strb.w r8, [r4, #20]
}
107c2e: e7d4 b.n 107bda <_Scheduler_EDF_Unblock+0x6e>
link = _RBTree_Root_reference( the_rbtree );
107c30: 4684 mov ip, r0
107c32: e7ba b.n 107baa <_Scheduler_EDF_Unblock+0x3e>
00107ab4 <_Scheduler_EDF_Unmap_priority>:
Priority_Control _Scheduler_EDF_Unmap_priority(
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
return SCHEDULER_PRIORITY_UNMAP( priority & ~SCHEDULER_EDF_PRIO_MSB );
107ab4: 0850 lsrs r0, r2, #1 <== NOT EXECUTED
}
107ab6: f3c3 015d ubfx r1, r3, #1, #30 <== NOT EXECUTED
107aba: ea40 70c3 orr.w r0, r0, r3, lsl #31 <== NOT EXECUTED
107abe: 4770 bx lr <== NOT EXECUTED
001079cc <_Scheduler_EDF_Update_priority>:
Scheduler_EDF_Context *context;
Scheduler_EDF_Node *the_node;
Priority_Control priority;
Priority_Control insert_priority;
if ( !_Thread_Is_ready( the_thread ) ) {
1079cc: 69cb ldr r3, [r1, #28]
1079ce: 2b00 cmp r3, #0
1079d0: d146 bne.n 107a60 <_Scheduler_EDF_Update_priority+0x94>
{
1079d2: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
1079d6: 4615 mov r5, r2
do {
seq = _SMP_sequence_lock_Read_begin( &node->Priority.Lock );
#endif
priority = node->Priority.value;
1079d8: e9d2 760c ldrd r7, r6, [r2, #48] ; 0x30
the_node = _Scheduler_EDF_Node_downcast( node );
insert_priority = _Scheduler_Node_get_priority( &the_node->Base );
priority = SCHEDULER_PRIORITY_PURIFY( insert_priority );
if ( priority == the_node->priority ) {
1079dc: e9d2 1212 ldrd r1, r2, [r2, #72] ; 0x48
priority = SCHEDULER_PRIORITY_PURIFY( insert_priority );
1079e0: f027 0301 bic.w r3, r7, #1
if ( priority == the_node->priority ) {
1079e4: 42b2 cmp r2, r6
1079e6: bf08 it eq
1079e8: 4299 cmpeq r1, r3
1079ea: d037 beq.n 107a5c <_Scheduler_EDF_Update_priority+0x90> <== ALWAYS TAKEN
return scheduler->context;
1079ec: f8d0 9000 ldr.w r9, [r0]
_RBTree_Extract( &context->Ready, &node->Node );
1079f0: f105 0a38 add.w sl, r5, #56 ; 0x38
/* Nothing to do */
return;
}
the_node->priority = priority;
1079f4: 64ab str r3, [r5, #72] ; 0x48
1079f6: 4680 mov r8, r0
1079f8: 4651 mov r1, sl
1079fa: 64ee str r6, [r5, #76] ; 0x4c
1079fc: 4648 mov r0, r9
1079fe: f002 fd03 bl 10a408 <_RBTree_Extract>
link = _RBTree_Root_reference( the_rbtree );
parent = NULL;
is_new_minimum = true;
while ( *link != NULL ) {
107a02: f8d9 3000 ldr.w r3, [r9]
107a06: b90b cbnz r3, 107a0c <_Scheduler_EDF_Update_priority+0x40>
107a08: e043 b.n 107a92 <_Scheduler_EDF_Update_priority+0xc6> <== NOT EXECUTED
107a0a: 4623 mov r3, r4
parent = *link;
if ( ( *less )( key, parent ) ) {
107a0c: e9d3 4204 ldrd r4, r2, [r3, #16]
return &RB_RIGHT( the_node, Node );
107a10: f103 0c04 add.w ip, r3, #4
if ( ( *less )( key, parent ) ) {
107a14: 42bc cmp r4, r7
107a16: 41b2 sbcs r2, r6
return &RB_LEFT( the_node, Node );
107a18: bf28 it cs
107a1a: 469c movcs ip, r3
while ( *link != NULL ) {
107a1c: f8dc 4000 ldr.w r4, [ip]
107a20: 2c00 cmp r4, #0
107a22: d1f2 bne.n 107a0a <_Scheduler_EDF_Update_priority+0x3e>
RB_SET( child, parent, Node );
107a24: 642b str r3, [r5, #64] ; 0x40
107a26: 2601 movs r6, #1
107a28: 2300 movs r3, #0
107a2a: 646e str r6, [r5, #68] ; 0x44
107a2c: e9c5 330e strd r3, r3, [r5, #56] ; 0x38
is_new_minimum = false;
}
}
_RBTree_Add_child( the_node, parent, link );
_RBTree_Insert_color( the_rbtree, the_node );
107a30: 4648 mov r0, r9
107a32: 4651 mov r1, sl
*link = child;
107a34: f8cc a000 str.w sl, [ip]
Thread_Control *heir = _Thread_Heir;
107a38: f641 6400 movw r4, #7680 ; 0x1e00
_RBTree_Insert_color( the_rbtree, the_node );
107a3c: f002 fe26 bl 10a68c <_RBTree_Insert_color>
107a40: f2c0 0420 movt r4, #32
first = _RBTree_Minimum( &context->Ready );
107a44: f8d8 0000 ldr.w r0, [r8]
107a48: f002 feac bl 10a7a4 <_RBTree_Minimum>
107a4c: 69e5 ldr r5, [r4, #28]
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
107a4e: f850 7c38 ldr.w r7, [r0, #-56]
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
107a52: 42af cmp r7, r5
107a54: d002 beq.n 107a5c <_Scheduler_EDF_Update_priority+0x90>
107a56: f895 3089 ldrb.w r3, [r5, #137] ; 0x89
107a5a: b913 cbnz r3, 107a62 <_Scheduler_EDF_Update_priority+0x96>
context = _Scheduler_EDF_Get_context( scheduler );
_Scheduler_EDF_Extract( context, the_node );
_Scheduler_EDF_Enqueue( context, the_node, insert_priority );
_Scheduler_EDF_Schedule_body( scheduler, the_thread, false );
}
107a5c: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
107a60: 4770 bx lr
107a62: e9d4 9808 ldrd r9, r8, [r4, #32]
107a66: f7ff fcaf bl 1073c8 <_Timecounter_Sbinuptime>
107a6a: 6220 str r0, [r4, #32]
107a6c: 6261 str r1, [r4, #36] ; 0x24
*_result = *_end - *_start;
107a6e: ebb0 0009 subs.w r0, r0, r9
*_time += *_add;
107a72: f8d5 3098 ldr.w r3, [r5, #152] ; 0x98
*_result = *_end - *_start;
107a76: eb61 0108 sbc.w r1, r1, r8
*_time += *_add;
107a7a: 1818 adds r0, r3, r0
107a7c: f8d5 309c ldr.w r3, [r5, #156] ; 0x9c
107a80: f8c5 0098 str.w r0, [r5, #152] ; 0x98
107a84: eb41 0103 adc.w r1, r1, r3
107a88: f8c5 109c str.w r1, [r5, #156] ; 0x9c
_Thread_Heir = new_heir;
107a8c: 61e7 str r7, [r4, #28]
_Thread_Dispatch_necessary = true;
107a8e: 7526 strb r6, [r4, #20]
107a90: e7e4 b.n 107a5c <_Scheduler_EDF_Update_priority+0x90>
link = _RBTree_Root_reference( the_rbtree );
107a92: 46cc mov ip, r9 <== NOT EXECUTED
107a94: e7c6 b.n 107a24 <_Scheduler_EDF_Update_priority+0x58> <== NOT EXECUTED
107a96: bf00 nop
00107c34 <_Scheduler_EDF_Yield>:
void _Scheduler_EDF_Yield(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
107c34: e92d 43f8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
_RBTree_Extract( &context->Ready, &node->Node );
107c38: f102 0838 add.w r8, r2, #56 ; 0x38
return scheduler->context;
107c3c: f8d0 9000 ldr.w r9, [r0]
107c40: 4606 mov r6, r0
107c42: 4641 mov r1, r8
107c44: 4615 mov r5, r2
107c46: 4648 mov r0, r9
107c48: f002 fbde bl 10a408 <_RBTree_Extract>
while ( *link != NULL ) {
107c4c: f8d9 3000 ldr.w r3, [r9]
context = _Scheduler_EDF_Get_context( scheduler );
the_node = _Scheduler_EDF_Node_downcast( node );
_Scheduler_EDF_Extract( context, the_node );
_Scheduler_EDF_Enqueue( context, the_node, the_node->priority );
107c50: 6caf ldr r7, [r5, #72] ; 0x48
107c52: 6cea ldr r2, [r5, #76] ; 0x4c
107c54: b90b cbnz r3, 107c5a <_Scheduler_EDF_Yield+0x26>
107c56: e03e b.n 107cd6 <_Scheduler_EDF_Yield+0xa2> <== NOT EXECUTED
107c58: 4623 mov r3, r4
if ( ( *less )( key, parent ) ) {
107c5a: 6919 ldr r1, [r3, #16]
return &RB_RIGHT( the_node, Node );
107c5c: f103 0c04 add.w ip, r3, #4
if ( ( *less )( key, parent ) ) {
107c60: 695c ldr r4, [r3, #20]
107c62: 42b9 cmp r1, r7
107c64: eb74 0102 sbcs.w r1, r4, r2
return &RB_LEFT( the_node, Node );
107c68: bf28 it cs
107c6a: 469c movcs ip, r3
while ( *link != NULL ) {
107c6c: f8dc 4000 ldr.w r4, [ip]
107c70: 2c00 cmp r4, #0
107c72: d1f1 bne.n 107c58 <_Scheduler_EDF_Yield+0x24>
RB_SET( child, parent, Node );
107c74: 642b str r3, [r5, #64] ; 0x40
107c76: 2701 movs r7, #1
107c78: 2300 movs r3, #0
107c7a: 646f str r7, [r5, #68] ; 0x44
107c7c: e9c5 330e strd r3, r3, [r5, #56] ; 0x38
_RBTree_Insert_color( the_rbtree, the_node );
107c80: 4648 mov r0, r9
107c82: 4641 mov r1, r8
*link = child;
107c84: f8cc 8000 str.w r8, [ip]
Thread_Control *heir = _Thread_Heir;
107c88: f641 6400 movw r4, #7680 ; 0x1e00
_RBTree_Insert_color( the_rbtree, the_node );
107c8c: f002 fcfe bl 10a68c <_RBTree_Insert_color>
107c90: f2c0 0420 movt r4, #32
first = _RBTree_Minimum( &context->Ready );
107c94: 6830 ldr r0, [r6, #0]
107c96: f002 fd85 bl 10a7a4 <_RBTree_Minimum>
107c9a: 69e5 ldr r5, [r4, #28]
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
107c9c: f850 6c38 ldr.w r6, [r0, #-56]
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
107ca0: 42ae cmp r6, r5
107ca2: d016 beq.n 107cd2 <_Scheduler_EDF_Yield+0x9e> <== ALWAYS TAKEN
107ca4: e9d4 9808 ldrd r9, r8, [r4, #32]
107ca8: f7ff fb8e bl 1073c8 <_Timecounter_Sbinuptime>
107cac: 6220 str r0, [r4, #32]
107cae: 6261 str r1, [r4, #36] ; 0x24
*_result = *_end - *_start;
107cb0: ebb0 0009 subs.w r0, r0, r9
*_time += *_add;
107cb4: f8d5 3098 ldr.w r3, [r5, #152] ; 0x98
*_result = *_end - *_start;
107cb8: eb61 0108 sbc.w r1, r1, r8
*_time += *_add;
107cbc: 1818 adds r0, r3, r0
107cbe: f8d5 309c ldr.w r3, [r5, #156] ; 0x9c
107cc2: f8c5 0098 str.w r0, [r5, #152] ; 0x98
107cc6: eb41 0103 adc.w r1, r1, r3
107cca: f8c5 109c str.w r1, [r5, #156] ; 0x9c
_Thread_Heir = new_heir;
107cce: 61e6 str r6, [r4, #28]
_Thread_Dispatch_necessary = true;
107cd0: 7527 strb r7, [r4, #20]
_Scheduler_EDF_Schedule_body( scheduler, the_thread, true );
}
107cd2: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
link = _RBTree_Root_reference( the_rbtree );
107cd6: 46cc mov ip, r9 <== NOT EXECUTED
107cd8: e7cc b.n 107c74 <_Scheduler_EDF_Yield+0x40> <== NOT EXECUTED
107cda: bf00 nop
00109190 <_Scheduler_Set_affinity>:
bool _Scheduler_Set_affinity(
Thread_Control *the_thread,
size_t cpusetsize,
const cpu_set_t *cpuset
)
{
109190: b500 push {lr}
109192: b083 sub sp, #12
109194: 460b mov r3, r1
Processor_mask *dst,
size_t src_size,
const cpu_set_t *src
)
{
return _Processor_mask_Copy(
109196: a801 add r0, sp, #4
109198: 2104 movs r1, #4
10919a: f002 fe7b bl 10be94 <_Processor_mask_Copy>
Scheduler_Node *node;
ISR_lock_Context lock_context;
bool ok;
status = _Processor_mask_From_cpu_set_t( &affinity, cpusetsize, cpuset );
if ( !_Processor_mask_Is_at_most_partial_loss( status ) ) {
10919e: 2801 cmp r0, #1
return false;
1091a0: bf88 it hi
1091a2: 2000 movhi r0, #0
if ( !_Processor_mask_Is_at_most_partial_loss( status ) ) {
1091a4: d809 bhi.n 1091ba <_Scheduler_Set_affinity+0x2a> <== ALWAYS TAKEN
BIT_AND2( CPU_MAXIMUM_PROCESSORS, a, b, c );
1091a6: f245 23b8 movw r3, #21176 ; 0x52b8
1091aa: 9a01 ldr r2, [sp, #4]
1091ac: f2c0 0315 movt r3, #21
1091b0: 681b ldr r3, [r3, #0]
return BIT_SUBSET( CPU_MAXIMUM_PROCESSORS, big, small );
1091b2: 4393 bics r3, r2
1091b4: bf0c ite eq
1091b6: 2001 moveq r0, #1
1091b8: 2000 movne r0, #0
);
#endif
_Scheduler_Release_critical( scheduler, &lock_context );
return ok;
}
1091ba: b003 add sp, #12
1091bc: f85d fb04 ldr.w pc, [sp], #4
0010a104 <_Scheduler_default_Tick>:
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10a104: f891 3089 ldrb.w r3, [r1, #137] ; 0x89
10a108: b133 cbz r3, 10a118 <_Scheduler_default_Tick+0x14>
return;
if ( !_States_Is_ready( executing->current_state ) )
10a10a: 69cb ldr r3, [r1, #28]
10a10c: b923 cbnz r3, 10a118 <_Scheduler_default_Tick+0x14>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10a10e: f8d1 3090 ldr.w r3, [r1, #144] ; 0x90
10a112: 2b02 cmp r3, #2
10a114: d801 bhi.n 10a11a <_Scheduler_default_Tick+0x16>
10a116: b96b cbnz r3, 10a134 <_Scheduler_default_Tick+0x30>
10a118: 4770 bx lr
10a11a: 2b03 cmp r3, #3
10a11c: d122 bne.n 10a164 <_Scheduler_default_Tick+0x60> <== ALWAYS TAKEN
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
10a11e: f8d1 308c ldr.w r3, [r1, #140] ; 0x8c
10a122: 3b01 subs r3, #1
10a124: f8c1 308c str.w r3, [r1, #140] ; 0x8c
10a128: 2b00 cmp r3, #0
10a12a: d1f5 bne.n 10a118 <_Scheduler_default_Tick+0x14>
(*executing->budget_callout)( executing );
10a12c: f8d1 3094 ldr.w r3, [r1, #148] ; 0x94
10a130: 4608 mov r0, r1
10a132: 4718 bx r3
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
10a134: f8d1 308c ldr.w r3, [r1, #140] ; 0x8c
10a138: 3b01 subs r3, #1
10a13a: 2b00 cmp r3, #0
10a13c: f8c1 308c str.w r3, [r1, #140] ; 0x8c
10a140: dcea bgt.n 10a118 <_Scheduler_default_Tick+0x14>
{
10a142: b500 push {lr}
_Thread_Yield( executing );
10a144: 4608 mov r0, r1
{
10a146: b083 sub sp, #12
_Thread_Yield( executing );
10a148: 9101 str r1, [sp, #4]
10a14a: f001 fae5 bl 10b718 <_Thread_Yield>
executing->cpu_time_budget =
10a14e: f248 13d8 movw r3, #33240 ; 0x81d8
10a152: 9901 ldr r1, [sp, #4]
10a154: f2c0 0311 movt r3, #17
10a158: 681b ldr r3, [r3, #0]
10a15a: f8c1 308c str.w r3, [r1, #140] ; 0x8c
break;
#endif
}
}
10a15e: b003 add sp, #12
10a160: f85d fb04 ldr.w pc, [sp], #4
10a164: 4770 bx lr <== NOT EXECUTED
10a166: bf00 nop
0010a470 <_Scheduler_priority_Unblock>:
void _Scheduler_priority_Unblock (
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
10a470: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
10a474: 460c mov r4, r1
do {
seq = _SMP_sequence_lock_Read_begin( &node->Priority.Lock );
#endif
priority = node->Priority.value;
10a476: 6b16 ldr r6, [r2, #48] ; 0x30
context = _Scheduler_priority_Get_context( scheduler );
the_node = _Scheduler_priority_Node_downcast( node );
priority = (unsigned int ) _Scheduler_Node_get_priority( &the_node->Base );
unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority );
if ( unmapped_priority != the_node->Ready_queue.current_priority ) {
10a478: 6b93 ldr r3, [r2, #56] ; 0x38
return scheduler->context;
10a47a: 6805 ldr r5, [r0, #0]
unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority );
10a47c: 0871 lsrs r1, r6, #1
if ( unmapped_priority != the_node->Ready_queue.current_priority ) {
10a47e: 428b cmp r3, r1
10a480: d129 bne.n 10a4d6 <_Scheduler_priority_Unblock+0x66>
*bit_map_info->minor |= bit_map_info->ready_minor;
10a482: e9d2 100f ldrd r1, r0, [r2, #60] ; 0x3c
10a486: f8b2 3046 ldrh.w r3, [r2, #70] ; 0x46
10a48a: f8b0 c000 ldrh.w ip, [r0]
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
10a48e: f242 7780 movw r7, #10112 ; 0x2780
10a492: f2c0 0720 movt r7, #32
return &the_chain->Tail.Node;
10a496: f101 0e04 add.w lr, r1, #4
10a49a: f8d7 801c ldr.w r8, [r7, #28]
10a49e: ea43 030c orr.w r3, r3, ip
old_last = tail->previous;
10a4a2: f8d1 c008 ldr.w ip, [r1, #8]
the_node->next = tail;
10a4a6: f8c4 e000 str.w lr, [r4]
tail->previous = the_node;
10a4aa: 608c str r4, [r1, #8]
old_last->next = the_node;
10a4ac: f8cc 4000 str.w r4, [ip]
the_node->previous = old_last;
10a4b0: f8c4 c004 str.w ip, [r4, #4]
10a4b4: 8003 strh r3, [r0, #0]
bit_map->major_bit_map |= bit_map_info->ready_major;
10a4b6: f8b2 1044 ldrh.w r1, [r2, #68] ; 0x44
10a4ba: 882b ldrh r3, [r5, #0]
*/
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_priority(
const Priority_Aggregation *aggregation
)
{
return aggregation->Node.priority;
10a4bc: f8d8 2038 ldr.w r2, [r8, #56] ; 0x38
10a4c0: 430b orrs r3, r1
10a4c2: 802b strh r3, [r5, #0]
10a4c4: e9d2 1306 ldrd r1, r3, [r2, #24]
10a4c8: 2200 movs r2, #0
10a4ca: 428e cmp r6, r1
10a4cc: eb72 0303 sbcs.w r3, r2, r3
10a4d0: d324 bcc.n 10a51c <_Scheduler_priority_Unblock+0xac>
_Scheduler_Update_heir( the_thread, priority == PRIORITY_PSEUDO_ISR );
}
}
10a4d2: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
return the_priority / 16;
10a4d6: 0970 lsrs r0, r6, #5
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
10a4d8: f44f 4c00 mov.w ip, #32768 ; 0x8000
return the_priority % 16;
10a4dc: f001 030f and.w r3, r1, #15
ready_queue->current_priority = new_priority;
10a4e0: 6391 str r1, [r2, #56] ; 0x38
return (Priority_bit_map_Word) ( 0x8000u >> bit_number );
10a4e2: fa2c fe00 lsr.w lr, ip, r0
10a4e6: fa2c f303 lsr.w r3, ip, r3
ready_queue->ready_chain = &ready_queues[ new_priority ];
10a4ea: eb01 0c41 add.w ip, r1, r1, lsl #1
10a4ee: fa1f f18e uxth.w r1, lr
10a4f2: b29b uxth r3, r3
bit_map_info->ready_major = mask;
10a4f4: f8a2 1044 strh.w r1, [r2, #68] ; 0x44
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
10a4f8: 43c9 mvns r1, r1
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
10a4fa: 3001 adds r0, #1
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
10a4fc: f8a2 1048 strh.w r1, [r2, #72] ; 0x48
_Scheduler_priority_Ready_queue_update(
10a500: f105 0124 add.w r1, r5, #36 ; 0x24
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
10a504: eb05 0040 add.w r0, r5, r0, lsl #1
10a508: eb01 018c add.w r1, r1, ip, lsl #2
bit_map_info->block_minor = (Priority_bit_map_Word) ~mask;
10a50c: 43df mvns r7, r3
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
10a50e: 6410 str r0, [r2, #64] ; 0x40
bit_map_info->ready_minor = mask;
10a510: f8a2 3046 strh.w r3, [r2, #70] ; 0x46
10a514: 63d1 str r1, [r2, #60] ; 0x3c
bit_map_info->block_minor = (Priority_bit_map_Word) ~mask;
10a516: f8a2 704a strh.w r7, [r2, #74] ; 0x4a
_Priority_bit_map_Initialize_information(
bit_map,
&ready_queue->Priority_map,
new_priority
);
}
10a51a: e7b6 b.n 10a48a <_Scheduler_priority_Unblock+0x1a>
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
10a51c: 45a0 cmp r8, r4
10a51e: d0d8 beq.n 10a4d2 <_Scheduler_priority_Unblock+0x62> <== ALWAYS TAKEN
10a520: f898 3089 ldrb.w r3, [r8, #137] ; 0x89
10a524: 4296 cmp r6, r2
10a526: bf08 it eq
10a528: f043 0301 orreq.w r3, r3, #1
10a52c: 2b00 cmp r3, #0
10a52e: d0d0 beq.n 10a4d2 <_Scheduler_priority_Unblock+0x62>
10a530: e9d7 5608 ldrd r5, r6, [r7, #32]
10a534: f7ff fb20 bl 109b78 <_Timecounter_Sbinuptime>
10a538: 6238 str r0, [r7, #32]
10a53a: 6279 str r1, [r7, #36] ; 0x24
*_result = *_end - *_start;
10a53c: 1b40 subs r0, r0, r5
*_time += *_add;
10a53e: f8d8 3098 ldr.w r3, [r8, #152] ; 0x98
*_result = *_end - *_start;
10a542: eb61 0106 sbc.w r1, r1, r6
*_time += *_add;
10a546: f8d8 209c ldr.w r2, [r8, #156] ; 0x9c
10a54a: 1818 adds r0, r3, r0
_Thread_Dispatch_necessary = true;
10a54c: f04f 0301 mov.w r3, #1
10a550: eb41 0102 adc.w r1, r1, r2
10a554: f8c8 0098 str.w r0, [r8, #152] ; 0x98
10a558: f8c8 109c str.w r1, [r8, #156] ; 0x9c
_Thread_Heir = new_heir;
10a55c: 61fc str r4, [r7, #28]
_Thread_Dispatch_necessary = true;
10a55e: 753b strb r3, [r7, #20]
}
10a560: e7b7 b.n 10a4d2 <_Scheduler_priority_Unblock+0x62>
10a562: bf00 nop
001077c0 <_Scheduler_simple_Block>:
previous = the_node->previous;
1077c0: e9d1 2300 ldrd r2, r3, [r1]
void _Scheduler_simple_Block(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
1077c4: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
return ( the_thread == _Thread_Heir );
1077c8: f641 3480 movw r4, #7040 ; 0x1b80
1077cc: f2c0 0420 movt r4, #32
next->previous = previous;
1077d0: 6053 str r3, [r2, #4]
previous->next = next;
1077d2: 601a str r2, [r3, #0]
1077d4: e9d4 3506 ldrd r3, r5, [r4, #24]
{
( *extract )( scheduler, the_thread, node );
/* TODO: flash critical section? */
if ( _Thread_Is_executing( the_thread ) || _Thread_Is_heir( the_thread ) ) {
1077d8: 4299 cmp r1, r3
1077da: d003 beq.n 1077e4 <_Scheduler_simple_Block+0x24>
1077dc: 42a9 cmp r1, r5
1077de: d001 beq.n 1077e4 <_Scheduler_simple_Block+0x24> <== ALWAYS TAKEN
the_thread,
node,
_Scheduler_simple_Extract,
_Scheduler_simple_Schedule_body
);
}
1077e0: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
return _Chain_Immutable_head( the_chain )->next;
1077e4: 6803 ldr r3, [r0, #0]
1077e6: 681e ldr r6, [r3, #0]
bool force_dispatch
)
{
Thread_Control *heir = _Thread_Heir;
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
1077e8: 42ae cmp r6, r5
1077ea: d0f9 beq.n 1077e0 <_Scheduler_simple_Block+0x20> <== ALWAYS TAKEN
last = cpu->cpu_usage_timestamp;
1077ec: e9d4 7808 ldrd r7, r8, [r4, #32]
*time = _Timecounter_Sbinuptime();
1077f0: f7ff fd80 bl 1072f4 <_Timecounter_Sbinuptime>
1077f4: 6220 str r0, [r4, #32]
1077f6: 6261 str r1, [r4, #36] ; 0x24
const Timestamp_Control *_start,
const Timestamp_Control *_end,
Timestamp_Control *_result
)
{
*_result = *_end - *_start;
1077f8: 1bc0 subs r0, r0, r7
*_time += *_add;
1077fa: f8d5 3098 ldr.w r3, [r5, #152] ; 0x98
*_result = *_end - *_start;
1077fe: eb61 0108 sbc.w r1, r1, r8
*_time += *_add;
107802: f8d5 209c ldr.w r2, [r5, #156] ; 0x9c
107806: 1818 adds r0, r3, r0
heir->Scheduler.state = THREAD_SCHEDULER_BLOCKED;
new_heir->Scheduler.state = THREAD_SCHEDULER_SCHEDULED;
#endif
_Thread_Update_CPU_time_used( heir, _Thread_Get_CPU( heir ) );
_Thread_Heir = new_heir;
_Thread_Dispatch_necessary = true;
107808: f04f 0301 mov.w r3, #1
10780c: eb41 0102 adc.w r1, r1, r2
107810: f8c5 0098 str.w r0, [r5, #152] ; 0x98
107814: f8c5 109c str.w r1, [r5, #156] ; 0x9c
_Thread_Heir = new_heir;
107818: 61e6 str r6, [r4, #28]
_Thread_Dispatch_necessary = true;
10781a: 7523 strb r3, [r4, #20]
10781c: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
001078c0 <_Scheduler_simple_Schedule>:
return _Chain_Immutable_head( the_chain )->next;
1078c0: 6803 ldr r3, [r0, #0] <== NOT EXECUTED
void _Scheduler_simple_Schedule(
const Scheduler_Control *scheduler,
Thread_Control *the_thread
)
{
1078c2: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
Thread_Control *heir = _Thread_Heir;
1078c6: f641 3480 movw r4, #7040 ; 0x1b80 <== NOT EXECUTED
1078ca: f2c0 0420 movt r4, #32 <== NOT EXECUTED
1078ce: 69e5 ldr r5, [r4, #28] <== NOT EXECUTED
1078d0: 681e ldr r6, [r3, #0] <== NOT EXECUTED
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
1078d2: 42ae cmp r6, r5 <== NOT EXECUTED
1078d4: d002 beq.n 1078dc <_Scheduler_simple_Schedule+0x1c> <== NOT EXECUTED
1078d6: f895 3089 ldrb.w r3, [r5, #137] ; 0x89 <== NOT EXECUTED
1078da: b90b cbnz r3, 1078e0 <_Scheduler_simple_Schedule+0x20> <== NOT EXECUTED
_Scheduler_simple_Schedule_body( scheduler, the_thread, false );
}
1078dc: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
1078e0: e9d4 7808 ldrd r7, r8, [r4, #32] <== NOT EXECUTED
1078e4: f7ff fd06 bl 1072f4 <_Timecounter_Sbinuptime> <== NOT EXECUTED
1078e8: 6220 str r0, [r4, #32] <== NOT EXECUTED
1078ea: 6261 str r1, [r4, #36] ; 0x24 <== NOT EXECUTED
*_result = *_end - *_start;
1078ec: 1bc0 subs r0, r0, r7 <== NOT EXECUTED
*_time += *_add;
1078ee: f8d5 3098 ldr.w r3, [r5, #152] ; 0x98 <== NOT EXECUTED
*_result = *_end - *_start;
1078f2: eb61 0108 sbc.w r1, r1, r8 <== NOT EXECUTED
*_time += *_add;
1078f6: f8d5 209c ldr.w r2, [r5, #156] ; 0x9c <== NOT EXECUTED
1078fa: 1818 adds r0, r3, r0 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
1078fc: f04f 0301 mov.w r3, #1 <== NOT EXECUTED
107900: eb41 0102 adc.w r1, r1, r2 <== NOT EXECUTED
107904: f8c5 0098 str.w r0, [r5, #152] ; 0x98 <== NOT EXECUTED
107908: f8c5 109c str.w r1, [r5, #156] ; 0x9c <== NOT EXECUTED
_Thread_Heir = new_heir;
10790c: 61e6 str r6, [r4, #28] <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
10790e: 7523 strb r3, [r4, #20] <== NOT EXECUTED
107910: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00107914 <_Scheduler_simple_Unblock>:
void _Scheduler_simple_Unblock(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
107914: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
107918: 460d mov r5, r1
return &the_chain->Tail.Node;
10791a: 6804 ldr r4, [r0, #0]
10791c: 6b8a ldr r2, [r1, #56] ; 0x38
return _Chain_Immutable_head( the_chain )->next;
10791e: f854 3b04 ldr.w r3, [r4], #4
107922: 6991 ldr r1, [r2, #24]
while ( next != tail && !( *order )( left, next ) ) {
107924: 429c cmp r4, r3
107926: bf18 it ne
107928: f041 0c01 orrne.w ip, r1, #1
10792c: d103 bne.n 107936 <_Scheduler_simple_Unblock+0x22>
10792e: e009 b.n 107944 <_Scheduler_simple_Unblock+0x30>
return the_node->next;
107930: 681b ldr r3, [r3, #0]
while ( next != tail && !( *order )( left, next ) ) {
107932: 429c cmp r4, r3
107934: d006 beq.n 107944 <_Scheduler_simple_Unblock+0x30>
107936: 6b9a ldr r2, [r3, #56] ; 0x38
107938: e9d2 0206 ldrd r0, r2, [r2, #24]
10793c: 4560 cmp r0, ip
10793e: f172 0200 sbcs.w r2, r2, #0
107942: d3f5 bcc.n 107930 <_Scheduler_simple_Unblock+0x1c>
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
107944: f641 3480 movw r4, #7040 ; 0x1b80
return the_node->previous;
107948: 685b ldr r3, [r3, #4]
10794a: f2c0 0420 movt r4, #32
10794e: 69e6 ldr r6, [r4, #28]
before_node = after_node->next;
107950: 681a ldr r2, [r3, #0]
the_node->previous = after_node;
107952: 606b str r3, [r5, #4]
after_node->next = the_node;
107954: 601d str r5, [r3, #0]
107956: 6bb3 ldr r3, [r6, #56] ; 0x38
the_node->next = before_node;
107958: 602a str r2, [r5, #0]
before_node->previous = the_node;
10795a: 6055 str r5, [r2, #4]
10795c: 2200 movs r2, #0
10795e: e9d3 0306 ldrd r0, r3, [r3, #24]
107962: 4281 cmp r1, r0
107964: eb72 0303 sbcs.w r3, r2, r3
107968: d301 bcc.n 10796e <_Scheduler_simple_Unblock+0x5a>
_Scheduler_Update_heir(
the_thread,
priority == PRIORITY_PSEUDO_ISR
);
}
}
10796a: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
10796e: 42ae cmp r6, r5
107970: d0fb beq.n 10796a <_Scheduler_simple_Unblock+0x56> <== ALWAYS TAKEN
107972: f896 3089 ldrb.w r3, [r6, #137] ; 0x89
107976: 4291 cmp r1, r2
107978: bf08 it eq
10797a: f043 0301 orreq.w r3, r3, #1
10797e: 2b00 cmp r3, #0
107980: d0f3 beq.n 10796a <_Scheduler_simple_Unblock+0x56>
107982: e9d4 7808 ldrd r7, r8, [r4, #32]
107986: f7ff fcb5 bl 1072f4 <_Timecounter_Sbinuptime>
10798a: 6220 str r0, [r4, #32]
10798c: 6261 str r1, [r4, #36] ; 0x24
*_result = *_end - *_start;
10798e: 1bc0 subs r0, r0, r7
*_time += *_add;
107990: f8d6 2098 ldr.w r2, [r6, #152] ; 0x98
*_result = *_end - *_start;
107994: eb61 0308 sbc.w r3, r1, r8
*_time += *_add;
107998: f8d6 109c ldr.w r1, [r6, #156] ; 0x9c
10799c: 1810 adds r0, r2, r0
_Thread_Dispatch_necessary = true;
10799e: f04f 0201 mov.w r2, #1
1079a2: eb43 0301 adc.w r3, r3, r1
1079a6: f8c6 0098 str.w r0, [r6, #152] ; 0x98
1079aa: f8c6 309c str.w r3, [r6, #156] ; 0x9c
_Thread_Heir = new_heir;
1079ae: 61e5 str r5, [r4, #28]
_Thread_Dispatch_necessary = true;
1079b0: 7522 strb r2, [r4, #20]
1079b2: e7da b.n 10796a <_Scheduler_simple_Unblock+0x56>
00107830 <_Scheduler_simple_Update_priority>:
)
{
Scheduler_simple_Context *context;
unsigned int new_priority;
if ( !_Thread_Is_ready( the_thread ) ) {
107830: 69cb ldr r3, [r1, #28]
107832: b103 cbz r3, 107836 <_Scheduler_simple_Update_priority+0x6>
107834: 4770 bx lr <== NOT EXECUTED
{
107836: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
10783a: 6806 ldr r6, [r0, #0]
previous = the_node->previous;
10783c: e9d1 0300 ldrd r0, r3, [r1]
return &the_chain->Tail.Node;
107840: 46b4 mov ip, r6
do {
seq = _SMP_sequence_lock_Read_begin( &node->Priority.Lock );
#endif
priority = node->Priority.value;
107842: 6b14 ldr r4, [r2, #48] ; 0x30
next->previous = previous;
107844: 6043 str r3, [r0, #4]
previous->next = next;
107846: 6018 str r0, [r3, #0]
return _Chain_Immutable_head( the_chain )->next;
107848: f85c 3b04 ldr.w r3, [ip], #4
)
{
const Chain_Node *tail = _Chain_Immutable_tail( the_chain );
Chain_Node *next = _Chain_First( the_chain );
while ( next != tail && !( *order )( left, next ) ) {
10784c: 459c cmp ip, r3
10784e: d103 bne.n 107858 <_Scheduler_simple_Update_priority+0x28> <== NEVER TAKEN
107850: e009 b.n 107866 <_Scheduler_simple_Update_priority+0x36> <== NOT EXECUTED
return the_node->next;
107852: 681b ldr r3, [r3, #0]
while ( next != tail && !( *order )( left, next ) ) {
107854: 459c cmp ip, r3
107856: d006 beq.n 107866 <_Scheduler_simple_Update_priority+0x36>
return aggregation->Node.priority;
107858: 6b9a ldr r2, [r3, #56] ; 0x38
10785a: e9d2 0206 ldrd r0, r2, [r2, #24]
10785e: 42a0 cmp r0, r4
107860: f172 0200 sbcs.w r2, r2, #0
107864: d3f5 bcc.n 107852 <_Scheduler_simple_Update_priority+0x22>
return the_node->previous;
107866: 685b ldr r3, [r3, #4]
Thread_Control *heir = _Thread_Heir;
107868: f641 3480 movw r4, #7040 ; 0x1b80
10786c: f2c0 0420 movt r4, #32
107870: 69e5 ldr r5, [r4, #28]
before_node = after_node->next;
107872: 681a ldr r2, [r3, #0]
the_node->previous = after_node;
107874: 604b str r3, [r1, #4]
after_node->next = the_node;
107876: 6019 str r1, [r3, #0]
the_node->next = before_node;
107878: 600a str r2, [r1, #0]
return _Chain_Immutable_head( the_chain )->next;
10787a: 6836 ldr r6, [r6, #0]
before_node->previous = the_node;
10787c: 6051 str r1, [r2, #4]
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
10787e: 42ae cmp r6, r5
107880: d002 beq.n 107888 <_Scheduler_simple_Update_priority+0x58>
107882: f895 3089 ldrb.w r3, [r5, #137] ; 0x89
107886: b90b cbnz r3, 10788c <_Scheduler_simple_Update_priority+0x5c>
new_priority = (unsigned int ) _Scheduler_Node_get_priority( node );
_Scheduler_simple_Extract( scheduler, the_thread, node );
_Scheduler_simple_Insert( &context->Ready, the_thread, new_priority );
_Scheduler_simple_Schedule_body( scheduler, the_thread, false );
}
107888: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
10788c: e9d4 7808 ldrd r7, r8, [r4, #32] <== NOT EXECUTED
107890: f7ff fd30 bl 1072f4 <_Timecounter_Sbinuptime> <== NOT EXECUTED
107894: 6220 str r0, [r4, #32] <== NOT EXECUTED
107896: 6261 str r1, [r4, #36] ; 0x24 <== NOT EXECUTED
*_result = *_end - *_start;
107898: 1bc0 subs r0, r0, r7 <== NOT EXECUTED
*_time += *_add;
10789a: f8d5 3098 ldr.w r3, [r5, #152] ; 0x98 <== NOT EXECUTED
*_result = *_end - *_start;
10789e: eb61 0108 sbc.w r1, r1, r8 <== NOT EXECUTED
*_time += *_add;
1078a2: f8d5 209c ldr.w r2, [r5, #156] ; 0x9c <== NOT EXECUTED
1078a6: 1818 adds r0, r3, r0 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
1078a8: f04f 0301 mov.w r3, #1 <== NOT EXECUTED
1078ac: eb41 0102 adc.w r1, r1, r2 <== NOT EXECUTED
1078b0: f8c5 0098 str.w r0, [r5, #152] ; 0x98 <== NOT EXECUTED
1078b4: f8c5 109c str.w r1, [r5, #156] ; 0x9c <== NOT EXECUTED
_Thread_Heir = new_heir;
1078b8: 61e6 str r6, [r4, #28] <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
1078ba: 7523 strb r3, [r4, #20] <== NOT EXECUTED
1078bc: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
001079b4 <_Scheduler_simple_Yield>:
void _Scheduler_simple_Yield(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
1079b4: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
return scheduler->context;
1079b8: 6806 ldr r6, [r0, #0]
previous = the_node->previous;
1079ba: e9d1 2300 ldrd r2, r3, [r1]
1079be: 6b88 ldr r0, [r1, #56] ; 0x38
return &the_chain->Tail.Node;
1079c0: 46b4 mov ip, r6
next->previous = previous;
1079c2: 6053 str r3, [r2, #4]
previous->next = next;
1079c4: 601a str r2, [r3, #0]
return _Chain_Immutable_head( the_chain )->next;
1079c6: f85c 3b04 ldr.w r3, [ip], #4
context = _Scheduler_simple_Get_context( scheduler );
(void) node;
_Chain_Extract_unprotected( &the_thread->Object.Node );
insert_priority = (unsigned int) _Thread_Get_priority( the_thread );
1079ca: 6982 ldr r2, [r0, #24]
while ( next != tail && !( *order )( left, next ) ) {
1079cc: 459c cmp ip, r3
1079ce: bf18 it ne
1079d0: f042 0e01 orrne.w lr, r2, #1
1079d4: d103 bne.n 1079de <_Scheduler_simple_Yield+0x2a> <== NEVER TAKEN
1079d6: e009 b.n 1079ec <_Scheduler_simple_Yield+0x38> <== NOT EXECUTED
return the_node->next;
1079d8: 681b ldr r3, [r3, #0]
while ( next != tail && !( *order )( left, next ) ) {
1079da: 459c cmp ip, r3
1079dc: d006 beq.n 1079ec <_Scheduler_simple_Yield+0x38> <== ALWAYS TAKEN
1079de: 6b9a ldr r2, [r3, #56] ; 0x38
1079e0: e9d2 0206 ldrd r0, r2, [r2, #24]
1079e4: 4570 cmp r0, lr
1079e6: f172 0200 sbcs.w r2, r2, #0
1079ea: d3f5 bcc.n 1079d8 <_Scheduler_simple_Yield+0x24>
return the_node->previous;
1079ec: 685b ldr r3, [r3, #4]
Thread_Control *heir = _Thread_Heir;
1079ee: f641 3480 movw r4, #7040 ; 0x1b80
1079f2: f2c0 0420 movt r4, #32
1079f6: 69e5 ldr r5, [r4, #28]
before_node = after_node->next;
1079f8: 681a ldr r2, [r3, #0]
the_node->previous = after_node;
1079fa: 604b str r3, [r1, #4]
after_node->next = the_node;
1079fc: 6019 str r1, [r3, #0]
the_node->next = before_node;
1079fe: 600a str r2, [r1, #0]
return _Chain_Immutable_head( the_chain )->next;
107a00: 6836 ldr r6, [r6, #0]
before_node->previous = the_node;
107a02: 6051 str r1, [r2, #4]
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
107a04: 42ae cmp r6, r5
107a06: d002 beq.n 107a0e <_Scheduler_simple_Yield+0x5a>
107a08: f895 3089 ldrb.w r3, [r5, #137] ; 0x89
107a0c: b90b cbnz r3, 107a12 <_Scheduler_simple_Yield+0x5e>
insert_priority = SCHEDULER_PRIORITY_APPEND( insert_priority );
_Scheduler_simple_Insert( &context->Ready, the_thread, insert_priority );
_Scheduler_simple_Schedule_body( scheduler, the_thread, false );
}
107a0e: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
107a12: e9d4 7808 ldrd r7, r8, [r4, #32] <== NOT EXECUTED
107a16: f7ff fc6d bl 1072f4 <_Timecounter_Sbinuptime> <== NOT EXECUTED
107a1a: 6220 str r0, [r4, #32] <== NOT EXECUTED
107a1c: 6261 str r1, [r4, #36] ; 0x24 <== NOT EXECUTED
*_result = *_end - *_start;
107a1e: 1bc0 subs r0, r0, r7 <== NOT EXECUTED
*_time += *_add;
107a20: f8d5 3098 ldr.w r3, [r5, #152] ; 0x98 <== NOT EXECUTED
*_result = *_end - *_start;
107a24: eb61 0108 sbc.w r1, r1, r8 <== NOT EXECUTED
*_time += *_add;
107a28: f8d5 209c ldr.w r2, [r5, #156] ; 0x9c <== NOT EXECUTED
107a2c: 1818 adds r0, r3, r0 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
107a2e: f04f 0301 mov.w r3, #1 <== NOT EXECUTED
107a32: eb41 0102 adc.w r1, r1, r2 <== NOT EXECUTED
107a36: f8c5 0098 str.w r0, [r5, #152] ; 0x98 <== NOT EXECUTED
107a3a: f8c5 109c str.w r1, [r5, #156] ; 0x9c <== NOT EXECUTED
_Thread_Heir = new_heir;
107a3e: 61e6 str r6, [r4, #28] <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
107a40: 7523 strb r3, [r4, #20] <== NOT EXECUTED
107a42: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
107a46: bf00 nop
0010f3b8 <_TLS_Get_allocation_size>:
size = (uintptr_t) _TLS_Size;
10f3b8: f240 0000 movw r0, #0
10f3bc: f2c0 0000 movt r0, #0
uintptr_t allocation_size;
uintptr_t alignment;
size = _TLS_Get_size();
if ( size == 0 ) {
10f3c0: b310 cbz r0, 10f408 <_TLS_Get_allocation_size+0x50>
{
10f3c2: b508 push {r3, lr}
return 0;
}
allocation_size = _TLS_Allocation_size;
10f3c4: f642 13f0 movw r3, #10736 ; 0x29f0
10f3c8: f2c0 0320 movt r3, #32
10f3cc: 681a ldr r2, [r3, #0]
if ( allocation_size == 0 ) {
10f3ce: b9ca cbnz r2, 10f404 <_TLS_Get_allocation_size+0x4c>
return (val + msk) & ~msk;
10f3d0: 4a0f ldr r2, [pc, #60] ; (10f410 <_TLS_Get_allocation_size+0x58>)
10f3d2: 3007 adds r0, #7
10f3d4: f020 0107 bic.w r1, r0, #7
10f3d8: f022 0007 bic.w r0, r2, #7
#ifndef __i386__
allocation_size += sizeof(TLS_Dynamic_thread_vector);
#endif
if ( _Thread_Maximum_TLS_size != 0 ) {
10f3dc: f247 72d0 movw r2, #30672 ; 0x77d0
10f3e0: f2c0 0211 movt r2, #17
if ( alignment > CPU_HEAP_ALIGNMENT ) {
10f3e4: 2808 cmp r0, #8
if ( _Thread_Maximum_TLS_size != 0 ) {
10f3e6: 6812 ldr r2, [r2, #0]
allocation_size += alignment;
10f3e8: bf88 it hi
10f3ea: 1809 addhi r1, r1, r0
sizeof(TLS_Thread_control_block) : alignment;
10f3ec: 2808 cmp r0, #8
10f3ee: bf38 it cc
10f3f0: 2008 movcc r0, #8
allocation_size += sizeof(TLS_Dynamic_thread_vector);
10f3f2: 3008 adds r0, #8
10f3f4: 4408 add r0, r1
if ( _Thread_Maximum_TLS_size != 0 ) {
10f3f6: b11a cbz r2, 10f400 <_TLS_Get_allocation_size+0x48>
if ( allocation_size <= _Thread_Maximum_TLS_size ) {
10f3f8: 4282 cmp r2, r0
10f3fa: bf28 it cs
10f3fc: 4610 movcs r0, r2
10f3fe: d304 bcc.n 10f40a <_TLS_Get_allocation_size+0x52>
} else {
_Internal_error( INTERNAL_ERROR_TOO_LARGE_TLS_SIZE );
}
}
_TLS_Allocation_size = allocation_size;
10f400: 6018 str r0, [r3, #0]
}
return allocation_size;
}
10f402: bd08 pop {r3, pc}
10f404: 4610 mov r0, r2
10f406: bd08 pop {r3, pc}
10f408: 4770 bx lr
_Internal_error( INTERNAL_ERROR_TOO_LARGE_TLS_SIZE );
10f40a: 2029 movs r0, #41 ; 0x29
10f40c: f7f9 fe9c bl 109148 <_Internal_error>
10f410: 00000008 .word 0x00000008
00109104 <_Terminate>:
void _Terminate(
Internal_errors_Source the_source,
Internal_errors_t the_error
)
{
109104: 460c mov r4, r1
109106: b500 push {lr}
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, error };
_User_extensions_Iterate(
109108: f24b 71dd movw r1, #47069 ; 0xb7dd
10910c: b083 sub sp, #12
10910e: 4605 mov r5, r0
109110: 2200 movs r2, #0
109112: f2c0 0110 movt r1, #16
109116: 4668 mov r0, sp
User_extensions_Fatal_context ctx = { source, error };
109118: e9cd 5400 strd r5, r4, [sp]
_User_extensions_Iterate(
10911c: f002 fb6a bl 10b7f4 <_User_extensions_Iterate>
_User_extensions_Fatal( the_source, the_error );
_Internal_errors_What_happened.the_source = the_source;
109120: f242 7348 movw r3, #10056 ; 0x2748 <== NOT EXECUTED
_System_state_Current = state;
109124: f242 7250 movw r2, #10064 ; 0x2750 <== NOT EXECUTED
109128: f2c0 0320 movt r3, #32 <== NOT EXECUTED
10912c: f2c0 0220 movt r2, #32 <== NOT EXECUTED
109130: 2103 movs r1, #3 <== NOT EXECUTED
_Internal_errors_What_happened.the_error = the_error;
109132: e9c3 5400 strd r5, r4, [r3] <== NOT EXECUTED
109136: 6011 str r1, [r2, #0] <== NOT EXECUTED
__asm__ volatile (
109138: f3ef 8200 mrs r2, CPSR <== NOT EXECUTED
10913c: f042 0380 orr.w r3, r2, #128 ; 0x80 <== NOT EXECUTED
109140: f383 8900 msr CPSR_fc, r3 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_TERMINATED );
_SMP_Request_shutdown();
_CPU_Fatal_halt( the_source, the_error );
109144: 4620 mov r0, r4 <== NOT EXECUTED
109146: e7fe b.n 109146 <_Terminate+0x42> <== NOT EXECUTED
0010a314 <_Thread_Allocate_unlimited>:
}
}
}
Objects_Control *_Thread_Allocate_unlimited( Objects_Information *information )
{
10a314: b5f8 push {r3, r4, r5, r6, r7, lr}
return _Chain_Immutable_head( the_chain )->next;
10a316: 4606 mov r6, r0
10a318: f856 5f18 ldr.w r5, [r6, #24]!
return &the_chain->Tail.Node;
10a31c: f100 071c add.w r7, r0, #28
10a320: 4604 mov r4, r0
if ( !_Chain_Is_empty(the_chain))
10a322: 42bd cmp r5, r7
10a324: d016 beq.n 10a354 <_Thread_Allocate_unlimited+0x40>
10a326: 68a8 ldr r0, [r5, #8]
Objects_Maximum objects_per_block;
Objects_Maximum block;
_Assert( _Objects_Is_auto_extend( information ) );
objects_per_block = information->objects_per_block;
10a328: 8a61 ldrh r1, [r4, #18]
new_first = old_first->next;
10a32a: 682b ldr r3, [r5, #0]
block = _Objects_Get_index( the_object->id ) - OBJECTS_INDEX_MINIMUM;
10a32c: 3801 subs r0, #1
10a32e: b280 uxth r0, r0
head->next = new_first;
10a330: 61a3 str r3, [r4, #24]
if ( block > objects_per_block ) {
10a332: 4281 cmp r1, r0
new_first->previous = head;
10a334: 605e str r6, [r3, #4]
10a336: d20b bcs.n 10a350 <_Thread_Allocate_unlimited+0x3c>
block /= objects_per_block;
10a338: f009 feaa bl 114090 <__udivsi3>
information->inactive_per_block[ block ]--;
10a33c: 6a62 ldr r2, [r4, #36] ; 0x24
10a33e: b280 uxth r0, r0
10a340: f832 3010 ldrh.w r3, [r2, r0, lsl #1]
10a344: 3b01 subs r3, #1
10a346: f822 3010 strh.w r3, [r2, r0, lsl #1]
information->inactive--;
10a34a: 8a23 ldrh r3, [r4, #16]
10a34c: 3b01 subs r3, #1
10a34e: 8223 strh r3, [r4, #16]
return _Objects_Allocate_with_extend(
information,
_Thread_Extend_information
);
}
10a350: 4628 mov r0, r5
10a352: bdf8 pop {r3, r4, r5, r6, r7, pc}
block = _Objects_Extend_information( &information->Objects );
10a354: f7ff fbe6 bl 109b24 <_Objects_Extend_information>
if ( block > 0 ) {
10a358: 4605 mov r5, r0
10a35a: b928 cbnz r0, 10a368 <_Thread_Allocate_unlimited+0x54>
return _Chain_Immutable_head( the_chain )->next;
10a35c: 69a5 ldr r5, [r4, #24]
if ( !_Chain_Is_empty(the_chain))
10a35e: 42af cmp r7, r5
return NULL;
10a360: bf08 it eq
10a362: 2500 moveq r5, #0
if ( !_Chain_Is_empty(the_chain))
10a364: d1df bne.n 10a326 <_Thread_Allocate_unlimited+0x12> <== NEVER TAKEN
10a366: e7f3 b.n 10a350 <_Thread_Allocate_unlimited+0x3c> <== NOT EXECUTED
new_heads = _Freechain_Extend(
10a368: f64b 1119 movw r1, #47385 ; 0xb919
10a36c: 8a62 ldrh r2, [r4, #18]
10a36e: 2348 movs r3, #72 ; 0x48
10a370: f2c0 0110 movt r1, #16
10a374: f104 0030 add.w r0, r4, #48 ; 0x30
10a378: f005 fb8e bl 10fa98 <_Freechain_Extend>
if ( new_heads == NULL ) {
10a37c: 2800 cmp r0, #0
10a37e: d1ed bne.n 10a35c <_Thread_Allocate_unlimited+0x48> <== NEVER TAKEN
_Objects_Free_objects_block( &information->Objects, block );
10a380: 4629 mov r1, r5 <== NOT EXECUTED
10a382: 4620 mov r0, r4 <== NOT EXECUTED
10a384: f7ff fce0 bl 109d48 <_Objects_Free_objects_block> <== NOT EXECUTED
10a388: e7e8 b.n 10a35c <_Thread_Allocate_unlimited+0x48> <== NOT EXECUTED
10a38a: bf00 nop
0010b310 <_Thread_Cancel>:
void _Thread_Cancel(
Thread_Control *the_thread,
Thread_Control *executing,
void *exit_value
)
{
10b310: b5f8 push {r3, r4, r5, r6, r7, lr}
10b312: 4604 mov r4, r0
__asm__ volatile (
10b314: f3ef 8500 mrs r5, CPSR
10b318: f045 0380 orr.w r3, r5, #128 ; 0x80
10b31c: f383 8900 msr CPSR_fc, r3
previous = the_thread->Life.state;
10b320: f8d0 3174 ldr.w r3, [r0, #372] ; 0x174
the_thread->Life.exit_value = exit_value;
10b324: f8c0 217c str.w r2, [r0, #380] ; 0x17c
if (
10b328: f013 0f09 tst.w r3, #9
state |= set;
10b32c: f043 0204 orr.w r2, r3, #4
the_thread->Life.state = state;
10b330: f8c0 2174 str.w r2, [r0, #372] ; 0x174
if (
10b334: d13c bne.n 10b3b0 <_Thread_Cancel+0xa0>
the_thread->is_preemptible = the_thread->Start.is_preemptible;
10b336: f890 20ac ldrb.w r2, [r0, #172] ; 0xac
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
10b33a: f8d0 30b0 ldr.w r3, [r0, #176] ; 0xb0
the_thread->is_preemptible = the_thread->Start.is_preemptible;
10b33e: f880 2089 strb.w r2, [r0, #137] ; 0x89
the_thread->budget_callout = the_thread->Start.budget_callout;
10b342: f8d0 20b4 ldr.w r2, [r0, #180] ; 0xb4
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
10b346: f8c0 3090 str.w r3, [r0, #144] ; 0x90
action->handler = handler;
10b34a: f24b 1359 movw r3, #45401 ; 0xb159
10b34e: f2c0 0310 movt r3, #16
the_thread->budget_callout = the_thread->Start.budget_callout;
10b352: f8c0 2094 str.w r2, [r0, #148] ; 0x94
if ( _Chain_Is_node_off_chain( the_node ) ) {
10b356: f8d0 2168 ldr.w r2, [r0, #360] ; 0x168
10b35a: f8c0 3170 str.w r3, [r0, #368] ; 0x170
cpu_self->dispatch_necessary = true;
10b35e: f242 7380 movw r3, #10112 ; 0x2780
10b362: f2c0 0320 movt r3, #32
10b366: 2001 movs r0, #1
10b368: 7518 strb r0, [r3, #20]
10b36a: 2a00 cmp r2, #0
10b36c: d065 beq.n 10b43a <_Thread_Cancel+0x12a>
disable_level = cpu_self->thread_dispatch_disable_level;
10b36e: 691a ldr r2, [r3, #16]
return aggregation->Node.priority;
10b370: 6b89 ldr r1, [r1, #56] ; 0x38
cpu_self->thread_dispatch_disable_level = disable_level + 1;
10b372: 3201 adds r2, #1
10b374: 611a str r2, [r3, #16]
);
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
priority = _Thread_Get_priority( executing );
if ( _States_Is_dormant( the_thread->current_state ) ) {
10b376: 69e3 ldr r3, [r4, #28]
10b378: e9d1 6706 ldrd r6, r7, [r1, #24]
10b37c: 2b00 cmp r3, #0
10b37e: db4f blt.n 10b420 <_Thread_Cancel+0x110>
pending_requests = the_thread->Life.pending_life_change_requests;
10b380: f8d4 3178 ldr.w r3, [r4, #376] ; 0x178
the_thread->Life.pending_life_change_requests = pending_requests + 1;
10b384: 1c5a adds r2, r3, #1
10b386: f8c4 2178 str.w r2, [r4, #376] ; 0x178
if ( pending_requests == 0 ) {
10b38a: 2b00 cmp r3, #0
10b38c: d06b beq.n 10b466 <_Thread_Cancel+0x156> <== NEVER TAKEN
__asm__ volatile (
10b38e: f385 8900 msr CPSR_fc, r5
_Thread_queue_Extract_with_proxy( the_thread );
10b392: 4620 mov r0, r4
10b394: f003 ff74 bl 10f280 <_Thread_queue_Extract_with_proxy>
__asm__ volatile (
10b398: f3ef 8500 mrs r5, CPSR
10b39c: f045 0380 orr.w r3, r5, #128 ; 0x80
10b3a0: f383 8900 msr CPSR_fc, r3
10b3a4: 6e20 ldr r0, [r4, #96] ; 0x60
10b3a6: f104 0168 add.w r1, r4, #104 ; 0x68
10b3aa: f000 facf bl 10b94c <_Watchdog_Remove>
_ISR_lock_Release_and_ISR_enable( &the_thread->Timer.Lock, &lock_context );
10b3ae: e018 b.n 10b3e2 <_Thread_Cancel+0xd2>
disable_level = cpu_self->thread_dispatch_disable_level;
10b3b0: f242 7380 movw r3, #10112 ; 0x2780
10b3b4: f2c0 0320 movt r3, #32
10b3b8: 691a ldr r2, [r3, #16]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
10b3ba: 3201 adds r2, #1
10b3bc: 611a str r2, [r3, #16]
if ( _States_Is_dormant( the_thread->current_state ) ) {
10b3be: 69c3 ldr r3, [r0, #28]
10b3c0: 2b00 cmp r3, #0
10b3c2: db2d blt.n 10b420 <_Thread_Cancel+0x110> <== ALWAYS TAKEN
10b3c4: 6b8b ldr r3, [r1, #56] ; 0x38
10b3c6: e9d3 6706 ldrd r6, r7, [r3, #24]
pending_requests = the_thread->Life.pending_life_change_requests;
10b3ca: f8d4 3178 ldr.w r3, [r4, #376] ; 0x178
the_thread->Life.pending_life_change_requests = pending_requests + 1;
10b3ce: 1c5a adds r2, r3, #1
10b3d0: f8c4 2178 str.w r2, [r4, #376] ; 0x178
if ( pending_requests == 0 ) {
10b3d4: 2b00 cmp r3, #0
10b3d6: d04c beq.n 10b472 <_Thread_Cancel+0x162> <== NEVER TAKEN
_Thread_State_release( the_thread, &lock_context );
_Thread_Finalize_life_change( the_thread, priority );
} else {
_Thread_Add_life_change_request( the_thread );
_Thread_Clear_state_locked( the_thread, STATES_SUSPENDED );
10b3d8: f44f 4100 mov.w r1, #32768 ; 0x8000
10b3dc: 4620 mov r0, r4
10b3de: f003 fdb5 bl 10ef4c <_Thread_Clear_state_locked>
__asm__ volatile (
10b3e2: f385 8900 msr CPSR_fc, r5
_Thread_State_release( the_thread, &lock_context );
_Thread_Raise_real_priority( the_thread, priority );
10b3e6: 4632 mov r2, r6
10b3e8: 463b mov r3, r7
10b3ea: 4620 mov r0, r4
10b3ec: f7ff fe0a bl 10b004 <_Thread_Raise_real_priority>
__asm__ volatile (
10b3f0: f3ef 8500 mrs r5, CPSR
10b3f4: f045 0380 orr.w r3, r5, #128 ; 0x80
10b3f8: f383 8900 msr CPSR_fc, r3
pending_requests = the_thread->Life.pending_life_change_requests;
10b3fc: f8d4 3178 ldr.w r3, [r4, #376] ; 0x178
if ( pending_requests == 1 ) {
10b400: 2b01 cmp r3, #1
the_thread->Life.pending_life_change_requests = pending_requests - 1;
10b402: f103 32ff add.w r2, r3, #4294967295 ; 0xffffffff
10b406: f8c4 2178 str.w r2, [r4, #376] ; 0x178
if ( pending_requests == 1 ) {
10b40a: d024 beq.n 10b456 <_Thread_Cancel+0x146> <== NEVER TAKEN
__asm__ volatile (
10b40c: f385 8900 msr CPSR_fc, r5
_Thread_Remove_life_change_request( the_thread );
}
_Thread_Dispatch_enable( cpu_self );
10b410: f242 7080 movw r0, #10112 ; 0x2780
}
10b414: e8bd 40f8 ldmia.w sp!, {r3, r4, r5, r6, r7, lr}
_Thread_Dispatch_enable( cpu_self );
10b418: f2c0 0020 movt r0, #32
10b41c: f7ff b96c b.w 10a6f8 <_Thread_Dispatch_enable>
10b420: f385 8900 msr CPSR_fc, r5
_Thread_Make_zombie( the_thread );
10b424: 4620 mov r0, r4
10b426: f7ff fe4d bl 10b0c4 <_Thread_Make_zombie>
_Thread_Dispatch_enable( cpu_self );
10b42a: f242 7080 movw r0, #10112 ; 0x2780
}
10b42e: e8bd 40f8 ldmia.w sp!, {r3, r4, r5, r6, r7, lr}
_Thread_Dispatch_enable( cpu_self );
10b432: f2c0 0020 movt r0, #32
10b436: f7ff b95f b.w 10a6f8 <_Thread_Dispatch_enable>
old_last = tail->previous;
10b43a: f8d4 00e0 ldr.w r0, [r4, #224] ; 0xe0
_Chain_Append_if_is_off_chain_unprotected(
10b43e: f504 72b4 add.w r2, r4, #360 ; 0x168
return &the_chain->Tail.Node;
10b442: f104 06dc add.w r6, r4, #220 ; 0xdc
tail->previous = the_node;
10b446: f8c4 20e0 str.w r2, [r4, #224] ; 0xe0
the_node->next = tail;
10b44a: f8c4 6168 str.w r6, [r4, #360] ; 0x168
old_last->next = the_node;
10b44e: 6002 str r2, [r0, #0]
the_node->previous = old_last;
10b450: f8c4 016c str.w r0, [r4, #364] ; 0x16c
}
10b454: e78b b.n 10b36e <_Thread_Cancel+0x5e>
_Thread_Clear_state_locked(
10b456: f248 310c movw r1, #33548 ; 0x830c
10b45a: 4620 mov r0, r4
10b45c: f2c3 0102 movt r1, #12290 ; 0x3002
10b460: f003 fd74 bl 10ef4c <_Thread_Clear_state_locked>
10b464: e7d2 b.n 10b40c <_Thread_Cancel+0xfc>
_Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING );
10b466: f44f 3100 mov.w r1, #131072 ; 0x20000
10b46a: 4620 mov r0, r4
10b46c: f000 f8b4 bl 10b5d8 <_Thread_Set_state_locked>
10b470: e78d b.n 10b38e <_Thread_Cancel+0x7e>
10b472: f44f 3100 mov.w r1, #131072 ; 0x20000
10b476: f000 f8af bl 10b5d8 <_Thread_Set_state_locked>
10b47a: e7ad b.n 10b3d8 <_Thread_Cancel+0xc8>
0010a6f8 <_Thread_Dispatch_enable>:
void _Thread_Dispatch_enable( Per_CPU_Control *cpu_self )
{
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
10a6f8: 6903 ldr r3, [r0, #16]
if ( disable_level == 1 ) {
10a6fa: 2b01 cmp r3, #1
10a6fc: d002 beq.n 10a704 <_Thread_Dispatch_enable+0xc>
_Profiling_Thread_dispatch_enable( cpu_self, 0 );
_ISR_Local_enable( level );
}
} else {
_Assert( disable_level > 0 );
cpu_self->thread_dispatch_disable_level = disable_level - 1;
10a6fe: 3b01 subs r3, #1
10a700: 6103 str r3, [r0, #16]
}
}
10a702: 4770 bx lr
10a704: f3ef 8100 mrs r1, CPSR
10a708: f041 0380 orr.w r3, r1, #128 ; 0x80
10a70c: f383 8900 msr CPSR_fc, r3
cpu_self->dispatch_necessary
10a710: 7d03 ldrb r3, [r0, #20]
if (
10a712: b913 cbnz r3, 10a71a <_Thread_Dispatch_enable+0x22>
|| !_ISR_Is_enabled( level )
10a714: f011 0380 ands.w r3, r1, #128 ; 0x80
10a718: d001 beq.n 10a71e <_Thread_Dispatch_enable+0x26> <== NEVER TAKEN
_Thread_Do_dispatch( cpu_self, level );
10a71a: f7ff bf69 b.w 10a5f0 <_Thread_Do_dispatch>
cpu_self->thread_dispatch_disable_level = 0;
10a71e: 6103 str r3, [r0, #16]
__asm__ volatile (
10a720: f381 8900 msr CPSR_fc, r1
"msr basepri, %[level]\n"
:
: [level] "r" (level)
);
#endif
}
10a724: 4770 bx lr
10a726: bf00 nop
0010a5f0 <_Thread_Do_dispatch>:
_Thread_State_release( executing, &lock_context );
}
void _Thread_Do_dispatch( Per_CPU_Control *cpu_self, ISR_Level level )
{
10a5f0: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
Thread_Control *executing;
_Assert( cpu_self->thread_dispatch_disable_level == 1 );
#if defined(RTEMS_SCORE_ROBUST_THREAD_DISPATCH)
if (
10a5f4: f011 0880 ands.w r8, r1, #128 ; 0x80
{
10a5f8: b083 sub sp, #12
if (
10a5fa: d167 bne.n 10a6cc <_Thread_Do_dispatch+0xdc> <== ALWAYS TAKEN
return _Chain_Immutable_head( the_chain )->next;
10a5fc: f240 27d4 movw r7, #724 ; 0x2d4
) {
_Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT );
}
#endif
executing = cpu_self->executing;
10a600: f8d0 a018 ldr.w sl, [r0, #24]
/*
* Since heir and executing are not the same, we need to do a real
* context switch.
*/
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
heir->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice();
10a604: f248 19d8 movw r9, #33240 ; 0x81d8
10a608: f2c0 0720 movt r7, #32
* stack or non-volatile registers reflect the old execution environment.
*/
cpu_self = _Per_CPU_Get();
_ISR_Local_disable( level );
} while ( cpu_self->dispatch_necessary );
10a60c: f242 7680 movw r6, #10112 ; 0x2780
heir->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice();
10a610: f2c0 0911 movt r9, #17
} while ( cpu_self->dispatch_necessary );
10a614: f2c0 0620 movt r6, #32
if ( node != tail ) {
10a618: 1d3d adds r5, r7, #4
heir = cpu_self->heir;
10a61a: f8d0 b01c ldr.w fp, [r0, #28]
cpu_self->dispatch_necessary = false;
10a61e: f880 8014 strb.w r8, [r0, #20]
if ( heir == executing )
10a622: 45da cmp sl, fp
cpu_self->executing = heir;
10a624: f8c0 b018 str.w fp, [r0, #24]
10a628: d024 beq.n 10a674 <_Thread_Do_dispatch+0x84>
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
10a62a: f8db 3090 ldr.w r3, [fp, #144] ; 0x90
10a62e: 2b01 cmp r3, #1
heir->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice();
10a630: bf04 itt eq
10a632: f8d9 3000 ldreq.w r3, [r9]
10a636: f8cb 308c streq.w r3, [fp, #140] ; 0x8c
10a63a: f381 8900 msr CPSR_fc, r1
10a63e: 683c ldr r4, [r7, #0]
10a640: 42ac cmp r4, r5
10a642: d007 beq.n 10a654 <_Thread_Do_dispatch+0x64>
return the_node->next;
10a644: 4623 mov r3, r4
10a646: 6824 ldr r4, [r4, #0]
(*extension->thread_switch)( executing, heir );
10a648: 689b ldr r3, [r3, #8]
10a64a: 4659 mov r1, fp
10a64c: 4650 mov r0, sl
10a64e: 4798 blx r3
while ( node != tail ) {
10a650: 42ac cmp r4, r5
10a652: d1f7 bne.n 10a644 <_Thread_Do_dispatch+0x54>
_Context_Switch( &executing->Registers, &heir->Registers );
10a654: f10b 01e8 add.w r1, fp, #232 ; 0xe8
10a658: f10a 00e8 add.w r0, sl, #232 ; 0xe8
10a65c: f001 fb96 bl 10bd8c <_CPU_Context_switch>
__asm__ volatile (
10a660: f3ef 8100 mrs r1, CPSR
10a664: f041 0380 orr.w r3, r1, #128 ; 0x80
10a668: f383 8900 msr CPSR_fc, r3
} while ( cpu_self->dispatch_necessary );
10a66c: 7d33 ldrb r3, [r6, #20]
cpu_self = _Per_CPU_Get();
10a66e: 4630 mov r0, r6
} while ( cpu_self->dispatch_necessary );
10a670: 2b00 cmp r3, #0
10a672: d1d2 bne.n 10a61a <_Thread_Do_dispatch+0x2a>
post_switch:
_Assert( cpu_self->thread_dispatch_disable_level == 1 );
cpu_self->thread_dispatch_disable_level = 0;
10a674: 2400 movs r4, #0
10a676: 6104 str r4, [r0, #16]
__asm__ volatile (
10a678: f381 8900 msr CPSR_fc, r1
__asm__ volatile (
10a67c: f3ef 8300 mrs r3, CPSR
10a680: f043 0280 orr.w r2, r3, #128 ; 0x80
10a684: f382 8900 msr CPSR_fc, r2
_ISR_lock_ISR_disable( lock_context );
10a688: 9301 str r3, [sp, #4]
return _Chain_Immutable_head( the_chain )->next;
10a68a: 4655 mov r5, sl
return &the_chain->Tail.Node;
10a68c: f10a 06dc add.w r6, sl, #220 ; 0xdc
return _Chain_Immutable_head( the_chain )->next;
10a690: f855 1fd8 ldr.w r1, [r5, #216]!
if ( !_Chain_Is_empty(the_chain))
10a694: 42b1 cmp r1, r6
10a696: d013 beq.n 10a6c0 <_Thread_Do_dispatch+0xd0>
new_first = old_first->next;
10a698: 680b ldr r3, [r1, #0]
( *action->handler )( executing, action, &lock_context );
10a69a: aa01 add r2, sp, #4
10a69c: 4650 mov r0, sl
head->next = new_first;
10a69e: f8ca 30d8 str.w r3, [sl, #216] ; 0xd8
new_first->previous = head;
10a6a2: 605d str r5, [r3, #4]
10a6a4: 688b ldr r3, [r1, #8]
node->next = NULL;
10a6a6: 600c str r4, [r1, #0]
10a6a8: 4798 blx r3
10a6aa: f3ef 8300 mrs r3, CPSR
10a6ae: f043 0280 orr.w r2, r3, #128 ; 0x80
10a6b2: f382 8900 msr CPSR_fc, r2
10a6b6: 9301 str r3, [sp, #4]
return _Chain_Immutable_head( the_chain )->next;
10a6b8: f8da 10d8 ldr.w r1, [sl, #216] ; 0xd8
if ( !_Chain_Is_empty(the_chain))
10a6bc: 428e cmp r6, r1
10a6be: d1eb bne.n 10a698 <_Thread_Do_dispatch+0xa8> <== ALWAYS TAKEN
__asm__ volatile (
10a6c0: 9b01 ldr r3, [sp, #4]
10a6c2: f383 8900 msr CPSR_fc, r3
_Profiling_Thread_dispatch_enable( cpu_self, 0 );
_ISR_Local_enable( level );
_Thread_Run_post_switch_actions( executing );
}
10a6c6: b003 add sp, #12
10a6c8: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
_Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT );
10a6cc: 201f movs r0, #31 <== NOT EXECUTED
10a6ce: f7fe fd3b bl 109148 <_Internal_error> <== NOT EXECUTED
10a6d2: bf00 nop
0010b4b4 <_Thread_Exit>:
__asm__ volatile (
10b4b4: f3ef 8300 mrs r3, CPSR
10b4b8: f043 0c80 orr.w ip, r3, #128 ; 0x80
10b4bc: f38c 8900 msr CPSR_fc, ip
the_thread->Life.exit_value = exit_value;
10b4c0: f8c0 217c str.w r2, [r0, #380] ; 0x17c
state |= set;
10b4c4: f8d0 2174 ldr.w r2, [r0, #372] ; 0x174
10b4c8: 4311 orrs r1, r2
&& _Thread_Is_life_changing( state )
10b4ca: f011 0f06 tst.w r1, #6
the_thread->Life.state = state;
10b4ce: f8c0 1174 str.w r1, [r0, #372] ; 0x174
&& _Thread_Is_life_changing( state )
10b4d2: d022 beq.n 10b51a <_Thread_Exit+0x66> <== ALWAYS TAKEN
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
10b4d4: f8d0 20b0 ldr.w r2, [r0, #176] ; 0xb0
the_thread->is_preemptible = the_thread->Start.is_preemptible;
10b4d8: f890 c0ac ldrb.w ip, [r0, #172] ; 0xac
if ( _Chain_Is_node_off_chain( the_node ) ) {
10b4dc: f8d0 1168 ldr.w r1, [r0, #360] ; 0x168
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
10b4e0: f8c0 2090 str.w r2, [r0, #144] ; 0x90
action->handler = handler;
10b4e4: f24b 1259 movw r2, #45401 ; 0xb159
10b4e8: f2c0 0210 movt r2, #16
void _Thread_Exit(
Thread_Control *executing,
Thread_Life_state set,
void *exit_value
)
{
10b4ec: b410 push {r4}
the_thread->budget_callout = the_thread->Start.budget_callout;
10b4ee: f8d0 40b4 ldr.w r4, [r0, #180] ; 0xb4
10b4f2: f8c0 2170 str.w r2, [r0, #368] ; 0x170
cpu_self->dispatch_necessary = true;
10b4f6: f242 7280 movw r2, #10112 ; 0x2780
the_thread->is_preemptible = the_thread->Start.is_preemptible;
10b4fa: f880 c089 strb.w ip, [r0, #137] ; 0x89
10b4fe: f2c0 0220 movt r2, #32
10b502: f04f 0c01 mov.w ip, #1
the_thread->budget_callout = the_thread->Start.budget_callout;
10b506: f8c0 4094 str.w r4, [r0, #148] ; 0x94
10b50a: f882 c014 strb.w ip, [r2, #20]
10b50e: b139 cbz r1, 10b520 <_Thread_Exit+0x6c>
__asm__ volatile (
10b510: f383 8900 msr CPSR_fc, r3
0,
set,
THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED
);
_Thread_State_release( executing, &lock_context );
}
10b514: f85d 4b04 ldr.w r4, [sp], #4
10b518: 4770 bx lr
10b51a: f383 8900 msr CPSR_fc, r3 <== NOT EXECUTED
10b51e: 4770 bx lr <== NOT EXECUTED
old_last = tail->previous;
10b520: f8d0 20e0 ldr.w r2, [r0, #224] ; 0xe0
_Chain_Append_if_is_off_chain_unprotected(
10b524: f500 71b4 add.w r1, r0, #360 ; 0x168
return &the_chain->Tail.Node;
10b528: f100 04dc add.w r4, r0, #220 ; 0xdc
tail->previous = the_node;
10b52c: f8c0 10e0 str.w r1, [r0, #224] ; 0xe0
the_node->next = tail;
10b530: f8c0 4168 str.w r4, [r0, #360] ; 0x168
old_last->next = the_node;
10b534: 6011 str r1, [r2, #0]
the_node->previous = old_last;
10b536: f8c0 216c str.w r2, [r0, #364] ; 0x16c
}
10b53a: e7e9 b.n 10b510 <_Thread_Exit+0x5c>
0010f080 <_Thread_Initialize>:
Per_CPU_Control *cpu = _Per_CPU_Get_by_index( 0 );
memset(
&the_thread->Join_queue,
0,
information->Objects.object_size - offsetof( Thread_Control, Join_queue )
10f080: 8a83 ldrh r3, [r0, #20]
{
10f082: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
10f086: 460c mov r4, r1
10f088: b089 sub sp, #36 ; 0x24
10f08a: 4606 mov r6, r0
memset(
10f08c: 2100 movs r1, #0
{
10f08e: 4615 mov r5, r2
memset(
10f090: f104 0010 add.w r0, r4, #16
10f094: f1a3 0210 sub.w r2, r3, #16
10f098: f001 ff82 bl 110fa0 <memset>
);
for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) {
10f09c: f247 739c movw r3, #30620 ; 0x779c
10f0a0: f247 70a0 movw r0, #30624 ; 0x77a0
10f0a4: f2c0 0311 movt r3, #17
10f0a8: f2c0 0011 movt r0, #17
10f0ac: 681f ldr r7, [r3, #0]
10f0ae: f100 0c04 add.w ip, r0, #4
10f0b2: 2300 movs r3, #0
10f0b4: b147 cbz r7, 10f0c8 <_Thread_Initialize+0x48>
const Thread_Control_add_on *add_on = &_Thread_Control_add_ons[ i ];
*(void **) ( (char *) the_thread + add_on->destination_offset ) =
(char *) the_thread + add_on->source_offset;
10f0b6: f85c 2033 ldr.w r2, [ip, r3, lsl #3]
*(void **) ( (char *) the_thread + add_on->destination_offset ) =
10f0ba: f850 1033 ldr.w r1, [r0, r3, lsl #3]
for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) {
10f0be: 3301 adds r3, #1
10f0c0: 42bb cmp r3, r7
(char *) the_thread + add_on->source_offset;
10f0c2: 4422 add r2, r4
*(void **) ( (char *) the_thread + add_on->destination_offset ) =
10f0c4: 5062 str r2, [r4, r1]
for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) {
10f0c6: d1f6 bne.n 10f0b6 <_Thread_Initialize+0x36>
goto failed;
}
#endif
#if defined(RTEMS_SMP) || CPU_ENABLE_ROBUST_THREAD_DISPATCH == TRUE
if (
10f0c8: 6a6a ldr r2, [r5, #36] ; 0x24
the_thread->Start.stack_free = config->stack_free;
10f0ca: 68eb ldr r3, [r5, #12]
10f0cc: f8c4 30c8 str.w r3, [r4, #200] ; 0xc8
if (
10f0d0: b132 cbz r2, 10f0e0 <_Thread_Initialize+0x60>
#if defined(RTEMS_SMP) || CPU_ENABLE_ROBUST_THREAD_DISPATCH == TRUE
failed:
#endif
( *the_thread->Start.stack_free )( the_thread->Start.Initial_stack.area );
10f0d2: f8d4 00d0 ldr.w r0, [r4, #208] ; 0xd0
10f0d6: 4798 blx r3
return false;
10f0d8: 2000 movs r0, #0
}
10f0da: b009 add sp, #36 ; 0x24
10f0dc: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
stack_end = stack_begin + config->stack_size;
10f0e0: e9d5 8701 ldrd r8, r7, [r5, #4]
10f0e4: 4447 add r7, r8
tls_size = _TLS_Get_allocation_size();
10f0e6: f000 f967 bl 10f3b8 <_TLS_Get_allocation_size>
if ( tls_size > 0 ) {
10f0ea: b150 cbz r0, 10f102 <_Thread_Initialize+0x82>
tls_align = (uintptr_t) _TLS_Alignment;
10f0ec: f240 0301 movw r3, #1
stack_end -= tls_size;
10f0f0: 1a3f subs r7, r7, r0
tls_align = (uintptr_t) _TLS_Alignment;
10f0f2: f2c0 0300 movt r3, #0
( ( (uintptr_t) stack_end + tls_align - 1 ) & ~( tls_align - 1 ) );
10f0f6: 1e5a subs r2, r3, #1
10f0f8: 425b negs r3, r3
10f0fa: 443a add r2, r7
10f0fc: 4013 ands r3, r2
the_thread->Start.tls_area = (void *)
10f0fe: f8c4 30d4 str.w r3, [r4, #212] ; 0xd4
old_first = head->next;
10f102: 6b33 ldr r3, [r6, #48] ; 0x30
stack_end - stack_begin
10f104: eba7 0708 sub.w r7, r7, r8
the_stack->area = starting_address;
10f108: f8c4 80d0 str.w r8, [r4, #208] ; 0xd0
return &the_chain->Head.Node;
10f10c: f106 0830 add.w r8, r6, #48 ; 0x30
the_thread->is_fp = config->is_fp;
10f110: f895 e028 ldrb.w lr, [r5, #40] ; 0x28
new_first = old_first->next;
10f114: 681a ldr r2, [r3, #0]
return &the_chain->Tail.Node;
10f116: f103 0930 add.w r9, r3, #48 ; 0x30
the_thread->Start.isr_level = config->isr_level;
10f11a: f8d5 c024 ldr.w ip, [r5, #36] ; 0x24
the_stack->size = size;
10f11e: f8c4 70cc str.w r7, [r4, #204] ; 0xcc
the_thread->Start.is_preemptible = config->is_preemptible;
10f122: f895 7029 ldrb.w r7, [r5, #41] ; 0x29
head->next = new_first;
10f126: 6332 str r2, [r6, #48] ; 0x30
new_first->previous = head;
10f128: f8c2 8004 str.w r8, [r2, #4]
the_thread->Start.budget_callout = config->budget_callout;
10f12c: e9d5 2006 ldrd r2, r0, [r5, #24]
the_thread->Wait.spare_heads = _Freechain_Pop(
10f130: 65e3 str r3, [r4, #92] ; 0x5c
tail->previous = head;
10f132: f8c3 9038 str.w r9, [r3, #56] ; 0x38
return &the_chain->Tail.Node;
10f136: f103 0934 add.w r9, r3, #52 ; 0x34
head->next = tail;
10f13a: f8c3 9030 str.w r9, [r3, #48] ; 0x30
head->previous = NULL;
10f13e: f04f 0900 mov.w r9, #0
10f142: f8c3 9034 str.w r9, [r3, #52] ; 0x34
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
10f146: 2302 movs r3, #2
switch ( config->budget_algorithm ) {
10f148: 429a cmp r2, r3
10f14a: 6763 str r3, [r4, #116] ; 0x74
the_thread->cpu_time_budget =
10f14c: bf08 it eq
10f14e: f248 13d8 movweq r3, #33240 ; 0x81d8
( *scheduler->Operations.node_initialize )(
10f152: e9d5 ab04 ldrd sl, fp, [r5, #16]
10f156: bf08 it eq
10f158: f2c0 0311 movteq r3, #17
the_thread->Start.budget_callout = config->budget_callout;
10f15c: f8c4 00b4 str.w r0, [r4, #180] ; 0xb4
the_thread->cpu_time_budget =
10f160: bf08 it eq
10f162: 681b ldreq r3, [r3, #0]
_RBTree_Initialize_one( &aggregation->Contributors, &node->Node.RBTree );
10f164: f104 0920 add.w r9, r4, #32
config->scheduler,
10f168: 6828 ldr r0, [r5, #0]
timer->header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ];
10f16a: 4934 ldr r1, [pc, #208] ; (10f23c <_Thread_Initialize+0x1bc>)
the_thread->cpu_time_budget =
10f16c: bf08 it eq
10f16e: f8c4 308c streq.w r3, [r4, #140] ; 0x8c
return the_thread->Scheduler.nodes;
10f172: 6ba3 ldr r3, [r4, #56] ; 0x38
the_thread->is_fp = config->is_fp;
10f174: f884 e08a strb.w lr, [r4, #138] ; 0x8a
the_thread->Start.isr_level = config->isr_level;
10f178: f8c4 c0b8 str.w ip, [r4, #184] ; 0xb8
the_thread->Start.is_preemptible = config->is_preemptible;
10f17c: f884 70ac strb.w r7, [r4, #172] ; 0xac
timer->header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ];
10f180: 6621 str r1, [r4, #96] ; 0x60
10f182: 4619 mov r1, r3
the_thread->Start.budget_algorithm = config->budget_algorithm;
10f184: f8c4 20b0 str.w r2, [r4, #176] ; 0xb0
10f188: 4622 mov r2, r4
10f18a: e9cd ab00 strd sl, fp, [sp]
return &the_chain->Tail.Node;
10f18e: f104 0bd8 add.w fp, r4, #216 ; 0xd8
return the_thread->Scheduler.nodes;
10f192: 9303 str r3, [sp, #12]
User_extensions_Thread_create_context ctx = { created, true };
10f194: f04f 0a01 mov.w sl, #1
10f198: 6a43 ldr r3, [r0, #36] ; 0x24
10f19a: 4798 blx r3
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
10f19c: 8923 ldrh r3, [r4, #8]
the_thread->Wait.operations = &_Thread_queue_Operations_default;
10f19e: f248 1e9c movw lr, #33180 ; 0x819c
10f1a2: 6a2a ldr r2, [r5, #32]
10f1a4: f2c0 0e11 movt lr, #17
_Priority_Node_initialize( &the_thread->Real_priority, config->priority );
10f1a8: edd5 0b04 vldr d16, [r5, #16]
10f1ac: f104 0cdc add.w ip, r4, #220 ; 0xdc
10f1b0: f103 4380 add.w r3, r3, #1073741824 ; 0x40000000
10f1b4: 6871 ldr r1, [r6, #4]
10f1b6: 3b01 subs r3, #1
10f1b8: 9204 str r2, [sp, #16]
10f1ba: 9305 str r3, [sp, #20]
RB_PARENT( the_node, Node ) = NULL;
10f1bc: 2200 movs r2, #0
RB_ROOT( the_rbtree ) = the_node;
10f1be: 9b03 ldr r3, [sp, #12]
10f1c0: 460f mov r7, r1
node->priority = priority;
10f1c2: edc4 0b0c vstr d16, [r4, #48] ; 0x30
_User_extensions_Iterate(
10f1c6: f24b 719d movw r1, #47005 ; 0xb79d
10f1ca: a806 add r0, sp, #24
10f1cc: f2c0 0110 movt r1, #16
10f1d0: f8c3 9020 str.w r9, [r3, #32]
the_thread->current_state = STATES_DORMANT;
10f1d4: f04f 4900 mov.w r9, #2147483648 ; 0x80000000
10f1d8: edc3 0b06 vstr d16, [r3, #24]
the_object->name = name;
10f1dc: 9b04 ldr r3, [sp, #16]
the_thread->Start.initial_priority = config->priority;
10f1de: edc4 0b30 vstr d16, [r4, #192] ; 0xc0
the_thread->current_state = STATES_DORMANT;
10f1e2: f8c4 901c str.w r9, [r4, #28]
10f1e6: 60e3 str r3, [r4, #12]
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
10f1e8: 463b mov r3, r7
10f1ea: 9f05 ldr r7, [sp, #20]
the_thread->Wait.operations = &_Thread_queue_Operations_default;
10f1ec: f8c4 e058 str.w lr, [r4, #88] ; 0x58
head->next = tail;
10f1f0: f8c4 c0d8 str.w ip, [r4, #216] ; 0xd8
tail->previous = head;
10f1f4: f8c4 b0e0 str.w fp, [r4, #224] ; 0xe0
RB_PARENT( the_node, Node ) = NULL;
10f1f8: 62a2 str r2, [r4, #40] ; 0x28
RB_RIGHT( the_node, Node ) = NULL;
10f1fa: e9c4 2208 strd r2, r2, [r4, #32]
RB_COLOR( the_node, Node ) = RB_BLACK;
10f1fe: 62e2 str r2, [r4, #44] ; 0x2c
RB_INIT( the_rbtree );
10f200: f8c4 2164 str.w r2, [r4, #356] ; 0x164
head->previous = NULL;
10f204: f8c4 20dc str.w r2, [r4, #220] ; 0xdc
10f208: f843 4027 str.w r4, [r3, r7, lsl #2]
User_extensions_Thread_create_context ctx = { created, true };
10f20c: f88d a01c strb.w sl, [sp, #28]
10f210: 9406 str r4, [sp, #24]
_User_extensions_Iterate(
10f212: f7fc faef bl 10b7f4 <_User_extensions_Iterate>
return ctx.ok;
10f216: f89d 001c ldrb.w r0, [sp, #28]
if ( extension_status )
10f21a: 2800 cmp r0, #0
10f21c: f47f af5d bne.w 10f0da <_Thread_Initialize+0x5a>
_Scheduler_Node_destroy( config->scheduler, scheduler_node );
10f220: 6828 ldr r0, [r5, #0]
( *scheduler->Operations.node_destroy )( scheduler, node );
10f222: 9903 ldr r1, [sp, #12]
10f224: 6a83 ldr r3, [r0, #40] ; 0x28
10f226: 4798 blx r3
the_thread->Wait.spare_heads
10f228: 6de2 ldr r2, [r4, #92] ; 0x5c
before_node = after_node->next;
10f22a: 6b31 ldr r1, [r6, #48] ; 0x30
( *the_thread->Start.stack_free )( the_thread->Start.Initial_stack.area );
10f22c: f8d4 30c8 ldr.w r3, [r4, #200] ; 0xc8
the_node->previous = after_node;
10f230: f8c2 8004 str.w r8, [r2, #4]
after_node->next = the_node;
10f234: 6332 str r2, [r6, #48] ; 0x30
the_node->next = before_node;
10f236: 6011 str r1, [r2, #0]
before_node->previous = the_node;
10f238: 604a str r2, [r1, #4]
void *node
)
{
_Chain_Initialize_node( node );
_Chain_Prepend_unprotected( &freechain->Free, node );
}
10f23a: e74a b.n 10f0d2 <_Thread_Initialize+0x52>
10f23c: 002027b0 .word 0x002027b0
0010a678 <_Thread_Iterate>:
void _Thread_Iterate(
Thread_Visitor visitor,
void *arg
)
{
10a678: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
10a67c: 4607 mov r7, r0
10a67e: f8df 8034 ldr.w r8, [pc, #52] ; 10a6b4 <_Thread_Iterate+0x3c>
10a682: 468a mov sl, r1
10a684: f108 090c add.w r9, r8, #12
const Objects_Information *information;
Objects_Maximum maximum;
Objects_Maximum index;
_Assert( _Objects_Information_table[ api_index ] != NULL );
information = _Objects_Information_table[ api_index ][ 1 ];
10a688: f858 3b04 ldr.w r3, [r8], #4
10a68c: 685e ldr r6, [r3, #4]
if ( information == NULL ) {
10a68e: b16e cbz r6, 10a6ac <_Thread_Iterate+0x34>
return _Objects_Get_index( information->maximum_id );
10a690: 6835 ldr r5, [r6, #0]
continue;
}
maximum = _Objects_Get_maximum_index( information );
for ( index = 0 ; index < maximum ; ++index ) {
10a692: b2ab uxth r3, r5
10a694: b153 cbz r3, 10a6ac <_Thread_Iterate+0x34>
10a696: 009d lsls r5, r3, #2
10a698: 2400 movs r4, #0
Thread_Control *the_thread;
the_thread = (Thread_Control *) information->local_table[ index ];
10a69a: 6873 ldr r3, [r6, #4]
if ( the_thread != NULL ) {
bool done;
done = (* visitor )( the_thread, arg );
10a69c: 4651 mov r1, sl
the_thread = (Thread_Control *) information->local_table[ index ];
10a69e: 5918 ldr r0, [r3, r4]
for ( index = 0 ; index < maximum ; ++index ) {
10a6a0: 3404 adds r4, #4
if ( the_thread != NULL ) {
10a6a2: b108 cbz r0, 10a6a8 <_Thread_Iterate+0x30>
done = (* visitor )( the_thread, arg );
10a6a4: 47b8 blx r7
if ( done ) {
10a6a6: b918 cbnz r0, 10a6b0 <_Thread_Iterate+0x38>
for ( index = 0 ; index < maximum ; ++index ) {
10a6a8: 42a5 cmp r5, r4
10a6aa: d1f6 bne.n 10a69a <_Thread_Iterate+0x22>
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; ++api_index ) {
10a6ac: 45c1 cmp r9, r8
10a6ae: d1eb bne.n 10a688 <_Thread_Iterate+0x10>
return;
}
}
}
}
}
10a6b0: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
10a6b4: 00115784 .word 0x00115784
0010b24c <_Thread_Kill_zombies>:
{
10b24c: e92d 43f8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
__asm__ volatile (
10b250: f3ef 8300 mrs r3, CPSR
10b254: f043 0280 orr.w r2, r3, #128 ; 0x80
10b258: f382 8900 msr CPSR_fc, r2
return _Chain_Immutable_head( the_chain )->next;
10b25c: f240 26e0 movw r6, #736 ; 0x2e0
10b260: f2c0 0620 movt r6, #32
10b264: 4637 mov r7, r6
10b266: f857 4b04 ldr.w r4, [r7], #4
if ( !_Chain_Is_empty(the_chain))
10b26a: 42bc cmp r4, r7
10b26c: d04b beq.n 10b306 <_Thread_Kill_zombies+0xba>
new_first = old_first->next;
10b26e: 6822 ldr r2, [r4, #0]
head->next = new_first;
10b270: f247 7948 movw r9, #30536 ; 0x7748
_User_extensions_Iterate(
10b274: f24b 78b5 movw r8, #47029 ; 0xb7b5
10b278: f2c0 0911 movt r9, #17
10b27c: f2c0 0810 movt r8, #16
10b280: 6032 str r2, [r6, #0]
new_first->previous = head;
10b282: 6056 str r6, [r2, #4]
__asm__ volatile (
10b284: f383 8900 msr CPSR_fc, r3
_Objects_Get_information_id( the_thread->Object.id );
10b288: 68a0 ldr r0, [r4, #8]
10b28a: f003 faef bl 10e86c <_Objects_Get_information_id>
10b28e: 2201 movs r2, #1
10b290: 4605 mov r5, r0
10b292: 4641 mov r1, r8
10b294: 4620 mov r0, r4
10b296: f000 faad bl 10b7f4 <_User_extensions_Iterate>
__asm__ volatile (
10b29a: f3ef 8000 mrs r0, CPSR
10b29e: f040 0380 orr.w r3, r0, #128 ; 0x80
10b2a2: f383 8900 msr CPSR_fc, r3
iter = the_thread->last_user_extensions_iterator;
10b2a6: f8d4 3190 ldr.w r3, [r4, #400] ; 0x190
while ( iter != NULL ) {
10b2aa: b133 cbz r3, 10b2ba <_Thread_Kill_zombies+0x6e>
previous = the_node->previous;
10b2ac: e9d3 1200 ldrd r1, r2, [r3]
iter = iter->previous;
10b2b0: 691b ldr r3, [r3, #16]
next->previous = previous;
10b2b2: 604a str r2, [r1, #4]
previous->next = next;
10b2b4: 6011 str r1, [r2, #0]
while ( iter != NULL ) {
10b2b6: 2b00 cmp r3, #0
10b2b8: d1f8 bne.n 10b2ac <_Thread_Kill_zombies+0x60> <== ALWAYS TAKEN
__asm__ volatile (
10b2ba: f380 8900 msr CPSR_fc, r0
( *scheduler->Operations.node_destroy )( scheduler, node );
10b2be: 6ba1 ldr r1, [r4, #56] ; 0x38
10b2c0: 4648 mov r0, r9
10b2c2: f8d9 3028 ldr.w r3, [r9, #40] ; 0x28
10b2c6: 4798 blx r3
the_thread->Wait.spare_heads
10b2c8: 6de3 ldr r3, [r4, #92] ; 0x5c
return &the_chain->Head.Node;
10b2ca: f105 0c30 add.w ip, r5, #48 ; 0x30
before_node = after_node->next;
10b2ce: 6b2a ldr r2, [r5, #48] ; 0x30
( *the_thread->Start.stack_free )( the_thread->Start.Initial_stack.area );
10b2d0: f8d4 00d0 ldr.w r0, [r4, #208] ; 0xd0
10b2d4: f8d4 10c8 ldr.w r1, [r4, #200] ; 0xc8
the_node->previous = after_node;
10b2d8: f8c3 c004 str.w ip, [r3, #4]
after_node->next = the_node;
10b2dc: 632b str r3, [r5, #48] ; 0x30
the_node->next = before_node;
10b2de: 601a str r2, [r3, #0]
before_node->previous = the_node;
10b2e0: 6053 str r3, [r2, #4]
10b2e2: 4788 blx r1
Objects_Control *the_object
)
{
_Assert( _Objects_Allocator_is_owner() );
_Assert( information->deallocate != NULL );
( *information->deallocate )( information, the_object );
10b2e4: 68eb ldr r3, [r5, #12]
10b2e6: 4621 mov r1, r4
10b2e8: 4628 mov r0, r5
10b2ea: 4798 blx r3
__asm__ volatile (
10b2ec: f3ef 8300 mrs r3, CPSR
10b2f0: f043 0280 orr.w r2, r3, #128 ; 0x80
10b2f4: f382 8900 msr CPSR_fc, r2
return _Chain_Immutable_head( the_chain )->next;
10b2f8: 6834 ldr r4, [r6, #0]
if ( !_Chain_Is_empty(the_chain))
10b2fa: 42bc cmp r4, r7
10b2fc: d003 beq.n 10b306 <_Thread_Kill_zombies+0xba>
new_first = old_first->next;
10b2fe: 6822 ldr r2, [r4, #0]
head->next = new_first;
10b300: 6032 str r2, [r6, #0]
new_first->previous = head;
10b302: 6056 str r6, [r2, #4]
while ( the_thread != NULL ) {
10b304: e7be b.n 10b284 <_Thread_Kill_zombies+0x38>
__asm__ volatile (
10b306: f383 8900 msr CPSR_fc, r3
}
10b30a: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
10b30e: bf00 nop
0010c1fc <_Thread_Priority_add>:
void _Thread_Priority_add(
Thread_Control *the_thread,
Priority_Node *priority_node,
Thread_queue_Context *queue_context
)
{
10c1fc: b570 push {r4, r5, r6, lr}
10c1fe: 4614 mov r4, r2
return the_thread->Scheduler.nodes;
10c200: 6b82 ldr r2, [r0, #56] ; 0x38
aggregation->Action.type = type;
10c202: 2300 movs r3, #0
10c204: b082 sub sp, #8
aggregation->Action.node = node;
10c206: 6251 str r1, [r2, #36] ; 0x24
_Priority_Actions_initialize_one(
10c208: 3208 adds r2, #8
aggregation->Action.type = type;
10c20a: 6213 str r3, [r2, #32]
actions->actions = aggregation;
10c20c: 6122 str r2, [r4, #16]
_Thread_Priority_do_perform_actions(
10c20e: e9d0 6215 ldrd r6, r2, [r0, #84] ; 0x54
10c212: 9400 str r4, [sp, #0]
10c214: 4631 mov r1, r6
10c216: f7ff ff31 bl 10c07c <_Thread_Priority_do_perform_actions>
if ( !_Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) {
10c21a: 6923 ldr r3, [r4, #16]
10c21c: b173 cbz r3, 10c23c <_Thread_Priority_add+0x40>
_Thread_Priority_perform_actions( queue->owner, queue_context );
10c21e: 6870 ldr r0, [r6, #4] <== NOT EXECUTED
return queue_context->Priority.update_count;
10c220: 6966 ldr r6, [r4, #20] <== NOT EXECUTED
10c222: e001 b.n 10c228 <_Thread_Priority_add+0x2c> <== NOT EXECUTED
the_thread = queue->owner;
10c224: 6868 ldr r0, [r5, #4] <== NOT EXECUTED
queue_context->Priority.update_count = update_count;
10c226: 6166 str r6, [r4, #20] <== NOT EXECUTED
_Thread_Priority_do_perform_actions(
10c228: e9d0 5215 ldrd r5, r2, [r0, #84] ; 0x54 <== NOT EXECUTED
10c22c: 2300 movs r3, #0 <== NOT EXECUTED
10c22e: 9400 str r4, [sp, #0] <== NOT EXECUTED
10c230: 4629 mov r1, r5 <== NOT EXECUTED
10c232: f7ff ff23 bl 10c07c <_Thread_Priority_do_perform_actions> <== NOT EXECUTED
if ( _Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) {
10c236: 6923 ldr r3, [r4, #16] <== NOT EXECUTED
10c238: 2b00 cmp r3, #0 <== NOT EXECUTED
10c23a: d1f3 bne.n 10c224 <_Thread_Priority_add+0x28> <== NOT EXECUTED
priority_node,
queue_context,
false,
PRIORITY_ACTION_ADD
);
}
10c23c: b002 add sp, #8
10c23e: bd70 pop {r4, r5, r6, pc}
0010c240 <_Thread_Priority_remove>:
void _Thread_Priority_remove(
Thread_Control *the_thread,
Priority_Node *priority_node,
Thread_queue_Context *queue_context
)
{
10c240: b570 push {r4, r5, r6, lr}
10c242: 4614 mov r4, r2
10c244: 6b82 ldr r2, [r0, #56] ; 0x38
10c246: b082 sub sp, #8
_Thread_Priority_do_perform_actions(
10c248: 2301 movs r3, #1
aggregation->Action.node = node;
10c24a: 6251 str r1, [r2, #36] ; 0x24
aggregation->Action.type = type;
10c24c: 2102 movs r1, #2
10c24e: 6291 str r1, [r2, #40] ; 0x28
_Priority_Actions_initialize_one(
10c250: 3208 adds r2, #8
actions->actions = aggregation;
10c252: 6122 str r2, [r4, #16]
_Thread_Priority_do_perform_actions(
10c254: e9d0 5215 ldrd r5, r2, [r0, #84] ; 0x54
10c258: 9400 str r4, [sp, #0]
10c25a: 4629 mov r1, r5
10c25c: f7ff ff0e bl 10c07c <_Thread_Priority_do_perform_actions>
if ( !_Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) {
10c260: 6923 ldr r3, [r4, #16]
10c262: b173 cbz r3, 10c282 <_Thread_Priority_remove+0x42>
_Thread_Priority_perform_actions( queue->owner, queue_context );
10c264: 6868 ldr r0, [r5, #4] <== NOT EXECUTED
return queue_context->Priority.update_count;
10c266: 6966 ldr r6, [r4, #20] <== NOT EXECUTED
10c268: e001 b.n 10c26e <_Thread_Priority_remove+0x2e> <== NOT EXECUTED
the_thread = queue->owner;
10c26a: 6868 ldr r0, [r5, #4] <== NOT EXECUTED
queue_context->Priority.update_count = update_count;
10c26c: 6166 str r6, [r4, #20] <== NOT EXECUTED
_Thread_Priority_do_perform_actions(
10c26e: e9d0 5215 ldrd r5, r2, [r0, #84] ; 0x54 <== NOT EXECUTED
10c272: 2300 movs r3, #0 <== NOT EXECUTED
10c274: 9400 str r4, [sp, #0] <== NOT EXECUTED
10c276: 4629 mov r1, r5 <== NOT EXECUTED
10c278: f7ff ff00 bl 10c07c <_Thread_Priority_do_perform_actions> <== NOT EXECUTED
if ( _Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) {
10c27c: 6923 ldr r3, [r4, #16] <== NOT EXECUTED
10c27e: 2b00 cmp r3, #0 <== NOT EXECUTED
10c280: d1f3 bne.n 10c26a <_Thread_Priority_remove+0x2a> <== NOT EXECUTED
priority_node,
queue_context,
true,
PRIORITY_ACTION_REMOVE
);
}
10c282: b002 add sp, #8
10c284: bd70 pop {r4, r5, r6, pc}
10c286: bf00 nop
00107a60 <_Thread_Restart_other>:
Thread_Life_state previous;
Per_CPU_Control *cpu_self;
_Thread_State_acquire_critical( the_thread, lock_context );
if ( _States_Is_dormant( the_thread->current_state ) ) {
107a60: 69c3 ldr r3, [r0, #28]
{
107a62: b530 push {r4, r5, lr}
107a64: 4615 mov r5, r2
107a66: b083 sub sp, #12
if ( _States_Is_dormant( the_thread->current_state ) ) {
107a68: 2b00 cmp r3, #0
107a6a: db79 blt.n 107b60 <_Thread_Restart_other+0x100>
_Thread_State_release( the_thread, lock_context );
return false;
}
the_thread->Start.Entry = *entry;
107a6c: 4604 mov r4, r0
107a6e: f100 03a0 add.w r3, r0, #160 ; 0xa0
107a72: c907 ldmia r1, {r0, r1, r2}
107a74: e883 0007 stmia.w r3, {r0, r1, r2}
previous = the_thread->Life.state;
107a78: f8d4 3174 ldr.w r3, [r4, #372] ; 0x174
if (
107a7c: f013 0f09 tst.w r3, #9
state |= set;
107a80: f043 0202 orr.w r2, r3, #2
the_thread->Life.state = state;
107a84: f8c4 2174 str.w r2, [r4, #372] ; 0x174
if (
107a88: d017 beq.n 107aba <_Thread_Restart_other+0x5a> <== NEVER TAKEN
disable_level = cpu_self->thread_dispatch_disable_level;
107a8a: f641 73c0 movw r3, #8128 ; 0x1fc0 <== NOT EXECUTED
_Thread_Finalize_life_change(
the_thread,
the_thread->Start.initial_priority
);
} else {
_Thread_Clear_state_locked( the_thread, STATES_SUSPENDED );
107a8e: f44f 4100 mov.w r1, #32768 ; 0x8000 <== NOT EXECUTED
107a92: f2c0 0320 movt r3, #32 <== NOT EXECUTED
107a96: 4620 mov r0, r4 <== NOT EXECUTED
107a98: 691a ldr r2, [r3, #16] <== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
107a9a: 3201 adds r2, #1 <== NOT EXECUTED
107a9c: 611a str r2, [r3, #16] <== NOT EXECUTED
107a9e: f002 f9c7 bl 109e30 <_Thread_Clear_state_locked> <== NOT EXECUTED
107aa2: 682b ldr r3, [r5, #0] <== NOT EXECUTED
107aa4: f383 8900 msr CPSR_fc, r3 <== NOT EXECUTED
_Thread_State_release( the_thread, lock_context );
}
_Thread_Dispatch_enable( cpu_self );
107aa8: f641 70c0 movw r0, #8128 ; 0x1fc0
107aac: f2c0 0020 movt r0, #32
107ab0: f7ff fcc0 bl 107434 <_Thread_Dispatch_enable>
return true;
107ab4: 2001 movs r0, #1
}
107ab6: b003 add sp, #12
107ab8: bd30 pop {r4, r5, pc}
the_thread->is_preemptible = the_thread->Start.is_preemptible;
107aba: f894 10ac ldrb.w r1, [r4, #172] ; 0xac
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
107abe: f8d4 30b0 ldr.w r3, [r4, #176] ; 0xb0
if ( _Chain_Is_node_off_chain( the_node ) ) {
107ac2: f8d4 2168 ldr.w r2, [r4, #360] ; 0x168
the_thread->is_preemptible = the_thread->Start.is_preemptible;
107ac6: f884 1089 strb.w r1, [r4, #137] ; 0x89
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
107aca: f8c4 3090 str.w r3, [r4, #144] ; 0x90
action->handler = handler;
107ace: f247 637d movw r3, #30333 ; 0x767d
the_thread->budget_callout = the_thread->Start.budget_callout;
107ad2: f8d4 10b4 ldr.w r1, [r4, #180] ; 0xb4
107ad6: f2c0 0310 movt r3, #16
107ada: f8c4 3170 str.w r3, [r4, #368] ; 0x170
cpu_self->dispatch_necessary = true;
107ade: f641 73c0 movw r3, #8128 ; 0x1fc0
107ae2: f2c0 0320 movt r3, #32
107ae6: f8c4 1094 str.w r1, [r4, #148] ; 0x94
107aea: 2101 movs r1, #1
107aec: 7519 strb r1, [r3, #20]
107aee: 2a00 cmp r2, #0
107af0: d04a beq.n 107b88 <_Thread_Restart_other+0x128> <== NEVER TAKEN
disable_level = cpu_self->thread_dispatch_disable_level;
107af2: 691a ldr r2, [r3, #16]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
107af4: 3201 adds r2, #1
107af6: 611a str r2, [r3, #16]
pending_requests = the_thread->Life.pending_life_change_requests;
107af8: f8d4 3178 ldr.w r3, [r4, #376] ; 0x178
the_thread->Life.pending_life_change_requests = pending_requests + 1;
107afc: 1c5a adds r2, r3, #1
107afe: f8c4 2178 str.w r2, [r4, #376] ; 0x178
if ( pending_requests == 0 ) {
107b02: 2b00 cmp r3, #0
107b04: d032 beq.n 107b6c <_Thread_Restart_other+0x10c> <== NEVER TAKEN
107b06: 682b ldr r3, [r5, #0]
107b08: f383 8900 msr CPSR_fc, r3
_Thread_Finalize_life_change(
107b0c: e9d4 2330 ldrd r2, r3, [r4, #192] ; 0xc0
_Thread_queue_Extract_with_proxy( the_thread );
107b10: 4620 mov r0, r4
_Thread_Finalize_life_change(
107b12: e9cd 2300 strd r2, r3, [sp]
_Thread_queue_Extract_with_proxy( the_thread );
107b16: f002 fc67 bl 10a3e8 <_Thread_queue_Extract_with_proxy>
__asm__ volatile (
107b1a: f3ef 8500 mrs r5, CPSR
107b1e: f045 0180 orr.w r1, r5, #128 ; 0x80
107b22: f381 8900 msr CPSR_fc, r1
107b26: 6e20 ldr r0, [r4, #96] ; 0x60
107b28: f104 0168 add.w r1, r4, #104 ; 0x68
107b2c: f000 fade bl 1080ec <_Watchdog_Remove>
__asm__ volatile (
107b30: f385 8900 msr CPSR_fc, r5
_Thread_Raise_real_priority( the_thread, priority );
107b34: e9dd 2300 ldrd r2, r3, [sp]
107b38: 4620 mov r0, r4
107b3a: f7ff fcf5 bl 107528 <_Thread_Raise_real_priority>
__asm__ volatile (
107b3e: f3ef 8500 mrs r5, CPSR
107b42: f045 0380 orr.w r3, r5, #128 ; 0x80
107b46: f383 8900 msr CPSR_fc, r3
pending_requests = the_thread->Life.pending_life_change_requests;
107b4a: f8d4 3178 ldr.w r3, [r4, #376] ; 0x178
if ( pending_requests == 1 ) {
107b4e: 2b01 cmp r3, #1
the_thread->Life.pending_life_change_requests = pending_requests - 1;
107b50: f103 32ff add.w r2, r3, #4294967295 ; 0xffffffff
107b54: f8c4 2178 str.w r2, [r4, #376] ; 0x178
if ( pending_requests == 1 ) {
107b58: d00e beq.n 107b78 <_Thread_Restart_other+0x118> <== NEVER TAKEN
__asm__ volatile (
107b5a: f385 8900 msr CPSR_fc, r5
}
107b5e: e7a3 b.n 107aa8 <_Thread_Restart_other+0x48>
107b60: 6813 ldr r3, [r2, #0]
107b62: f383 8900 msr CPSR_fc, r3
return false;
107b66: 2000 movs r0, #0
}
107b68: b003 add sp, #12
107b6a: bd30 pop {r4, r5, pc}
_Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING );
107b6c: f44f 3100 mov.w r1, #131072 ; 0x20000
107b70: 4620 mov r0, r4
107b72: f000 f89b bl 107cac <_Thread_Set_state_locked>
107b76: e7c6 b.n 107b06 <_Thread_Restart_other+0xa6>
_Thread_Clear_state_locked(
107b78: f248 310c movw r1, #33548 ; 0x830c
107b7c: 4620 mov r0, r4
107b7e: f2c3 0102 movt r1, #12290 ; 0x3002
107b82: f002 f955 bl 109e30 <_Thread_Clear_state_locked>
107b86: e7e8 b.n 107b5a <_Thread_Restart_other+0xfa>
old_last = tail->previous;
107b88: f8d4 20e0 ldr.w r2, [r4, #224] ; 0xe0
_Chain_Append_if_is_off_chain_unprotected(
107b8c: f504 71b4 add.w r1, r4, #360 ; 0x168
return &the_chain->Tail.Node;
107b90: f104 00dc add.w r0, r4, #220 ; 0xdc
tail->previous = the_node;
107b94: f8c4 10e0 str.w r1, [r4, #224] ; 0xe0
the_node->next = tail;
107b98: f8c4 0168 str.w r0, [r4, #360] ; 0x168
old_last->next = the_node;
107b9c: 6011 str r1, [r2, #0]
the_node->previous = old_last;
107b9e: f8c4 216c str.w r2, [r4, #364] ; 0x16c
}
107ba2: e7a6 b.n 107af2 <_Thread_Restart_other+0x92>
00109368 <_Thread_Wait_get_id>:
if ( _States_Is_waiting_for_rpc_reply( the_thread->current_state ) ) {
return the_thread->Wait.remote_id;
}
#endif
queue = the_thread->Wait.queue;
109368: 6d40 ldr r0, [r0, #84] ; 0x54
if ( queue != NULL && queue->name == _Thread_queue_Object_name ) {
10936a: b140 cbz r0, 10937e <_Thread_Wait_get_id+0x16>
10936c: 6882 ldr r2, [r0, #8]
10936e: f24e 63ac movw r3, #59052 ; 0xe6ac
109372: f2c0 0310 movt r3, #16
109376: 429a cmp r2, r3
queue_object = THREAD_QUEUE_QUEUE_TO_OBJECT( queue );
return queue_object->Object.id;
}
return 0;
109378: bf18 it ne
10937a: 2000 movne r0, #0
if ( queue != NULL && queue->name == _Thread_queue_Object_name ) {
10937c: d000 beq.n 109380 <_Thread_Wait_get_id+0x18> <== NEVER TAKEN
}
10937e: 4770 bx lr
return queue_object->Object.id;
109380: f850 0c08 ldr.w r0, [r0, #-8]
109384: 4770 bx lr
109386: bf00 nop
0010a83c <_Thread_queue_Enqueue>:
{
10a83c: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
10a840: 4607 mov r7, r0
10a842: 461e mov r6, r3
}
10a844: 4604 mov r4, r0
10a846: 4615 mov r5, r2
the_thread->Wait.queue = queue;
10a848: 6550 str r0, [r2, #84] ; 0x54
}
10a84a: e003 b.n 10a854 <_Thread_queue_Enqueue+0x18>
if ( owner == the_thread ) {
10a84c: 42a5 cmp r5, r4
10a84e: d05d beq.n 10a90c <_Thread_queue_Enqueue+0xd0>
queue = owner->Wait.queue;
10a850: 6d64 ldr r4, [r4, #84] ; 0x54
} while ( queue != NULL );
10a852: b114 cbz r4, 10a85a <_Thread_queue_Enqueue+0x1e>
owner = queue->owner;
10a854: 6864 ldr r4, [r4, #4]
if ( owner == NULL ) {
10a856: 2c00 cmp r4, #0
10a858: d1f8 bne.n 10a84c <_Thread_queue_Enqueue+0x10>
*/
RTEMS_INLINE_ROUTINE void _Thread_queue_Context_clear_priority_updates(
Thread_queue_Context *queue_context
)
{
queue_context->Priority.update_count = 0;
10a85a: f04f 0800 mov.w r8, #0
( *operations->enqueue )( queue, the_thread, queue_context );
10a85e: 684b ldr r3, [r1, #4]
10a860: 4632 mov r2, r6
10a862: f8c6 8014 str.w r8, [r6, #20]
10a866: 4638 mov r0, r7
the_thread->Wait.operations = operations;
10a868: 65a9 str r1, [r5, #88] ; 0x58
10a86a: 4629 mov r1, r5
the_thread->Wait.flags = flags;
10a86c: f240 4401 movw r4, #1025 ; 0x401
10a870: 4798 blx r3
disable_level = cpu_self->thread_dispatch_disable_level;
10a872: f242 7280 movw r2, #10112 ; 0x2780
10a876: e9c5 8413 strd r8, r4, [r5, #76] ; 0x4c
10a87a: f2c0 0220 movt r2, #32
10a87e: 6913 ldr r3, [r2, #16]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
10a880: 3301 adds r3, #1
10a882: 6113 str r3, [r2, #16]
10a884: 6833 ldr r3, [r6, #0]
10a886: f383 8900 msr CPSR_fc, r3
( *queue_context->enqueue_callout )(
10a88a: 4638 mov r0, r7
10a88c: 4633 mov r3, r6
10a88e: 4629 mov r1, r5
10a890: 68b7 ldr r7, [r6, #8]
10a892: 47b8 blx r7
_Thread_Set_state( the_thread, queue_context->thread_state );
10a894: 6871 ldr r1, [r6, #4]
10a896: 4628 mov r0, r5
10a898: f000 feae bl 10b5f8 <_Thread_Set_state>
__asm__ volatile (
10a89c: f3ef 8200 mrs r2, CPSR
10a8a0: f042 0380 orr.w r3, r2, #128 ; 0x80
10a8a4: f383 8900 msr CPSR_fc, r3
bool success = ( the_thread->Wait.flags == expected_flags );
10a8a8: 6d2b ldr r3, [r5, #80] ; 0x50
if ( success ) {
10a8aa: 42a3 cmp r3, r4
10a8ac: d010 beq.n 10a8d0 <_Thread_queue_Enqueue+0x94>
__asm__ volatile (
10a8ae: f382 8900 msr CPSR_fc, r2
if ( !success ) {
10a8b2: f240 4201 movw r2, #1025 ; 0x401
10a8b6: 4293 cmp r3, r2
10a8b8: d113 bne.n 10a8e2 <_Thread_queue_Enqueue+0xa6> <== NEVER TAKEN
_Thread_Priority_update( queue_context );
10a8ba: 4630 mov r0, r6
10a8bc: f004 fb26 bl 10ef0c <_Thread_Priority_update>
_Thread_Dispatch_direct( cpu_self );
10a8c0: f242 7080 movw r0, #10112 ; 0x2780
}
10a8c4: e8bd 41f0 ldmia.w sp!, {r4, r5, r6, r7, r8, lr}
_Thread_Dispatch_direct( cpu_self );
10a8c8: f2c0 0020 movt r0, #32
10a8cc: f7ff bf02 b.w 10a6d4 <_Thread_Dispatch_direct>
the_thread->Wait.flags = desired_flags;
10a8d0: f240 4102 movw r1, #1026 ; 0x402
10a8d4: 6529 str r1, [r5, #80] ; 0x50
10a8d6: f382 8900 msr CPSR_fc, r2
if ( !success ) {
10a8da: f240 4201 movw r2, #1025 ; 0x401
10a8de: 4293 cmp r3, r2
10a8e0: d0eb beq.n 10a8ba <_Thread_queue_Enqueue+0x7e> <== NEVER TAKEN
__asm__ volatile (
10a8e2: f3ef 8400 mrs r4, CPSR
10a8e6: f044 0380 orr.w r3, r4, #128 ; 0x80
10a8ea: f383 8900 msr CPSR_fc, r3
10a8ee: 6e28 ldr r0, [r5, #96] ; 0x60
10a8f0: f105 0168 add.w r1, r5, #104 ; 0x68
10a8f4: f001 f82a bl 10b94c <_Watchdog_Remove>
__asm__ volatile (
10a8f8: f384 8900 msr CPSR_fc, r4
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10a8fc: f645 71ff movw r1, #24575 ; 0x5fff
10a900: 4628 mov r0, r5
10a902: f2c3 0101 movt r1, #12289 ; 0x3001
10a906: f004 fb35 bl 10ef74 <_Thread_Clear_state>
}
#else
(void) queue;
_Thread_Unblock( the_thread );
#endif
}
10a90a: e7d6 b.n 10a8ba <_Thread_queue_Enqueue+0x7e>
the_thread->Wait.operations = &_Thread_queue_Operations_default;
10a90c: f248 139c movw r3, #33180 ; 0x819c
the_thread->Wait.queue = NULL;
10a910: 2200 movs r2, #0
the_thread->Wait.operations = &_Thread_queue_Operations_default;
10a912: f2c0 0311 movt r3, #17
10a916: e9c5 2315 strd r2, r3, [r5, #84] ; 0x54
10a91a: 6833 ldr r3, [r6, #0]
10a91c: f383 8900 msr CPSR_fc, r3
( *queue_context->deadlock_callout )( the_thread );
10a920: 6a33 ldr r3, [r6, #32]
10a922: 4628 mov r0, r5
}
10a924: e8bd 41f0 ldmia.w sp!, {r4, r5, r6, r7, r8, lr}
( *queue_context->deadlock_callout )( the_thread );
10a928: 4718 bx r3
10a92a: bf00 nop
0010a95c <_Thread_queue_Extract>:
&queue_context->Lock_context.Lock_context
);
}
void _Thread_queue_Extract( Thread_Control *the_thread )
{
10a95c: b530 push {r4, r5, lr}
10a95e: 2500 movs r5, #0
10a960: b08b sub sp, #44 ; 0x2c
10a962: 4604 mov r4, r0
10a964: 9506 str r5, [sp, #24]
__asm__ volatile (
10a966: f3ef 8300 mrs r3, CPSR
10a96a: f043 0280 orr.w r2, r3, #128 ; 0x80
10a96e: f382 8900 msr CPSR_fc, r2
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
10a972: 9301 str r3, [sp, #4]
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_clear_priority_updates( &queue_context );
_Thread_Wait_acquire( the_thread, &queue_context );
queue = the_thread->Wait.queue;
10a974: 6d40 ldr r0, [r0, #84] ; 0x54
if ( queue != NULL ) {
10a976: b300 cbz r0, 10a9ba <_Thread_queue_Extract+0x5e>
( *operations->extract )( queue, the_thread, queue_context );
10a978: 6da3 ldr r3, [r4, #88] ; 0x58
10a97a: aa01 add r2, sp, #4
10a97c: 4621 mov r1, r4
10a97e: 689b ldr r3, [r3, #8]
10a980: 4798 blx r3
if ( success ) {
10a982: 6d22 ldr r2, [r4, #80] ; 0x50
10a984: f240 4301 movw r3, #1025 ; 0x401
10a988: 429a cmp r2, r3
the_thread->Wait.operations = &_Thread_queue_Operations_default;
10a98a: f248 139c movw r3, #33180 ; 0x819c
the_thread->Wait.flags = desired_flags;
10a98e: f240 4204 movw r2, #1028 ; 0x404
the_thread->Wait.operations = &_Thread_queue_Operations_default;
10a992: f2c0 0311 movt r3, #17
if ( success ) {
10a996: d008 beq.n 10a9aa <_Thread_queue_Extract+0x4e> <== ALWAYS TAKEN
the_thread->Wait.flags = flags;
10a998: a901 add r1, sp, #4
10a99a: 4620 mov r0, r4
10a99c: 6522 str r2, [r4, #80] ; 0x50
the_thread->Wait.operations = &_Thread_queue_Operations_default;
10a99e: e9c4 5315 strd r5, r3, [r4, #84] ; 0x54
if ( unblock ) {
10a9a2: f7ff ff1f bl 10a7e4 <_Thread_queue_Unblock_critical.part.0>
&queue_context.Lock_context.Lock_context
);
} else {
_Thread_Wait_release( the_thread, &queue_context );
}
}
10a9a6: b00b add sp, #44 ; 0x2c
10a9a8: bd30 pop {r4, r5, pc}
the_thread->Wait.queue = NULL;
10a9aa: e9c4 2514 strd r2, r5, [r4, #80] ; 0x50 <== NOT EXECUTED
the_thread->Wait.operations = &_Thread_queue_Operations_default;
10a9ae: 65a3 str r3, [r4, #88] ; 0x58 <== NOT EXECUTED
__asm__ volatile (
10a9b0: 9b01 ldr r3, [sp, #4] <== NOT EXECUTED
10a9b2: f383 8900 msr CPSR_fc, r3 <== NOT EXECUTED
10a9b6: b00b add sp, #44 ; 0x2c <== NOT EXECUTED
10a9b8: bd30 pop {r4, r5, pc} <== NOT EXECUTED
10a9ba: 9b01 ldr r3, [sp, #4]
10a9bc: f383 8900 msr CPSR_fc, r3
10a9c0: b00b add sp, #44 ; 0x2c
10a9c2: bd30 pop {r4, r5, pc}
00114058 <_Thread_queue_Queue_get_name_and_id>:
const Thread_queue_Queue *queue,
char *buffer,
size_t buffer_size,
Objects_Id *id
)
{
114058: b530 push {r4, r5, lr} <== NOT EXECUTED
11405a: 4686 mov lr, r0 <== NOT EXECUTED
11405c: 4608 mov r0, r1 <== NOT EXECUTED
const char *name;
name = queue->name;
11405e: f8de 1008 ldr.w r1, [lr, #8] <== NOT EXECUTED
if ( name == _Thread_queue_Object_name ) {
114062: f241 1c78 movw ip, #4472 ; 0x1178 <== NOT EXECUTED
{
114066: 461c mov r4, r3 <== NOT EXECUTED
if ( name == _Thread_queue_Object_name ) {
114068: f2c0 0c16 movt ip, #22 <== NOT EXECUTED
11406c: 4561 cmp r1, ip <== NOT EXECUTED
11406e: d008 beq.n 114082 <_Thread_queue_Queue_get_name_and_id+0x2a> <== NOT EXECUTED
} else {
if ( name == NULL ) {
name = _Thread_queue_Object_name;
}
*id = 0;
114070: 2300 movs r3, #0 <== NOT EXECUTED
return strlcpy( buffer, name, buffer_size );
114072: 2900 cmp r1, #0 <== NOT EXECUTED
114074: bf08 it eq <== NOT EXECUTED
114076: 4661 moveq r1, ip <== NOT EXECUTED
*id = 0;
114078: 6023 str r3, [r4, #0] <== NOT EXECUTED
}
}
11407a: e8bd 4030 ldmia.w sp!, {r4, r5, lr} <== NOT EXECUTED
return strlcpy( buffer, name, buffer_size );
11407e: f029 bde5 b.w 13dc4c <strlcpy> <== NOT EXECUTED
*id = queue_object->Object.id;
114082: f85e 1c08 ldr.w r1, [lr, #-8] <== NOT EXECUTED
return _Objects_Name_to_string(
114086: 4613 mov r3, r2 <== NOT EXECUTED
114088: 4602 mov r2, r0 <== NOT EXECUTED
*id = queue_object->Object.id;
11408a: 6021 str r1, [r4, #0] <== NOT EXECUTED
return _Objects_Name_to_string(
11408c: 2100 movs r1, #0 <== NOT EXECUTED
11408e: f85e 0c04 ldr.w r0, [lr, #-4] <== NOT EXECUTED
}
114092: e8bd 4030 ldmia.w sp!, {r4, r5, lr} <== NOT EXECUTED
return _Objects_Name_to_string(
114096: f7fe bccd b.w 112a34 <_Objects_Name_to_string> <== NOT EXECUTED
11409a: bf00 nop
0010a9c4 <_Thread_queue_Surrender>:
Thread_queue_Heads *heads,
Thread_Control *previous_owner,
Thread_queue_Context *queue_context,
const Thread_queue_Operations *operations
)
{
10a9c4: b5f8 push {r3, r4, r5, r6, r7, lr}
10a9c6: 2700 movs r7, #0
10a9c8: 9c06 ldr r4, [sp, #24]
10a9ca: 4606 mov r6, r0
10a9cc: 461d mov r5, r3
Per_CPU_Control *cpu_self;
_Assert( heads != NULL );
_Thread_queue_Context_clear_priority_updates( queue_context );
new_owner = ( *operations->surrender )(
10a9ce: 68e4 ldr r4, [r4, #12]
10a9d0: 615f str r7, [r3, #20]
10a9d2: 47a0 blx r4
10a9d4: f240 4304 movw r3, #1028 ; 0x404
queue,
heads,
previous_owner,
queue_context
);
queue->owner = new_owner;
10a9d8: 6070 str r0, [r6, #4]
10a9da: f248 129c movw r2, #33180 ; 0x819c
bool success = ( the_thread->Wait.flags == expected_flags );
10a9de: 6d06 ldr r6, [r0, #80] ; 0x50
10a9e0: 6503 str r3, [r0, #80] ; 0x50
disable_level = cpu_self->thread_dispatch_disable_level;
10a9e2: f242 7380 movw r3, #10112 ; 0x2780
10a9e6: f2c0 0320 movt r3, #32
the_thread->Wait.operations = &_Thread_queue_Operations_default;
10a9ea: f2c0 0211 movt r2, #17
the_thread->Wait.queue = NULL;
10a9ee: e9c0 7215 strd r7, r2, [r0, #84] ; 0x54
new_owner = ( *operations->surrender )(
10a9f2: 4604 mov r4, r0
10a9f4: 691a ldr r2, [r3, #16]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
10a9f6: 3201 adds r2, #1
10a9f8: 611a str r2, [r3, #16]
10a9fa: 682b ldr r3, [r5, #0]
10a9fc: f383 8900 msr CPSR_fc, r3
_Thread_queue_Queue_release(
queue,
&queue_context->Lock_context.Lock_context
);
_Thread_Priority_update( queue_context );
10aa00: 4628 mov r0, r5
10aa02: f004 fa83 bl 10ef0c <_Thread_Priority_update>
if ( unblock ) {
10aa06: f240 4301 movw r3, #1025 ; 0x401
10aa0a: 429e cmp r6, r3
10aa0c: d107 bne.n 10aa1e <_Thread_queue_Surrender+0x5a> <== NEVER TAKEN
_Thread_Remove_timer_and_unblock( new_owner, queue );
}
_Thread_Dispatch_enable( cpu_self );
10aa0e: f242 7080 movw r0, #10112 ; 0x2780 <== NOT EXECUTED
}
10aa12: e8bd 40f8 ldmia.w sp!, {r3, r4, r5, r6, r7, lr} <== NOT EXECUTED
_Thread_Dispatch_enable( cpu_self );
10aa16: f2c0 0020 movt r0, #32 <== NOT EXECUTED
10aa1a: f7ff be6d b.w 10a6f8 <_Thread_Dispatch_enable> <== NOT EXECUTED
__asm__ volatile (
10aa1e: f3ef 8500 mrs r5, CPSR
10aa22: f045 0380 orr.w r3, r5, #128 ; 0x80
10aa26: f383 8900 msr CPSR_fc, r3
10aa2a: 6e20 ldr r0, [r4, #96] ; 0x60
10aa2c: f104 0168 add.w r1, r4, #104 ; 0x68
10aa30: f000 ff8c bl 10b94c <_Watchdog_Remove>
__asm__ volatile (
10aa34: f385 8900 msr CPSR_fc, r5
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10aa38: f645 71ff movw r1, #24575 ; 0x5fff
10aa3c: 4620 mov r0, r4
10aa3e: f2c3 0101 movt r1, #12289 ; 0x3001
10aa42: f004 fa97 bl 10ef74 <_Thread_Clear_state>
10aa46: f242 7080 movw r0, #10112 ; 0x2780
}
10aa4a: e8bd 40f8 ldmia.w sp!, {r3, r4, r5, r6, r7, lr}
_Thread_Dispatch_enable( cpu_self );
10aa4e: f2c0 0020 movt r0, #32
10aa52: f7ff be51 b.w 10a6f8 <_Thread_Dispatch_enable>
10aa56: bf00 nop
00109bc8 <_Timecounter_Bintime>:
{
109bc8: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
109bcc: f240 28d0 movw r8, #720 ; 0x2d0
109bd0: b083 sub sp, #12
109bd2: 4604 mov r4, r0
109bd4: f2c0 0820 movt r8, #32
th = timehands;
109bd8: f8d8 6000 ldr.w r6, [r8]
109bdc: 6f37 ldr r7, [r6, #112] ; 0x70
*bt = th->th_bintime;
109bde: f106 0330 add.w r3, r6, #48 ; 0x30
tc = th->th_counter;
109be2: f8d6 a000 ldr.w sl, [r6]
*bt = th->th_bintime;
109be6: cb0f ldmia r3, {r0, r1, r2, r3}
bintime_addx(bt, th->th_scale * tc_delta(th));
109be8: e9d6 5904 ldrd r5, r9, [r6, #16]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
109bec: f8da b000 ldr.w fp, [sl]
*bt = th->th_bintime;
109bf0: e884 000f stmia.w r4, {r0, r1, r2, r3}
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
109bf4: 4650 mov r0, sl
109bf6: 47d8 blx fp
109bf8: 69b1 ldr r1, [r6, #24]
109bfa: f8da 3004 ldr.w r3, [sl, #4]
109bfe: 68a2 ldr r2, [r4, #8]
109c00: 1a40 subs r0, r0, r1
109c02: 4018 ands r0, r3
bintime_addx(bt, th->th_scale * tc_delta(th));
109c04: fba0 3505 umull r3, r5, r0, r5
109c08: 9201 str r2, [sp, #4]
109c0a: 9901 ldr r1, [sp, #4]
109c0c: 2200 movs r2, #0
109c0e: fb00 5009 mla r0, r0, r9, r5
109c12: 185b adds r3, r3, r1
109c14: 68e1 ldr r1, [r4, #12]
109c16: 4148 adcs r0, r1
109c18: bf28 it cs
109c1a: 2201 movcs r2, #1
_bt->frac += _x;
109c1c: e9c4 3002 strd r3, r0, [r4, #8]
if (_u > _bt->frac)
109c20: b132 cbz r2, 109c30 <_Timecounter_Bintime+0x68>
_bt->sec++;
109c22: e9d4 3200 ldrd r3, r2, [r4]
109c26: 3301 adds r3, #1
109c28: f142 0200 adc.w r2, r2, #0
109c2c: e9c4 3200 strd r3, r2, [r4]
} while (gen == 0 || gen != th->th_generation);
109c30: 2f00 cmp r7, #0
109c32: d0d1 beq.n 109bd8 <_Timecounter_Bintime+0x10> <== ALWAYS TAKEN
109c34: 6f33 ldr r3, [r6, #112] ; 0x70
109c36: 42bb cmp r3, r7
109c38: d1ce bne.n 109bd8 <_Timecounter_Bintime+0x10>
}
109c3a: b003 add sp, #12
109c3c: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00108a30 <_Timecounter_Binuptime>:
{
108a30: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
108a34: f240 28b0 movw r8, #688 ; 0x2b0
108a38: b083 sub sp, #12
108a3a: 4604 mov r4, r0
108a3c: f2c0 0820 movt r8, #32
th = timehands;
108a40: f8d8 6000 ldr.w r6, [r8]
val = *obj;
108a44: 6f37 ldr r7, [r6, #112] ; 0x70
*bt = th->th_offset;
108a46: f106 0320 add.w r3, r6, #32
tc = th->th_counter;
108a4a: f8d6 a000 ldr.w sl, [r6]
*bt = th->th_offset;
108a4e: cb0f ldmia r3, {r0, r1, r2, r3}
bintime_addx(bt, th->th_scale * tc_delta(th));
108a50: e9d6 5904 ldrd r5, r9, [r6, #16]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
108a54: f8da b000 ldr.w fp, [sl]
*bt = th->th_offset;
108a58: e884 000f stmia.w r4, {r0, r1, r2, r3}
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
108a5c: 4650 mov r0, sl
108a5e: 47d8 blx fp
108a60: 69b1 ldr r1, [r6, #24]
108a62: f8da 3004 ldr.w r3, [sl, #4]
108a66: 68a2 ldr r2, [r4, #8]
108a68: 1a40 subs r0, r0, r1
108a6a: 4018 ands r0, r3
bintime_addx(bt, th->th_scale * tc_delta(th));
108a6c: fba0 3505 umull r3, r5, r0, r5
108a70: 9201 str r2, [sp, #4]
108a72: 9901 ldr r1, [sp, #4]
108a74: 2200 movs r2, #0
108a76: fb00 5009 mla r0, r0, r9, r5
108a7a: 185b adds r3, r3, r1
108a7c: 68e1 ldr r1, [r4, #12]
108a7e: 4148 adcs r0, r1
108a80: bf28 it cs
108a82: 2201 movcs r2, #1
_bt->frac += _x;
108a84: e9c4 3002 strd r3, r0, [r4, #8]
if (_u > _bt->frac)
108a88: b132 cbz r2, 108a98 <_Timecounter_Binuptime+0x68>
_bt->sec++;
108a8a: e9d4 3200 ldrd r3, r2, [r4]
108a8e: 3301 adds r3, #1
108a90: f142 0200 adc.w r2, r2, #0
108a94: e9c4 3200 strd r3, r2, [r4]
} while (gen == 0 || gen != th->th_generation);
108a98: 2f00 cmp r7, #0
108a9a: d0d1 beq.n 108a40 <_Timecounter_Binuptime+0x10> <== ALWAYS TAKEN
108a9c: 6f33 ldr r3, [r6, #112] ; 0x70
108a9e: 42bb cmp r3, r7
108aa0: d1ce bne.n 108a40 <_Timecounter_Binuptime+0x10>
}
108aa2: b003 add sp, #12
108aa4: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00109cc0 <_Timecounter_Getbintime>:
{
109cc0: b530 push {r4, r5, lr}
109cc2: f240 2ed0 movw lr, #720 ; 0x2d0
109cc6: 4684 mov ip, r0
109cc8: f2c0 0e20 movt lr, #32
th = timehands;
109ccc: f8de 4000 ldr.w r4, [lr]
109cd0: 6f25 ldr r5, [r4, #112] ; 0x70
*bt = th->th_bintime;
109cd2: f104 0330 add.w r3, r4, #48 ; 0x30
109cd6: cb0f ldmia r3, {r0, r1, r2, r3}
109cd8: e88c 000f stmia.w ip, {r0, r1, r2, r3}
} while (gen == 0 || gen != th->th_generation);
109cdc: 2d00 cmp r5, #0
109cde: d0f5 beq.n 109ccc <_Timecounter_Getbintime+0xc> <== ALWAYS TAKEN
109ce0: 6f23 ldr r3, [r4, #112] ; 0x70
109ce2: 42ab cmp r3, r5
109ce4: d1f2 bne.n 109ccc <_Timecounter_Getbintime+0xc> <== ALWAYS TAKEN
}
109ce6: bd30 pop {r4, r5, pc}
00105c70 <_Timecounter_Getbinuptime>:
{
105c70: b530 push {r4, r5, lr}
105c72: f240 0ee0 movw lr, #224 ; 0xe0
105c76: 4684 mov ip, r0
105c78: f2c0 0e20 movt lr, #32
th = timehands;
105c7c: f8de 4000 ldr.w r4, [lr]
105c80: 6f25 ldr r5, [r4, #112] ; 0x70
*bt = th->th_offset;
105c82: f104 0320 add.w r3, r4, #32
105c86: cb0f ldmia r3, {r0, r1, r2, r3}
105c88: e88c 000f stmia.w ip, {r0, r1, r2, r3}
} while (gen == 0 || gen != th->th_generation);
105c8c: 2d00 cmp r5, #0
105c8e: d0f5 beq.n 105c7c <_Timecounter_Getbinuptime+0xc> <== ALWAYS TAKEN
105c90: 6f23 ldr r3, [r4, #112] ; 0x70
105c92: 42ab cmp r3, r5
105c94: d1f2 bne.n 105c7c <_Timecounter_Getbinuptime+0xc> <== ALWAYS TAKEN
}
105c96: bd30 pop {r4, r5, pc}
00105d74 <_Timecounter_Getmicrotime>:
{
105d74: b530 push {r4, r5, lr}
105d76: f240 0ee0 movw lr, #224 ; 0xe0
105d7a: 4684 mov ip, r0
105d7c: f2c0 0e20 movt lr, #32
th = timehands;
105d80: f8de 4000 ldr.w r4, [lr]
105d84: 6f25 ldr r5, [r4, #112] ; 0x70
*tvp = th->th_microtime;
105d86: f104 0340 add.w r3, r4, #64 ; 0x40
105d8a: cb0f ldmia r3, {r0, r1, r2, r3}
105d8c: e88c 000f stmia.w ip, {r0, r1, r2, r3}
} while (gen == 0 || gen != th->th_generation);
105d90: 2d00 cmp r5, #0
105d92: d0f5 beq.n 105d80 <_Timecounter_Getmicrotime+0xc> <== ALWAYS TAKEN
105d94: 6f23 ldr r3, [r4, #112] ; 0x70
105d96: 42ab cmp r3, r5
105d98: d1f2 bne.n 105d80 <_Timecounter_Getmicrotime+0xc> <== ALWAYS TAKEN
}
105d9a: bd30 pop {r4, r5, pc}
00105ccc <_Timecounter_Getmicrouptime>:
{
105ccc: b570 push {r4, r5, r6, lr}
105cce: f240 0ee0 movw lr, #224 ; 0xe0
105cd2: f2c0 0e20 movt lr, #32
th = timehands;
105cd6: f8de 4000 ldr.w r4, [lr]
105cda: 6f25 ldr r5, [r4, #112] ; 0x70
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
105cdc: 6ae2 ldr r2, [r4, #44] ; 0x2c
_tv->tv_sec = _bt->sec;
105cde: edd4 0b08 vldr d16, [r4, #32]
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
105ce2: 0156 lsls r6, r2, #5
105ce4: 0ed3 lsrs r3, r2, #27
_tv->tv_sec = _bt->sec;
105ce6: edc0 0b00 vstr d16, [r0]
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
105cea: 1ab6 subs r6, r6, r2
105cec: f163 0300 sbc.w r3, r3, #0
105cf0: 0271 lsls r1, r6, #9
105cf2: 025b lsls r3, r3, #9
105cf4: 1889 adds r1, r1, r2
105cf6: ea43 53d6 orr.w r3, r3, r6, lsr #23
105cfa: ea4f 1681 mov.w r6, r1, lsl #6
105cfe: f143 0300 adc.w r3, r3, #0
105d02: 1a76 subs r6, r6, r1
105d04: ea4f 1c83 mov.w ip, r3, lsl #6
105d08: ea4c 6c91 orr.w ip, ip, r1, lsr #26
105d0c: eb6c 0303 sbc.w r3, ip, r3
105d10: 18b2 adds r2, r6, r2
105d12: f143 0300 adc.w r3, r3, #0
105d16: 6083 str r3, [r0, #8]
} while (gen == 0 || gen != th->th_generation);
105d18: 2d00 cmp r5, #0
105d1a: d0dc beq.n 105cd6 <_Timecounter_Getmicrouptime+0xa> <== ALWAYS TAKEN
105d1c: 6f23 ldr r3, [r4, #112] ; 0x70
105d1e: 42ab cmp r3, r5
105d20: d1d9 bne.n 105cd6 <_Timecounter_Getmicrouptime+0xa> <== ALWAYS TAKEN
}
105d22: bd70 pop {r4, r5, r6, pc}
00109ce8 <_Timecounter_Getnanotime>:
{
109ce8: b530 push {r4, r5, lr}
109cea: f240 2ed0 movw lr, #720 ; 0x2d0
109cee: 4684 mov ip, r0
109cf0: f2c0 0e20 movt lr, #32
th = timehands;
109cf4: f8de 4000 ldr.w r4, [lr]
109cf8: 6f25 ldr r5, [r4, #112] ; 0x70
*tsp = th->th_nanotime;
109cfa: f104 0350 add.w r3, r4, #80 ; 0x50
109cfe: cb0f ldmia r3, {r0, r1, r2, r3}
109d00: e88c 000f stmia.w ip, {r0, r1, r2, r3}
} while (gen == 0 || gen != th->th_generation);
109d04: 2d00 cmp r5, #0
109d06: d0f5 beq.n 109cf4 <_Timecounter_Getnanotime+0xc> <== ALWAYS TAKEN
109d08: 6f23 ldr r3, [r4, #112] ; 0x70
109d0a: 42ab cmp r3, r5
109d0c: d1f2 bne.n 109cf4 <_Timecounter_Getnanotime+0xc> <== ALWAYS TAKEN
}
109d0e: bd30 pop {r4, r5, pc}
00109c8c <_Timecounter_Getnanouptime>:
_ts->tv_nsec = ((uint64_t)1000000000 *
109c8c: f44f 4c4a mov.w ip, #51712 ; 0xca00
{
109c90: b510 push {r4, lr}
109c92: f240 2ed0 movw lr, #720 ; 0x2d0
109c96: f6c3 3c9a movt ip, #15258 ; 0x3b9a
109c9a: f2c0 0e20 movt lr, #32
th = timehands;
109c9e: f8de 3000 ldr.w r3, [lr]
109ca2: 6f19 ldr r1, [r3, #112] ; 0x70
(uint32_t)(_bt->frac >> 32)) >> 32;
109ca4: 6ada ldr r2, [r3, #44] ; 0x2c
_ts->tv_sec = _bt->sec;
109ca6: edd3 0b08 vldr d16, [r3, #32]
_ts->tv_nsec = ((uint64_t)1000000000 *
109caa: fba2 240c umull r2, r4, r2, ip
_ts->tv_sec = _bt->sec;
109cae: edc0 0b00 vstr d16, [r0]
_ts->tv_nsec = ((uint64_t)1000000000 *
109cb2: 6084 str r4, [r0, #8]
} while (gen == 0 || gen != th->th_generation);
109cb4: 2900 cmp r1, #0
109cb6: d0f2 beq.n 109c9e <_Timecounter_Getnanouptime+0x12> <== ALWAYS TAKEN
109cb8: 6f1b ldr r3, [r3, #112] ; 0x70
109cba: 428b cmp r3, r1
109cbc: d1ef bne.n 109c9e <_Timecounter_Getnanouptime+0x12> <== ALWAYS TAKEN
}
109cbe: bd10 pop {r4, pc}
00109d10 <_Timecounter_Install>:
if (tc->tc_quality < timecounter->tc_quality)
109d10: f240 232c movw r3, #556 ; 0x22c
{
109d14: b530 push {r4, r5, lr}
if (tc->tc_quality < timecounter->tc_quality)
109d16: f2c0 0320 movt r3, #32
109d1a: 6944 ldr r4, [r0, #20]
{
109d1c: b083 sub sp, #12
if (tc->tc_quality < timecounter->tc_quality)
109d1e: 681a ldr r2, [r3, #0]
109d20: 6951 ldr r1, [r2, #20]
109d22: 428c cmp r4, r1
109d24: db14 blt.n 109d50 <_Timecounter_Install+0x40> <== ALWAYS TAKEN
if (tc->tc_quality == timecounter->tc_quality &&
109d26: d107 bne.n 109d38 <_Timecounter_Install+0x28>
109d28: e9d2 4202 ldrd r4, r2, [r2, #8]
109d2c: 6885 ldr r5, [r0, #8]
109d2e: 68c1 ldr r1, [r0, #12]
109d30: 42a5 cmp r5, r4
109d32: eb71 0202 sbcs.w r2, r1, r2
109d36: d30b bcc.n 109d50 <_Timecounter_Install+0x40>
timecounter = tc;
109d38: 6018 str r0, [r3, #0]
__asm__ volatile (
109d3a: f3ef 8300 mrs r3, CPSR
109d3e: f043 0280 orr.w r2, r3, #128 ; 0x80
109d42: f382 8900 msr CPSR_fc, r2
_Timecounter_Acquire(&lock_context);
109d46: 9301 str r3, [sp, #4]
_Timecounter_Windup(new_boottimebin, &lock_context);
109d48: 2000 movs r0, #0
109d4a: a901 add r1, sp, #4
109d4c: f7ff fdf2 bl 109934 <_Timecounter_Windup>
}
109d50: b003 add sp, #12
109d52: bd30 pop {r4, r5, pc}
00109b78 <_Timecounter_Sbinuptime>:
{
109b78: e92d 4ff8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}
109b7c: f240 27d0 movw r7, #720 ; 0x2d0
109b80: f2c0 0720 movt r7, #32
th = timehands;
109b84: 683c ldr r4, [r7, #0]
val = *obj;
109b86: f8d4 b070 ldr.w fp, [r4, #112] ; 0x70
tc = th->th_counter;
109b8a: 6825 ldr r5, [r4, #0]
109b8c: f8d4 9020 ldr.w r9, [r4, #32]
109b90: f8d4 802c ldr.w r8, [r4, #44] ; 0x2c
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
109b94: 682b ldr r3, [r5, #0]
109b96: 4628 mov r0, r5
sbt += (th->th_scale * tc_delta(th)) >> 32;
109b98: e9d4 6a04 ldrd r6, sl, [r4, #16]
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
109b9c: 4798 blx r3
109b9e: 69a2 ldr r2, [r4, #24]
tc->tc_counter_mask);
109ba0: 686b ldr r3, [r5, #4]
} while (gen == 0 || gen != th->th_generation);
109ba2: f1bb 0f00 cmp.w fp, #0
109ba6: d0ed beq.n 109b84 <_Timecounter_Sbinuptime+0xc> <== ALWAYS TAKEN
109ba8: 6f21 ldr r1, [r4, #112] ; 0x70
109baa: 4559 cmp r1, fp
109bac: d1ea bne.n 109b84 <_Timecounter_Sbinuptime+0xc>
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
109bae: 1a80 subs r0, r0, r2
109bb0: 4018 ands r0, r3
sbt += (th->th_scale * tc_delta(th)) >> 32;
109bb2: fba0 6306 umull r6, r3, r0, r6
109bb6: fb00 300a mla r0, r0, sl, r3
109bba: eb10 0008 adds.w r0, r0, r8
}
109bbe: f149 0100 adc.w r1, r9, #0
109bc2: e8bd 8ff8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
109bc6: bf00 nop
001076dc <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
1076dc: b570 push {r4, r5, r6, lr}
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
1076de: f64c 1eff movw lr, #51711 ; 0xc9ff
uint32_t seconds = add->tv_sec;
1076e2: 680d ldr r5, [r1, #0]
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
1076e4: f6c3 3e9a movt lr, #15258 ; 0x3b9a
time->tv_nsec += add->tv_nsec;
1076e8: e9d1 3101 ldrd r3, r1, [r1, #4]
1076ec: 6882 ldr r2, [r0, #8]
time->tv_sec += add->tv_sec;
1076ee: 6804 ldr r4, [r0, #0]
time->tv_nsec += add->tv_nsec;
1076f0: 440a add r2, r1
time->tv_sec += add->tv_sec;
1076f2: 6841 ldr r1, [r0, #4]
1076f4: 192c adds r4, r5, r4
time->tv_nsec += add->tv_nsec;
1076f6: 6082 str r2, [r0, #8]
time->tv_sec += add->tv_sec;
1076f8: 6004 str r4, [r0, #0]
1076fa: eb43 0101 adc.w r1, r3, r1
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
1076fe: 4572 cmp r2, lr
time->tv_sec += add->tv_sec;
107700: 6041 str r1, [r0, #4]
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
107702: d914 bls.n 10772e <_Timespec_Add_to+0x52>
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
107704: f44f 5658 mov.w r6, #13824 ; 0x3600
107708: 4684 mov ip, r0
10770a: f2cc 4665 movt r6, #50277 ; 0xc465
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
10770e: 4623 mov r3, r4
time->tv_sec++;
107710: 3301 adds r3, #1
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
107712: 4432 add r2, r6
time->tv_sec++;
107714: f141 0100 adc.w r1, r1, #0
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
107718: 4572 cmp r2, lr
10771a: eb05 0003 add.w r0, r5, r3
10771e: eba0 0004 sub.w r0, r0, r4
107722: d8f5 bhi.n 107710 <_Timespec_Add_to+0x34> <== ALWAYS TAKEN
107724: f8cc 2008 str.w r2, [ip, #8]
107728: e9cc 3100 strd r3, r1, [ip]
seconds++;
}
return seconds;
}
10772c: bd70 pop {r4, r5, r6, pc}
uint32_t seconds = add->tv_sec;
10772e: 4628 mov r0, r5
}
107730: bd70 pop {r4, r5, r6, pc}
107732: bf00 nop
001152e8 <_Timespec_Divide_by_integer>:
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
1152e8: b5f8 push {r3, r4, r5, r6, r7, lr}
1152ea: 4615 mov r5, r2
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
t = time->tv_sec;
1152ec: e9d0 4700 ldrd r4, r7, [r0]
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
1152f0: 460a mov r2, r1
t *= TOD_NANOSECONDS_PER_SECOND;
1152f2: f44f 414a mov.w r1, #51712 ; 0xca00
t /= iterations;
1152f6: 2300 movs r3, #0
t *= TOD_NANOSECONDS_PER_SECOND;
1152f8: f6c3 319a movt r1, #15258 ; 0x3b9a
t += time->tv_nsec;
1152fc: 6886 ldr r6, [r0, #8]
t *= TOD_NANOSECONDS_PER_SECOND;
1152fe: fba4 0401 umull r0, r4, r4, r1
115302: fb01 4107 mla r1, r1, r7, r4
t += time->tv_nsec;
115306: 1830 adds r0, r6, r0
t /= iterations;
115308: eb41 71e6 adc.w r1, r1, r6, asr #31
11530c: f01c f8ea bl 1314e4 <__aeabi_uldivmod>
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
115310: a309 add r3, pc, #36 ; (adr r3, 115338 <_Timespec_Divide_by_integer+0x50>)
115312: e9d3 2300 ldrd r2, r3, [r3]
t /= iterations;
115316: 4606 mov r6, r0
115318: 460c mov r4, r1
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
11531a: f01c f8e3 bl 1314e4 <__aeabi_uldivmod>
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
11531e: a306 add r3, pc, #24 ; (adr r3, 115338 <_Timespec_Divide_by_integer+0x50>)
115320: e9d3 2300 ldrd r2, r3, [r3]
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
115324: e9c5 0100 strd r0, r1, [r5]
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
115328: 4630 mov r0, r6
11532a: 4621 mov r1, r4
11532c: f01c f8da bl 1314e4 <__aeabi_uldivmod>
115330: 60aa str r2, [r5, #8]
}
115332: bdf8 pop {r3, r4, r5, r6, r7, pc}
115334: f3af 8000 nop.w <== NOT EXECUTED
115338: 3b9aca00 .word 0x3b9aca00 <== NOT EXECUTED
11533c: 00000000 .word 0x00000000 <== NOT EXECUTED
0010b740 <_User_extensions_Handler_initialization>:
size_t n;
size_t i;
initial_table = _User_extensions_Initial_extensions;
initial_switch_controls = _User_extensions_Initial_switch_controls;
n = _User_extensions_Initial_count;
10b740: f247 73d4 movw r3, #30676 ; 0x77d4
10b744: f2c0 0311 movt r3, #17
10b748: 681b ldr r3, [r3, #0]
for ( i = 0 ; i < n ; ++i ) {
10b74a: b32b cbz r3, 10b798 <_User_extensions_Handler_initialization+0x58>
{
10b74c: b530 push {r4, r5, lr}
10b74e: f240 2ed4 movw lr, #724 ; 0x2d4
10b752: eb03 0c43 add.w ip, r3, r3, lsl #1
10b756: f2c0 0e20 movt lr, #32
10b75a: f242 4398 movw r3, #9368 ; 0x2498
10b75e: f2c0 0320 movt r3, #32
10b762: f8de 0008 ldr.w r0, [lr, #8]
10b766: f247 72d8 movw r2, #30680 ; 0x77d8
10b76a: eb03 0c8c add.w ip, r3, ip, lsl #2
10b76e: f2c0 0211 movt r2, #17
for ( i = 0 ; i < n ; ++i ) {
10b772: 2400 movs r4, #0
the_node->next = tail;
10b774: f10e 0504 add.w r5, lr, #4
User_extensions_thread_switch_extension callout;
callout = initial_table[ i ].thread_switch;
10b778: 6911 ldr r1, [r2, #16]
for ( i = 0 ; i < n ; ++i ) {
10b77a: 3224 adds r2, #36 ; 0x24
if ( callout != NULL ) {
10b77c: b129 cbz r1, 10b78a <_User_extensions_Handler_initialization+0x4a>
User_extensions_Switch_control *c;
c = &initial_switch_controls[ i ];
c->thread_switch = callout;
10b77e: 6099 str r1, [r3, #8]
}
10b780: 2401 movs r4, #1
the_node->next = tail;
10b782: 601d str r5, [r3, #0]
old_last->next = the_node;
10b784: 6003 str r3, [r0, #0]
the_node->previous = old_last;
10b786: 6058 str r0, [r3, #4]
}
10b788: 4618 mov r0, r3
for ( i = 0 ; i < n ; ++i ) {
10b78a: 330c adds r3, #12
10b78c: 4563 cmp r3, ip
10b78e: d1f3 bne.n 10b778 <_User_extensions_Handler_initialization+0x38>
10b790: b10c cbz r4, 10b796 <_User_extensions_Handler_initialization+0x56>
10b792: f8ce 0008 str.w r0, [lr, #8]
_Chain_Initialize_node( &c->Node );
_Chain_Append_unprotected( &_User_extensions_Switches_list, &c->Node );
}
}
}
10b796: bd30 pop {r4, r5, pc}
10b798: 4770 bx lr <== NOT EXECUTED
10b79a: bf00 nop
0010b7f4 <_User_extensions_Iterate>:
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor,
Chain_Iterator_direction direction
)
{
10b7f4: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
ISR_lock_Context lock_context;
executing = _Thread_Get_executing();
initial_begin = _User_extensions_Initial_extensions;
initial_end = initial_begin + _User_extensions_Initial_count;
10b7f8: f247 74d4 movw r4, #30676 ; 0x77d4
10b7fc: f2c0 0411 movt r4, #17
10b800: f242 7380 movw r3, #10112 ; 0x2780
10b804: f247 79d8 movw r9, #30680 ; 0x77d8
10b808: f2c0 0320 movt r3, #32
10b80c: 6824 ldr r4, [r4, #0]
10b80e: f2c0 0911 movt r9, #17
10b812: 699d ldr r5, [r3, #24]
{
10b814: b086 sub sp, #24
10b816: 4606 mov r6, r0
10b818: 460f mov r7, r1
if ( direction == CHAIN_ITERATOR_FORWARD ) {
10b81a: 4692 mov sl, r2
initial_end = initial_begin + _User_extensions_Initial_count;
10b81c: eb04 04c4 add.w r4, r4, r4, lsl #3
10b820: eb09 0484 add.w r4, r9, r4, lsl #2
if ( direction == CHAIN_ITERATOR_FORWARD ) {
10b824: 2a00 cmp r2, #0
10b826: d15f bne.n 10b8e8 <_User_extensions_Iterate+0xf4>
initial_current = initial_begin;
while ( initial_current != initial_end ) {
10b828: 454c cmp r4, r9
initial_current = initial_begin;
10b82a: bf18 it ne
10b82c: 46c8 movne r8, r9
while ( initial_current != initial_end ) {
10b82e: d007 beq.n 10b840 <_User_extensions_Iterate+0x4c> <== ALWAYS TAKEN
(*visitor)( executing, arg, initial_current );
10b830: 4642 mov r2, r8
10b832: 4631 mov r1, r6
10b834: 4628 mov r0, r5
++initial_current;
10b836: f108 0824 add.w r8, r8, #36 ; 0x24
(*visitor)( executing, arg, initial_current );
10b83a: 47b8 blx r7
while ( initial_current != initial_end ) {
10b83c: 4544 cmp r4, r8
10b83e: d1f7 bne.n 10b830 <_User_extensions_Iterate+0x3c>
}
end = _Chain_Immutable_tail( &_User_extensions_List.Active );
10b840: f8df 80b4 ldr.w r8, [pc, #180] ; 10b8f8 <_User_extensions_Iterate+0x104>
10b844: f1a8 0204 sub.w r2, r8, #4
__asm__ volatile (
10b848: f3ef 8100 mrs r1, CPSR
10b84c: f041 0380 orr.w r3, r1, #128 ; 0x80
10b850: f383 8900 msr CPSR_fc, r3
the_node->next = tail;
10b854: 4b27 ldr r3, [pc, #156] ; (10b8f4 <_User_extensions_Iterate+0x100>)
old_last = tail->previous;
10b856: f8d2 c014 ldr.w ip, [r2, #20]
);
the_iterator->direction = direction;
if ( direction == CHAIN_ITERATOR_FORWARD ) {
the_iterator->position = _Chain_Head( the_chain );
10b85a: f1a3 000c sub.w r0, r3, #12
the_node->next = tail;
10b85e: 9301 str r3, [sp, #4]
the_iterator->position = _Chain_Head( the_chain );
10b860: 3b10 subs r3, #16
10b862: f1ba 0f00 cmp.w sl, #0
10b866: bf08 it eq
10b868: 4618 moveq r0, r3
tail->previous = the_node;
10b86a: ab01 add r3, sp, #4
10b86c: 6153 str r3, [r2, #20]
old_last->next = the_node;
10b86e: f8cc 3000 str.w r3, [ip]
the_iterator->direction = direction;
10b872: e9cd ca02 strd ip, sl, [sp, #8]
if ( direction == CHAIN_ITERATOR_FORWARD ) {
10b876: 9004 str r0, [sp, #16]
&_User_extensions_List.Iterators,
&iter.Iterator,
direction
);
if ( executing != NULL ) {
10b878: b125 cbz r5, 10b884 <_User_extensions_Iterate+0x90>
iter.previous = executing->last_user_extensions_iterator;
10b87a: f8d5 2190 ldr.w r2, [r5, #400] ; 0x190
executing->last_user_extensions_iterator = &iter;
10b87e: f8c5 3190 str.w r3, [r5, #400] ; 0x190
iter.previous = executing->last_user_extensions_iterator;
10b882: 9205 str r2, [sp, #20]
the_iterator->position = _Chain_Head( the_chain );
10b884: 4653 mov r3, sl
10b886: e00e b.n 10b8a6 <_User_extensions_Iterate+0xb2>
RTEMS_INLINE_ROUTINE void _Chain_Iterator_set_position(
Chain_Iterator *the_iterator,
Chain_Node *the_node
)
{
the_iterator->position = the_node;
10b888: 9204 str r2, [sp, #16]
__asm__ volatile (
10b88a: f381 8900 msr CPSR_fc, r1
_Chain_Iterator_set_position( &iter.Iterator, node );
_User_extensions_Release( &lock_context );
extension = (const User_extensions_Control *) node;
( *visitor )( executing, arg, &extension->Callouts );
10b88e: 3214 adds r2, #20
10b890: 4631 mov r1, r6
10b892: 4628 mov r0, r5
10b894: 47b8 blx r7
__asm__ volatile (
10b896: f3ef 8100 mrs r1, CPSR
10b89a: f041 0380 orr.w r3, r1, #128 ; 0x80
10b89e: f383 8900 msr CPSR_fc, r3
return _Chain_Next( the_iterator->position );
10b8a2: e9dd 3003 ldrd r3, r0, [sp, #12]
return the_node->previous;
10b8a6: e9d0 2000 ldrd r2, r0, [r0]
return _Chain_Previous( the_iterator->position );
10b8aa: 2b00 cmp r3, #0
10b8ac: bf18 it ne
10b8ae: 4602 movne r2, r0
while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) {
10b8b0: 4590 cmp r8, r2
10b8b2: d1e9 bne.n 10b888 <_User_extensions_Iterate+0x94>
_User_extensions_Acquire( &lock_context );
}
if ( executing != NULL ) {
10b8b4: b115 cbz r5, 10b8bc <_User_extensions_Iterate+0xc8>
executing->last_user_extensions_iterator = iter.previous;
10b8b6: 9b05 ldr r3, [sp, #20]
10b8b8: f8c5 3190 str.w r3, [r5, #400] ; 0x190
previous = the_node->previous;
10b8bc: e9dd 2301 ldrd r2, r3, [sp, #4]
next->previous = previous;
10b8c0: 6053 str r3, [r2, #4]
previous->next = next;
10b8c2: 601a str r2, [r3, #0]
__asm__ volatile (
10b8c4: f381 8900 msr CPSR_fc, r1
_Chain_Iterator_destroy( &iter.Iterator );
_User_extensions_Release( &lock_context );
if ( direction == CHAIN_ITERATOR_BACKWARD ) {
10b8c8: f1ba 0f01 cmp.w sl, #1
10b8cc: d007 beq.n 10b8de <_User_extensions_Iterate+0xea>
while ( initial_current != initial_begin ) {
--initial_current;
(*visitor)( executing, arg, initial_current );
}
}
}
10b8ce: b006 add sp, #24
10b8d0: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
--initial_current;
10b8d4: 3c24 subs r4, #36 ; 0x24
(*visitor)( executing, arg, initial_current );
10b8d6: 4631 mov r1, r6
10b8d8: 4622 mov r2, r4
10b8da: 4628 mov r0, r5
10b8dc: 47b8 blx r7
while ( initial_current != initial_begin ) {
10b8de: 454c cmp r4, r9
10b8e0: d1f8 bne.n 10b8d4 <_User_extensions_Iterate+0xe0>
}
10b8e2: b006 add sp, #24
10b8e4: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
end = _Chain_Immutable_head( &_User_extensions_List.Active );
10b8e8: f240 22ec movw r2, #748 ; 0x2ec
10b8ec: f2c0 0220 movt r2, #32
10b8f0: 4690 mov r8, r2
10b8f2: e7a9 b.n 10b848 <_User_extensions_Iterate+0x54>
10b8f4: 002002fc .word 0x002002fc
10b8f8: 002002f0 .word 0x002002f0
0010fa00 <_User_extensions_Remove_set>:
#include <rtems/score/percpu.h>
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
10fa00: b430 push {r4, r5}
__asm__ volatile (
10fa02: f3ef 8c00 mrs ip, CPSR
10fa06: f04c 0380 orr.w r3, ip, #128 ; 0x80
10fa0a: f383 8900 msr CPSR_fc, r3
return the_node->next;
10fa0e: f240 2188 movw r1, #648 ; 0x288
10fa12: e9d0 5400 ldrd r5, r4, [r0]
10fa16: f2c0 0120 movt r1, #32
10fa1a: 68cb ldr r3, [r1, #12]
while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
10fa1c: 3110 adds r1, #16
10fa1e: 428b cmp r3, r1
10fa20: d103 bne.n 10fa2a <_User_extensions_Remove_set+0x2a> <== ALWAYS TAKEN
10fa22: e00e b.n 10fa42 <_User_extensions_Remove_set+0x42>
return the_node->next;
10fa24: 681b ldr r3, [r3, #0] <== NOT EXECUTED
while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
10fa26: 428b cmp r3, r1 <== NOT EXECUTED
10fa28: d00b beq.n 10fa42 <_User_extensions_Remove_set+0x42> <== NOT EXECUTED
if ( iter->position == the_node_to_extract ) {
10fa2a: 68da ldr r2, [r3, #12] <== NOT EXECUTED
10fa2c: 4290 cmp r0, r2 <== NOT EXECUTED
10fa2e: d1f9 bne.n 10fa24 <_User_extensions_Remove_set+0x24> <== NOT EXECUTED
iter->position = _Chain_Previous( the_node_to_extract );
10fa30: 689a ldr r2, [r3, #8] <== NOT EXECUTED
10fa32: 2a00 cmp r2, #0 <== NOT EXECUTED
10fa34: bf14 ite ne <== NOT EXECUTED
10fa36: 462a movne r2, r5 <== NOT EXECUTED
10fa38: 4622 moveq r2, r4 <== NOT EXECUTED
10fa3a: 60da str r2, [r3, #12] <== NOT EXECUTED
return the_node->next;
10fa3c: 681b ldr r3, [r3, #0] <== NOT EXECUTED
while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
10fa3e: 428b cmp r3, r1 <== NOT EXECUTED
10fa40: d1f3 bne.n 10fa2a <_User_extensions_Remove_set+0x2a> <== NOT EXECUTED
next->previous = previous;
10fa42: 606c str r4, [r5, #4]
previous->next = next;
10fa44: 6025 str r5, [r4, #0]
__asm__ volatile (
10fa46: f38c 8900 msr CPSR_fc, ip
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL ) {
10fa4a: 6a43 ldr r3, [r0, #36] ; 0x24
10fa4c: b15b cbz r3, 10fa66 <_User_extensions_Remove_set+0x66>
__asm__ volatile (
10fa4e: f3ef 8100 mrs r1, CPSR
10fa52: f041 0380 orr.w r3, r1, #128 ; 0x80
10fa56: f383 8900 msr CPSR_fc, r3
previous = the_node->previous;
10fa5a: e9d0 2302 ldrd r2, r3, [r0, #8]
next->previous = previous;
10fa5e: 6053 str r3, [r2, #4]
previous->next = next;
10fa60: 601a str r2, [r3, #0]
__asm__ volatile (
10fa62: f381 8900 msr CPSR_fc, r1
_Per_CPU_Acquire_all( &lock_context );
_Chain_Extract_unprotected( &the_extension->Switch.Node );
_Per_CPU_Release_all( &lock_context );
}
}
10fa66: bc30 pop {r4, r5}
10fa68: 4770 bx lr
10fa6a: bf00 nop
0010b980 <_Watchdog_Do_tickle>:
#ifdef RTEMS_SMP
ISR_lock_Control *lock,
#endif
ISR_lock_Context *lock_context
)
{
10b980: e92d 43f8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
10b984: 4605 mov r5, r0
10b986: 9e08 ldr r6, [sp, #32]
10b988: 460c mov r4, r1
10b98a: 4690 mov r8, r2
10b98c: 461f mov r7, r3
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
10b98e: f04f 0902 mov.w r9, #2
do {
if ( first->expire <= now ) {
10b992: e9d4 2306 ldrd r2, r3, [r4, #24]
10b996: 4590 cmp r8, r2
10b998: eb77 0303 sbcs.w r3, r7, r3
10b99c: d31c bcc.n 10b9d8 <_Watchdog_Do_tickle+0x58>
return RB_RIGHT( the_node, Node );
10b99e: 6863 ldr r3, [r4, #4]
if ( node != NULL ) {
10b9a0: b1e3 cbz r3, 10b9dc <_Watchdog_Do_tickle+0x5c>
return RB_LEFT( the_node, Node );
10b9a2: 4619 mov r1, r3
10b9a4: 681b ldr r3, [r3, #0]
while ( ( left = _RBTree_Left( node ) ) != NULL ) {
10b9a6: 2b00 cmp r3, #0
10b9a8: d1fb bne.n 10b9a2 <_Watchdog_Do_tickle+0x22> <== ALWAYS TAKEN
header->first = node;
10b9aa: 6069 str r1, [r5, #4]
Watchdog_Service_routine_entry routine;
_Watchdog_Next_first( header, first );
_RBTree_Extract( &header->Watchdogs, &first->Node.RBTree );
10b9ac: 4621 mov r1, r4
10b9ae: 4628 mov r0, r5
10b9b0: f002 ffca bl 10e948 <_RBTree_Extract>
_Watchdog_Set_state( first, WATCHDOG_INACTIVE );
routine = first->routine;
10b9b4: 6923 ldr r3, [r4, #16]
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
10b9b6: f8c4 900c str.w r9, [r4, #12]
10b9ba: 6832 ldr r2, [r6, #0]
10b9bc: f382 8900 msr CPSR_fc, r2
_ISR_lock_Release_and_ISR_enable( lock, lock_context );
( *routine )( first );
10b9c0: 4620 mov r0, r4
10b9c2: 4798 blx r3
__asm__ volatile (
10b9c4: f3ef 8300 mrs r3, CPSR
10b9c8: f043 0280 orr.w r2, r3, #128 ; 0x80
10b9cc: f382 8900 msr CPSR_fc, r2
_ISR_lock_ISR_disable_and_acquire( lock, lock_context );
10b9d0: 6033 str r3, [r6, #0]
return (Watchdog_Control *) header->first;
10b9d2: 686c ldr r4, [r5, #4]
} else {
break;
}
first = _Watchdog_Header_first( header );
} while ( first != NULL );
10b9d4: 2c00 cmp r4, #0
10b9d6: d1dc bne.n 10b992 <_Watchdog_Do_tickle+0x12>
}
10b9d8: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
header->first = _RBTree_Parent( &the_watchdog->Node.RBTree );
10b9dc: 68a3 ldr r3, [r4, #8]
10b9de: 606b str r3, [r5, #4]
10b9e0: e7e4 b.n 10b9ac <_Watchdog_Do_tickle+0x2c>
10b9e2: bf00 nop
0010b94c <_Watchdog_Remove>:
void _Watchdog_Remove(
Watchdog_Header *header,
Watchdog_Control *the_watchdog
)
{
if ( _Watchdog_Is_scheduled( the_watchdog ) ) {
10b94c: 68cb ldr r3, [r1, #12]
10b94e: 2b01 cmp r3, #1
10b950: d900 bls.n 10b954 <_Watchdog_Remove+0x8>
10b952: 4770 bx lr
if ( header->first == &the_watchdog->Node.RBTree ) {
10b954: 6843 ldr r3, [r0, #4]
{
10b956: b510 push {r4, lr}
10b958: 460c mov r4, r1
if ( header->first == &the_watchdog->Node.RBTree ) {
10b95a: 428b cmp r3, r1
10b95c: d005 beq.n 10b96a <_Watchdog_Remove+0x1e>
_Watchdog_Next_first( header, the_watchdog );
}
_RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree );
10b95e: 4621 mov r1, r4
10b960: f002 fff2 bl 10e948 <_RBTree_Extract>
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
10b964: 2302 movs r3, #2
10b966: 60e3 str r3, [r4, #12]
_Watchdog_Set_state( the_watchdog, WATCHDOG_INACTIVE );
}
}
10b968: bd10 pop {r4, pc}
return RB_RIGHT( the_node, Node );
10b96a: 684b ldr r3, [r1, #4]
if ( node != NULL ) {
10b96c: b12b cbz r3, 10b97a <_Watchdog_Remove+0x2e>
return RB_LEFT( the_node, Node );
10b96e: 461a mov r2, r3
10b970: 681b ldr r3, [r3, #0]
while ( ( left = _RBTree_Left( node ) ) != NULL ) {
10b972: 2b00 cmp r3, #0
10b974: d1fb bne.n 10b96e <_Watchdog_Remove+0x22> <== ALWAYS TAKEN
header->first = node;
10b976: 6042 str r2, [r0, #4]
10b978: e7f1 b.n 10b95e <_Watchdog_Remove+0x12>
header->first = _RBTree_Parent( &the_watchdog->Node.RBTree );
10b97a: 688b ldr r3, [r1, #8]
10b97c: 6043 str r3, [r0, #4]
10b97e: e7ee b.n 10b95e <_Watchdog_Remove+0x12>
0010ba90 <_Workspace_Handler_initialization>:
uintptr_t page_size;
uintptr_t overhead;
size_t i;
page_size = CPU_HEAP_ALIGNMENT;
remaining = rtems_configuration_get_work_space_size();
10ba90: f248 2398 movw r3, #33432 ; 0x8298
{
10ba94: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
remaining = rtems_configuration_get_work_space_size();
10ba98: f2c0 0311 movt r3, #17
{
10ba9c: b083 sub sp, #12
10ba9e: 4680 mov r8, r0
remaining = rtems_configuration_get_work_space_size();
10baa0: 2000 movs r0, #0
10baa2: 781b ldrb r3, [r3, #0]
{
10baa4: 9101 str r1, [sp, #4]
remaining = rtems_configuration_get_work_space_size();
10baa6: 2b00 cmp r3, #0
10baa8: d055 beq.n 10bb56 <_Workspace_Handler_initialization+0xc6> <== NEVER TAKEN
10baaa: f647 0148 movw r1, #30792 ; 0x7848
init_or_extend = _Heap_Initialize;
unified = rtems_configuration_get_unified_work_area();
10baae: f248 12dc movw r2, #33244 ; 0x81dc
remaining = rtems_configuration_get_work_space_size();
10bab2: f2c0 0111 movt r1, #17
unified = rtems_configuration_get_unified_work_area();
10bab6: f2c0 0211 movt r2, #17
overhead = _Heap_Area_overhead( page_size );
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
10baba: f8d8 3000 ldr.w r3, [r8]
remaining = rtems_configuration_get_work_space_size();
10babe: 680f ldr r7, [r1, #0]
unified = rtems_configuration_get_unified_work_area();
10bac0: 7812 ldrb r2, [r2, #0]
remaining = rtems_configuration_get_work_space_size();
10bac2: 4407 add r7, r0
unified = rtems_configuration_get_unified_work_area();
10bac4: 9200 str r2, [sp, #0]
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
10bac6: 2b00 cmp r3, #0
10bac8: d041 beq.n 10bb4e <_Workspace_Handler_initialization+0xbe> <== ALWAYS TAKEN
10baca: 2500 movs r5, #0
init_or_extend = _Heap_Initialize;
10bacc: f648 698d movw r9, #36493 ; 0x8e8d
} else {
size = 0;
}
}
space_available = ( *init_or_extend )(
10bad0: f242 7ad8 movw sl, #10200 ; 0x27d8
init_or_extend = _Heap_Initialize;
10bad4: f2c0 0910 movt r9, #16
space_available = ( *init_or_extend )(
10bad8: f2c0 0a20 movt sl, #32
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
10badc: 462e mov r6, r5
10bade: e01b b.n 10bb18 <_Workspace_Handler_initialization+0x88>
size = remaining < free_size - overhead ?
10bae0: f1ab 0316 sub.w r3, fp, #22
remaining + overhead : free_size;
10bae4: 42bb cmp r3, r7
10bae6: bf88 it hi
10bae8: f107 0b16 addhi.w fp, r7, #22
space_available = ( *init_or_extend )(
10baec: 2308 movs r3, #8
10baee: 465a mov r2, fp
10baf0: 4650 mov r0, sl
10baf2: 47c8 blx r9
RTEMS_INLINE_ROUTINE void _Memory_Consume(
Memory_Area *area,
uintptr_t consume
)
{
area->free = (char *) area->free + consume;
10baf4: 6863 ldr r3, [r4, #4]
page_size
);
_Memory_Consume( area, size );
if ( space_available < remaining ) {
10baf6: 42b8 cmp r0, r7
remaining -= space_available;
} else {
remaining = 0;
}
init_or_extend = extend;
10baf8: bf39 ittee cc
10bafa: f8dd 9004 ldrcc.w r9, [sp, #4]
remaining -= space_available;
10bafe: 1a3f subcc r7, r7, r0
init_or_extend = extend;
10bb00: f8dd 9004 ldrcs.w r9, [sp, #4]
remaining = 0;
10bb04: 2700 movcs r7, #0
10bb06: eb03 020b add.w r2, r3, fp
10bb0a: f8d8 3000 ldr.w r3, [r8]
10bb0e: 6062 str r2, [r4, #4]
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
10bb10: 3601 adds r6, #1
10bb12: 350c adds r5, #12
10bb14: 429e cmp r6, r3
10bb16: d21a bcs.n 10bb4e <_Workspace_Handler_initialization+0xbe> <== NEVER TAKEN
return &information->areas[ index ];
10bb18: f8d8 4004 ldr.w r4, [r8, #4]
10bb1c: 442c add r4, r5
return (uintptr_t) area->end - (uintptr_t) area->free;
10bb1e: e9d4 1201 ldrd r1, r2, [r4, #4]
10bb22: eba2 0b01 sub.w fp, r2, r1
if ( free_size > overhead ) {
10bb26: f1bb 0f16 cmp.w fp, #22
10bb2a: d9f1 bls.n 10bb10 <_Workspace_Handler_initialization+0x80>
if ( unified ) {
10bb2c: 9b00 ldr r3, [sp, #0]
10bb2e: 2b00 cmp r3, #0
10bb30: d1dc bne.n 10baec <_Workspace_Handler_initialization+0x5c>
if ( remaining > 0 ) {
10bb32: 2f00 cmp r7, #0
10bb34: d1d4 bne.n 10bae0 <_Workspace_Handler_initialization+0x50> <== NEVER TAKEN
space_available = ( *init_or_extend )(
10bb36: 2308 movs r3, #8 <== NOT EXECUTED
10bb38: 463a mov r2, r7 <== NOT EXECUTED
10bb3a: 4650 mov r0, sl <== NOT EXECUTED
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
10bb3c: 3601 adds r6, #1 <== NOT EXECUTED
space_available = ( *init_or_extend )(
10bb3e: 47c8 blx r9 <== NOT EXECUTED
if ( space_available < remaining ) {
10bb40: f8d8 3000 ldr.w r3, [r8] <== NOT EXECUTED
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
10bb44: 350c adds r5, #12 <== NOT EXECUTED
init_or_extend = extend;
10bb46: f8dd 9004 ldr.w r9, [sp, #4] <== NOT EXECUTED
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
10bb4a: 429e cmp r6, r3 <== NOT EXECUTED
10bb4c: d3e4 bcc.n 10bb18 <_Workspace_Handler_initialization+0x88> <== NOT EXECUTED
}
}
if ( remaining > 0 ) {
10bb4e: b92f cbnz r7, 10bb5c <_Workspace_Handler_initialization+0xcc>
_Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE );
}
_Heap_Protection_set_delayed_free_fraction( &_Workspace_Area, 1 );
}
10bb50: b003 add sp, #12
10bb52: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
remaining = rtems_configuration_get_work_space_size();
10bb56: f002 fcab bl 10e4b0 <rtems_configuration_get_stack_space_size>
10bb5a: e7a6 b.n 10baaa <_Workspace_Handler_initialization+0x1a>
_Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE );
10bb5c: 2002 movs r0, #2
10bb5e: f7fd faf3 bl 109148 <_Internal_error>
10bb62: bf00 nop