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